基于OpenGL编写一个简易的2D渲染框架-07 鼠标事件和键盘事件

Posted 2020-09-19 为了邮箱5

这次为程序添加鼠标事件和键盘事件

 

　　当检测到鼠标事件和键盘事件的信息时，捕获其信息并将信息传送到需要信息的对象处理。为此，需要一个可以分派信息的对象，这个对象能够正确的把信息交到正确的对象。

 

实现思路：

　　要实现以上的功能，需要几个对象：

　　　　事件分派器：EventDispatcher，负责将 BaseEvent 分派给 EventListener 对象

　　　　事件监听器：EventListener，这只是一个接口类，接受 BaseEvent 的对象，真正的处理在它的子类中实现

　　　　事件：BaseEvent，储存用户数据，事件信息载体

　　假设我要分派一个 BaseEvent， 那么我应该将 BaseEvent 分派给哪个监听器 EventListener ？可以在 BaseEvent 上添加一个 ID，通过这个 ID 将 BaseEvent 分派到对应 ID 的监听器。

　　有这样一个场景，有 A、B、C、D 四个监听器，需要把 ID 为 5 的 BaseEvent 分派给 A、B 监听器，而 C、D 监听器不需要接受这个 BaseEvent。

这时可以创建一个映射表，存储有 ID 和 监听器之间的联系信息

typedef std::map<int, std::list<EventListener*>> ListenerGroup;

A、B 需要监听 ID 为 5 的 BaseEvent，就把 A、B 注册到这个表中，表中就有了 5-A、B 这样的信息。事件分派器就能根据这个表将 ID 为 5 的 BaseEvent 分派到需要监听这个 BaseEvent 的监听器 A 和 B。对于 C、D 监听器，只能监听到对应 ID 的 BaseEvent，实现思路就这样。

　　

代码实现：

　　BaseEvent 结构如下

    struct BaseEvent
    {
        int nEventID;                    /* 事件 ID */
        int nParams[MAX_EVENT_PARAM];    /* 自定义参数 */
        void* pUserData;                 /* 用户数据 */
    };

nParams 用来储存几个自定义参数，对于其他数据就用 void 指针储存，需要时转换一下就可以了。

 

事件分派器有两个属性，分别是 事件池 和 ID-监听器表，事件池主要是用来储存所有要分派的事件

        std::list<BaseEvent> vEventPool;
        ListenerGroup listenerGroup;

接下来是监听器的实现

    class DLL_export EventListener
    {
        friend class EventDispatcher;

    public:
        EventListener();
        virtual ~EventListener() {}

    protected:
        void appendListener(int eventID, EventListener* listener);
        void removeListener(int eventID, EventListener* listener);

        virtual void handleEvent(const BaseEvent& event) = 0;

    private:
        static unsigned int nIDCounter;
        unsigned int nID;
    };

主要有三个函数，用于将监听器注册到 ID-监听器表和从 ID-监听器表中移除监听器，最后一个是处理 BaseEvent 的函数，这是一个抽象函数，表示在子类中实现处理函数。

将监听器注册到表中，需要一个监听器要监听的 BaseEvent ID 以及监听器本身

    void EventListener::appendListener(int eventID, EventListener* new_listener)
    {
        auto listenerList = pDispatcher->listenerGroup.find(eventID);

        /* 事件 ID 没有监听列表？为 ID 创建监听列表，添加 eListener */
        if ( listenerList == pDispatcher->listenerGroup.end() ) {
            std::list<EventListener*> newListenerList;
            newListenerList.push_back(new_listener);
            pDispatcher->listenerGroup.insert(std::make_pair(eventID, newListenerList));
        }
        else {
            /* 如果监听列表中没有监听器，添加监听器到列表中 */
            std::list<EventListener*>::iterator listener_it;
            for ( listener_it = listenerList->second.begin(); listener_it != listenerList->second.end(); ++listener_it ) {
                if ( (*listener_it)->nID == new_listener->nID ) return;
            }
            if ( listener_it == listenerList->second.end() ) {
                listenerList->second.push_back(new_listener);
            }
        }
    }

