how does the EventKeyboard class get the pressed key?

[10100010010001001010]

I see that the class constructor receives the keyCode and isPressed variables, but I can't figure out where it gets the information about whether the key is pressed or not.

I'm trying to understand how the EventListener works under the hood (I need this to study, because I haven't come across lambdas and std::function yet), but I also don't see where the information about the pressed key comes from.

[rh101]

You haven't mentioned what it is exactly that you are attempting to achieve.

If you need to know how something works, then you have several options. The easiest would be to be to run the application, put a breakpoint on where the event is sent out, and look at the call stack from there. Follow the calls up to see where the information came from. The source of the input is most likely platform specific, so the calls that send out the events will change depending on which platform you're running the application on.

For example, this is one implementation:

void GLViewImpl::onGLFWKeyCallback(GLFWwindow* /*window*/, int key, int /*scancode*/, int action, int /*mods*/)
{
    // x-studio spec, for repeat press key support.
    EventKeyboard event(g_keyCodeMap[key], action); <-- this is where the EventKeyboard is created
    auto dispatcher = Director::getInstance()->getEventDispatcher();
    dispatcher->dispatchEvent(&event); <-- this is where it's dispatched
...
}

Just search the source code for "EventKeyboard"; it's all there.

[10100010010001001010]

I've already seen this part, but I still can't figure out the connection between the code above and this one:

//Listener's init method 

bool EventListenerKeyboard::init()
{
     auto listener = [this](Event* event) 
     {
        auto keyboardEvent = static_cast<EventKeyboard*>(event); 
        if (keyboardEvent->_isPressed)
        {
            if (onKeyPressed != nullptr)
                onKeyPressed(keyboardEvent->_keyCode, event);
        }
        else
        {
            if (onKeyReleased != nullptr)
                onKeyReleased(keyboardEvent->_keyCode, event);
        }
     };
}

//keyboard control implementation
     auto listener = EventListenerKeyboard::create();
     listener->onKeyPressed = CC_CALLBACK_2(KeyboardTest::onKeyPressed, this);

     _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

     void KeyboardTest::onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event)
     {
             log("Key with keycode %d pressed", keyCode);
     }

It looks to me like they get arguments from nowhere. As for the call stack, I don't see what is sending the data, I only see the result that is already coming. I work in visual studio.

P.S. By the way, as I understand it, the keys are read in any case, even if you do not implement control in the project.

[rh101]

I don't understand what you mean. What values are you referring to?

As I mentioned earlier, the debugger is the best way to trace exactly where the data is coming from, so I'm a loss as to why you're asking questions like this when you could easily get the answers to them yourself. The source code is all there, and it's relatively straightforward to follow what is going on in it.

On Windows, the keyboard inputs come from GLViewImpl, if that is what you're actually looking for. It's all there in the code, you're just not taking the time to go through it.

[10100010010001001010]

Don't accuse me of wanting a ready-made answer without making any effort to find the answer. I just answered your last message without asking for help or tips. I mean Event in the arguments, the call stack shows the value that has already arrived, but not who sent it.

[rh101]

Look, there is no accusation or the like; there's just confusion here.

If you are referring to Event* event in onKeyPressed(EventKeyboard::KeyCode keyCode, Event* event), then if you actually checked the code, you would see this:

The event is of type EventKeyboard, which is declared as follows:

class AX_DLL EventKeyboard : public Event
{
...
}

If you look at the constructor for EventKeyboard, you would see this:

EventKeyboard::EventKeyboard(KeyCode keyCode, bool isPressed)
    : Event(Type::KEYBOARD), _keyCode(keyCode), _isPressed(isPressed)
{}

The important bit of information in that constructor is Event(Type::KEYBOARD).

So, knowing all of this, including what I mentioned in my initial response, the events get sent from here on Windows:

void GLViewImpl::onGLFWKeyCallback(GLFWwindow* /*window*/, int key, int /*scancode*/, int action, int /*mods*/)
{
    // x-studio spec, for repeat press key support.
    EventKeyboard event(g_keyCodeMap[key], action); <-- this is where the EventKeyboard is created
    auto dispatcher = Director::getInstance()->getEventDispatcher();
    dispatcher->dispatchEvent(&event); <-- this is where it's dispatched
...
}

If you search for Type::KEYBOARD, you would find yourself in EventKeyboardListener, and more specifically, here:

bool EventListenerKeyboard::init()
{
    auto listener = [this](Event* event) {
        auto keyboardEvent = static_cast<EventKeyboard*>(event);
        if (keyboardEvent->_isPressed)
        {
            if (onKeyPressed != nullptr)
                onKeyPressed(keyboardEvent->_keyCode, event);
        }
        else
        {
            if (onKeyReleased != nullptr)
                onKeyReleased(keyboardEvent->_keyCode, event);
        }
    };

    if (EventListener::init(Type::KEYBOARD, LISTENER_ID, listener)) <<<<< Notice "Type::KEYBOARD"
    {
        return true;
    }

    return false;
}

So, if you look closely at that EventListenerKeyboard::init(), you'll see this:

auto listener = [this](Event* event) {
        auto keyboardEvent = static_cast<EventKeyboard*>(event);
        if (keyboardEvent->_isPressed)
        {
            if (onKeyPressed != nullptr)
                onKeyPressed(keyboardEvent->_keyCode, event);
        }
...
}

So, when GLViewImpl::onGLFWKeyCallback sends out an event of type EventKeyboard, the EventListenerKeyboard catches it, and since it's of the same type, being Type::KEYBOARD, it passes that EventKeyboard to onKeyPressed:

onKeyPressed(keyboardEvent->_keyCode, event);

That is where event comes from.

So, as I mentioned earlier, it is all there in the code, and this is something you could have tracked down yourself.

[aismann]

@10100010010001001010
You can also have a look on the cocos2dx documentation:
https://docs.cocos.com/cocos2d-x/manual/en/event_dispatcher/keyboard.html

[10100010010001001010]

I usually start with this, but the documentation is too superficial

[aismann]

I usually start with this, but the documentation is too superficial

Just search the source code for "EventKeyboard"; it's all there.

[DelinWorks]

@10100010010001001010 or you can view the cpp_tests, a lot of the examples there are pretty useful!