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

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

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

实现思路：

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

　　　　事件分派器：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");}}
};