先判断该 ID 的 BaseEvent 是否有一张表了，如果没有就新建表，然后将监听器添加到表中。

将监听器中表中移除

    void EventListener::removeListener(int eventID, EventListener* listener)
    {
        auto listenerList = pDispatcher->listenerGroup.find(eventID);
        if ( listenerList == pDispatcher->listenerGroup.end() ) return;

        /* 从监听列表中移除监听器 */
        for ( auto it = listenerList->second.begin(); it != listenerList->second.end(); ++it ) {
            if ( (*it)->nID == listener->nID ) {
                listenerList->second.erase(it);
                break;
            }
        }
        /* 移除空监听列表 */
        if ( listenerList->second.empty() ) {
            pDispatcher->listenerGroup.erase(listenerList);
        }
    }

 

如果要分派一个 BaseEvent，先将其添加到分派器中

    void EventDispatcher::dispatchEvent(const BaseEvent& event)
    {
        /* 只是暂时添加事件到事件池中，并没有立即分派事件，避免递归分派错误 */
        vEventPool.push_back(event);
    }

这里没有立即将 BaseEvent 交给对应的监听器处理，是因为如果处理函数中有将 BaseEvent 添加到事件分派器中的操作，会发生递归错误。所以就将 BaseEvent 添加到一个事件池中，稍后在函数 flushEvent 中统一分派

    void EventDispatcher::flushEvent()
    {
        if ( vEventPool.empty() ) return;

        /* 分派事件池中的所有事件 */
        for ( auto& event : vEventPool ) {
            this->realDispatchEvent(event);
        }
        vEventPool.clear();
    }

分派每一个 BaseEvent，需要找到其对应的监听表，再交给表中的监听器处理

    void EventDispatcher::realDispatchEvent(const BaseEvent& event)
    {
        auto listenerList_it = listenerGroup.find(event.nEventID);
        if ( listenerList_it != listenerGroup.end() ) {
            std::list<EventListener*>& listenerList = listenerList_it->second;
            for ( auto listener_it : listenerList ) {
                listener_it->handleEvent(event);
            }
        }
    }

以上就实现了一个事件分派模块，费如此大的一番功夫，是为了让它不仅仅分派鼠标和键盘事件，还可以分派其他需要的事件。

 

鼠标事件和键盘事件处理

　　为鼠标事件和键盘事件分别定义事件 ID

    enum EventType 
    { 
        ET_UNKNOWN,            /* 未知事件 */
        ET_MOUSE,              /* 鼠标事件 */
        ET_KEY                 /* 按键事件 */
    };

　　

　　先实现鼠标事件的处理，定义一个鼠标监听器类，继承于事件监听器

    class DLL_export MouseEventListener : public EventListener
    {
    public:
        MouseEventListener();
        virtual ~MouseEventListener();

        virtual void mouseMove(const MouseEvent& event) {}
        virtual void mousePress(const MouseEvent& event) {}
        virtual void mouseRelease(const MouseEvent& event) {}
        virtual void mouseDoubleClick(const MouseEvent& event) {}
        virtual void mouseWheel(const MouseEvent& event) {}

        void handleEvent(const BaseEvent& event);
    };

在构造函数和析构函数中，主要是注册监听器到事件分派器和从事件分派器中移除监听器

    MouseEventListener::MouseEventListener()
    {
        this->appendListener(EventType::ET_MOUSE, this);
    }

    MouseEventListener::~MouseEventListener()
    {
        this->removeListener(EventType::ET_MOUSE, this);
    }

 

鼠标事件分别有按键按下、释放、双击、鼠标移动和滚轮滑动等动作

    enum EventAction
    {
        ACT_MOVE,             /* 移动 */
        ACT_PRESS,            /* 按压 */
        ACT_RELAESE,          /* 释放 */
        ACT_DUBBLE_CLICK,     /* 双击 */
        ACT_SCROLL            /* 滚动 */
    };

 

以及按钮类型，左键、右键和中键

    enum ButtonType 
    { 
        LEFT_BUTTON,         /* 鼠标左键 */
        RIGHT_BUTTON,        /* 鼠标右键 */
        MIDDLE_BUTTON        /* 鼠标中键 */
    };

 

对于一个鼠标事件，需要的数据信息如下

    /* 鼠标事件  */
    struct MouseEvent
    {
        EventAction eventAction;
        ButtonType buttonType;
        int nDelta;
        int nX, nY;
    };

动作类型、按钮类型、滚轮滚动数据和坐标数据。

 

为了捕捉窗口程序的鼠标信息，定义一个窗口信息处理类

    //------------------------------------------------------------------
    // WinMsgHandle
    // 窗口信息处理
    //------------------------------------------------------------------
    class WinMsgHandle
    {
    public:
        WinMsgHandle();

        void handleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

    private:
        BaseEvent baseEvent;

        KeyEvent keyEvent;
        MouseEvent mouseEvent;
    };

函数 handleMessage 主要捕捉窗口信息

    void WinMsgHandle::handleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        baseEvent.nEventID = ET_UNKNOWN;

        /* 鼠标事件信息  */
        if ( msg >= WM_MOUSEMOVE && msg <= WM_MBUTTONDBLCLK || msg == WM_MOUSEWHEEL ) {
            switch ( msg ) {
            case WM_LBUTTONDOWN:
                mouseEvent.buttonType = ButtonType::LEFT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_PRESS;
                break;
            case WM_LBUTTONUP:
                mouseEvent.buttonType = ButtonType::LEFT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_RELAESE;
                break;
            case WM_LBUTTONDBLCLK:
                mouseEvent.buttonType = ButtonType::LEFT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_DUBBLE_CLICK;
                break;
            case WM_MBUTTONDOWN:
                mouseEvent.buttonType = ButtonType::MIDDLE_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_PRESS;
                break;
            case WM_MBUTTONUP:
                mouseEvent.buttonType = ButtonType::MIDDLE_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_RELAESE;
                break;
            case WM_MBUTTONDBLCLK:
                mouseEvent.buttonType = ButtonType::MIDDLE_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_DUBBLE_CLICK;
                break;
            case WM_RBUTTONDOWN:
                mouseEvent.buttonType = ButtonType::RIGHT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_PRESS;
                break;
            case WM_RBUTTONUP:
                mouseEvent.buttonType = ButtonType::RIGHT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_RELAESE;
                break;
            case WM_RBUTTONDBLCLK:
                mouseEvent.buttonType = ButtonType::RIGHT_BUTTON;
                mouseEvent.eventAction = EventAction::ACT_DUBBLE_CLICK;
                break;
            case WM_MOUSEMOVE:
                mouseEvent.eventAction = EventAction::ACT_MOVE;
                break;
            case WM_MOUSEWHEEL:
                mouseEvent.eventAction = EventAction::ACT_SCROLL;
                mouseEvent.nDelta = ( short ) HIWORD(wParam);
                break;
            }
            mouseEvent.nX = ( short ) LOWORD(lParam);
            mouseEvent.nY = ( short ) HIWORD(lParam);
            baseEvent.nEventID = ET_MOUSE;
            baseEvent.pUserData = &mouseEvent;
            EventDispatcher::getInstance()->dispatchEvent(baseEvent);
        }
    }

主要是获取鼠标事件数据 MouseEvent，然后将数据附加到 BaseEvent 上，设置其 ID 为 鼠标事件ID——ET_MOUSE，最后由事件分派器分派 BaseEvent。

当鼠标事件监听器处理 BaseEvent 时，需要获取 MouseEvent 数据，然后根据按钮类型和动作类型调用相应函数

    void MouseEventListener::handleEvent(const BaseEvent& event)
    {
        if ( event.nEventID != EventType::ET_MOUSE && event.pUserData ) return;

        MouseEvent* mouseEvent = static_cast<MouseEvent*>(event.pUserData);

        switch ( mouseEvent->eventAction ) {
        case Simple2D::ACT_MOVE:         this->mouseMove(*mouseEvent);        break;
        case Simple2D::ACT_PRESS:        this->mousePress(*mouseEvent);       break;
        case Simple2D::ACT_RELAESE:      this->mouseRelease(*mouseEvent);     break;
        case Simple2D::ACT_SCROLL:       this->mouseWheel(*mouseEvent);       break;
        case Simple2D::ACT_DUBBLE_CLICK: this->mouseDoubleClick(*mouseEvent); break;
        }
    }

当然这些函数都没有具体的实现，具体的实现由子类完成。

 

对于键盘事件，只有两个按键动作按压和释放，及事件的数据结构体

    /* 按键事件 */
    struct KeyEvent
    {
        EventAction eventAction;
        bool keys[256];
        KeyType keyType;
    };

bool 类型的按键数组 keys 储存哪一个按键被按下的信息，当同时有多个按键按压时也可以检测。而 KeyType 就记录了当前按压的按键类型，这里并不包括键盘上的所有按键，只包含字母键、数字键和其它常用按键。

    /*
    * VK_0 - VK_9 are the same as ASCII \'0\' - \'9\' (0x30 - 0x39)
    * 0x40 : unassigned
    * VK_A - VK_Z are the same as ASCII \'A\' - \'Z\' (0x41 - 0x5A)
    */
    enum KeyType
    {
        Key_Unknown,

        Key_Space = 0x20,
        Key_Prior,
        Key_Next,
        Key_End,
        Key_Home,
        Key_Left,
        Key_Up,
        Key_Right,
        Key_Down,
        Key_Select,
        Key_Print,
        Key_Execute,
        Key_Snapshot,
        Key_Insert,
        Key_Delete,
        Key_Help,

        /* 主键盘上的数字键 */
        Key_0 = 0x30,
        Key_1,
        Key_2,
        Key_3,
        Key_4,
        Key_5,
        Key_6,
        Key_7,
        Key_8,
        Key_9,

        Key_A = 0x41,
        Key_B,
        Key_C,
        Key_D,
        Key_E,
        Key_F,
        Key_G,
        Key_H,
        Key_I,
        Key_J,
        Key_K,
        Key_L,
        Key_M,
        Key_N,
        Key_O,
        Key_P,
        Key_Q,
        Key_R,
        Key_S,
        Key_T,
        Key_U,
        Key_V,
        Key_W,
        Key_X,
        Key_Y,
        Key_Z,

        /* 小键盘上的数字 */
        Key_NumPad_0 = 0x60,
        Key_NumPad_1,
        Key_NumPad_2,
        Key_NumPad_3,
        Key_NumPad_4,
        Key_NumPad_5,
        Key_NumPad_6,
        Key_NumPad_7,
        Key_NumPad_8,
        Key_NumPad_9,

        Key_F1 = 0x70,
        Key_F2,
        Key_F3,
        Key_F4,
        Key_F5,
        Key_F6,
        Key_F7,
        Key_F8,
        Key_F9,
        Key_F10,
        Key_F11,
        Key_F12,
        Key_F13,
        Key_F14,
        Key_F15,
        Key_F16,
        Key_F17,
        Key_F18,
        Key_F19,
        Key_F20,
        Key_F21,
        Key_F22,
        Key_F23,
        Key_F24,
    };

 

键盘事件监听器定义

    class DLL_export KeyEventListener : public EventListener
    {
    public:
        KeyEventListener();
        virtual ~KeyEventListener();

        virtual void keyPress(const KeyEvent& event) {}
        virtual void keyRelease(const KeyEvent& event) {}

        void handleEvent(const BaseEvent& event);
    };

 

对于按键信息的捕捉，和鼠标事件一样在 handleMessage 函数中，这里只截取了键盘事件

    void WinMsgHandle::handleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        baseEvent.nEventID = ET_UNKNOWN;/* 键盘按键事件信息 */
        if ( msg == WM_KEYDOWN || msg == WM_KEYUP ) {
            keyEvent.eventAction = (msg == WM_KEYDOWN) ? EventAction::ACT_PRESS : EventAction::ACT_RELAESE;
            keyEvent.keyType = keyMap(( UINT ) wParam);
            keyEvent.keys[( UINT ) wParam] = (msg == WM_KEYDOWN) ? true : false;

            baseEvent.nEventID = ET_KEY;
            baseEvent.pUserData = &keyEvent;
            EventDispatcher::getInstance()->dispatchEvent(baseEvent);
        }
    }

和鼠标事件一样，获取按键数据 KeyEvent，然后附加到 BaseEvent 中，设置其 ID 为 ET_KEY，最后由分派器分派事件。按键事件监听器处理 BaseEvent 时，根据动作类型调用相应函数，其函数有子类实现。

    void KeyEventListener::handleEvent(const BaseEvent& event)
    {
        if ( event.nEventID != EventType::ET_KEY && event.pUserData ) return;

        KeyEvent* keyEvent = static_cast<KeyEvent*>(event.pUserData);

        switch ( keyEvent->eventAction ) {
        case Simple2D::ACT_PRESS:      this->keyPress(*keyEvent);        break;
        case Simple2D::ACT_RELAESE:    this->keyRelease(*keyEvent);      break;
        }
    }

 

最后在窗口的 proc 函数中

        /* 处理鼠标和按键事件  */
        if ( self ) {
            self->winMsgHandle.handleMessage(wnd, msg, wParam, lParam);
        }

 

主循环中分派所有事件

        if ( PeekMessage(&msg, 0, 0, 0, PM_REMOVE) ) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);

            EventDispatcher::getInstance()->flushEvent();
        }

 

新建一个测试类，继承与鼠标事件监听器和按键事件监听器，实现监听器中的函数，输出到输出窗口

class EventTest : public MouseEventListener, public KeyEventListener
{
public:
    //void mouseMove(const MouseEvent& event)
    //{
    //    log("mouse move");
    //    log("x:%d - y:%d", event.nX, event.nY);
    //}

    void mousePress(const MouseEvent& event)
    {
        if ( event.buttonType == ButtonType::LEFT_BUTTON ) {
            log("left button press");
        }
        else if ( event.buttonType == ButtonType::MIDDLE_BUTTON ) {
            log("middle button press");
        }
        else if ( event.buttonType == ButtonType::RIGHT_BUTTON ) {
            log("right button press");
        }
        log("x:%d - y:%d", event.nX, event.nY);
    }

    void mouseRelease(const MouseEvent& event)
    {
        log("mouse release");
        log("x:%d - y:%d", event.nX, event.nY);
    }

    void mouseDoubleClick(const MouseEvent& event)
    {
        log("mouse double click");
        log("x:%d - y:%d", event.nX, event.nY);
    }

    void mouseWheel(const MouseEvent& event)
    {
        log("mouse wheel");
        log("delta: %d", event.nDelta);
    }

    void keyPress(const KeyEvent& event)
    {
        if ( event.keys[KeyType::Key_A] && event.keys[KeyType::Key_S] ) {
            log("同时按下 AS");
        }
    }

    void keyRelease(const KeyEvent& event)
    {
        if ( event.keyType == KeyType::Key_NumPad_1 ) {
            log("释放键 1");
        }
    }
};

 

运行程序的结果

 

源码下载：http://pan.baidu.com/s/1skOmP21