Sirrf - Simple Irrlicht Framework: core/EventManager.cpp Source File

00001 // /////////////////////////////////////////////////////////////////////////////
00002 //
00003 // Name:            EventManager.cpp
00004 // Author:          Michael Bartsch (ZCCdark203)
00005 //
00006 // Desc :           The Event Manager is the central interface point to all
00007 //                  event related functions of this program.
00008 //
00009 // License:         Copyright (C) 2009 Michael Bartsch and Contributors
00010 //
00011 //                  This program is free software: you can redistribute it
00012 //                  and/or modify it under the terms of the zlib/libpng License.
00013 //                  See main.cpp for conditions of distribution and use.
00014 //
00015 // /////////////////////////////////////////////////////////////////////////////
00016 
00017 // Include files
00018 #include "EventManager.h"
00019 
00020 
00021 // EventManager class
00022 // EventManager constructor.
00023 EventManager::EventManager()
00024 {
00025     init();
00026 }
00027 
00028 // EventManager deconstructor.
00029 EventManager::~EventManager()
00030 {
00031     clear();
00032 }
00033 
00034 // Initialises the Event Manager.
00035 void EventManager::init()
00036 {
00037     generateKeyMap();
00038 
00039     // Create the event group for the Event Manager. This group should take care of core events.
00040     createEventGroup("EventManager");
00041     std::map<std::string, EventSlot> &eventGroup = mEvents["EventManager"];
00042 
00043     // Add mouse events.
00044     createEventSlot("EventManager", "onMouseMoved");
00045     createEventSlot("EventManager", "onMouseDown#Left");
00046     createEventSlot("EventManager", "onMouseDown#Right");
00047     createEventSlot("EventManager", "onMouseDown#Middle");
00048     createEventSlot("EventManager", "onMouseUp#Left");
00049     createEventSlot("EventManager", "onMouseUp#Right");
00050     createEventSlot("EventManager", "onMouseUp#Middle");
00051     createEventSlot("EventManager", "onMouseWheel");
00052 
00053     // Add event slots to the event group.
00054     std::string strOnKeyDown = "onKeyDown#";
00055     std::string strOnKeyUp = "onKeyUp#";
00056 
00057     std::map<EKEY_CODE, std::string>::iterator it;
00058     for(it = mKeyMap.begin(); it != mKeyMap.end(); it++)
00059     {
00060         EventSlot slot1, slot2;
00061         eventGroup[strOnKeyDown + it->second] = slot1;
00062         eventGroup[strOnKeyUp + it->second] = slot2;
00063     }
00064 }
00065 
00066 // Clears the Event Manager.
00067 void EventManager::clear()
00068 {
00069     mEvents.clear();
00070 }
00071 
00072 // Generates a string-based keymap, so that keys can be used by the event manager.
00073 void EventManager::generateKeyMap()
00074 {
00075 #define addToKeyMap(x) mKeyMap[x] = #x
00076     addToKeyMap(KEY_LBUTTON);
00077     addToKeyMap(KEY_RBUTTON);
00078     addToKeyMap(KEY_CANCEL);
00079     addToKeyMap(KEY_MBUTTON);
00080     addToKeyMap(KEY_XBUTTON1);
00081     addToKeyMap(KEY_XBUTTON2);
00082     addToKeyMap(KEY_BACK);
00083     addToKeyMap(KEY_TAB);
00084     addToKeyMap(KEY_CLEAR);
00085     addToKeyMap(KEY_RETURN);
00086     addToKeyMap(KEY_SHIFT);
00087     addToKeyMap(KEY_CONTROL);
00088     addToKeyMap(KEY_MENU);
00089     addToKeyMap(KEY_PAUSE);
00090     addToKeyMap(KEY_CAPITAL);
00091     addToKeyMap(KEY_KANA);
00092     addToKeyMap(KEY_HANGUEL);
00093     addToKeyMap(KEY_HANGUL);
00094     addToKeyMap(KEY_JUNJA);
00095     addToKeyMap(KEY_FINAL);
00096     addToKeyMap(KEY_HANJA);
00097     addToKeyMap(KEY_KANJI);
00098     addToKeyMap(KEY_ESCAPE);
00099     addToKeyMap(KEY_CONVERT);
00100     addToKeyMap(KEY_NONCONVERT);
00101     addToKeyMap(KEY_ACCEPT);
00102     addToKeyMap(KEY_MODECHANGE);
00103     addToKeyMap(KEY_SPACE);
00104     addToKeyMap(KEY_PRIOR);
00105     addToKeyMap(KEY_NEXT);
00106     addToKeyMap(KEY_END);
00107     addToKeyMap(KEY_HOME);
00108     addToKeyMap(KEY_LEFT);
00109     addToKeyMap(KEY_UP);
00110     addToKeyMap(KEY_RIGHT);
00111     addToKeyMap(KEY_DOWN);
00112     addToKeyMap(KEY_SELECT);
00113     addToKeyMap(KEY_PRINT);
00114     addToKeyMap(KEY_EXECUT);
00115     addToKeyMap(KEY_SNAPSHOT);
00116     addToKeyMap(KEY_INSERT);
00117     addToKeyMap(KEY_DELETE);
00118     addToKeyMap(KEY_HELP);
00119     addToKeyMap(KEY_KEY_0);
00120     addToKeyMap(KEY_KEY_1);
00121     addToKeyMap(KEY_KEY_2);
00122     addToKeyMap(KEY_KEY_3);
00123     addToKeyMap(KEY_KEY_4);
00124     addToKeyMap(KEY_KEY_5);
00125     addToKeyMap(KEY_KEY_6);
00126     addToKeyMap(KEY_KEY_7);
00127     addToKeyMap(KEY_KEY_8);
00128     addToKeyMap(KEY_KEY_9);
00129     addToKeyMap(KEY_KEY_A);
00130     addToKeyMap(KEY_KEY_B);
00131     addToKeyMap(KEY_KEY_C);
00132     addToKeyMap(KEY_KEY_D);
00133     addToKeyMap(KEY_KEY_E);
00134     addToKeyMap(KEY_KEY_F);
00135     addToKeyMap(KEY_KEY_G);
00136     addToKeyMap(KEY_KEY_H);
00137     addToKeyMap(KEY_KEY_I);
00138     addToKeyMap(KEY_KEY_J);
00139     addToKeyMap(KEY_KEY_K);
00140     addToKeyMap(KEY_KEY_L);
00141     addToKeyMap(KEY_KEY_M);
00142     addToKeyMap(KEY_KEY_N);
00143     addToKeyMap(KEY_KEY_O);
00144     addToKeyMap(KEY_KEY_P);
00145     addToKeyMap(KEY_KEY_Q);
00146     addToKeyMap(KEY_KEY_R);
00147     addToKeyMap(KEY_KEY_S);
00148     addToKeyMap(KEY_KEY_T);
00149     addToKeyMap(KEY_KEY_U);
00150     addToKeyMap(KEY_KEY_V);
00151     addToKeyMap(KEY_KEY_W);
00152     addToKeyMap(KEY_KEY_X);
00153     addToKeyMap(KEY_KEY_Y);
00154     addToKeyMap(KEY_KEY_Z);
00155     addToKeyMap(KEY_LWIN);
00156     addToKeyMap(KEY_RWIN);
00157     addToKeyMap(KEY_APPS);
00158     addToKeyMap(KEY_SLEEP);
00159     addToKeyMap(KEY_NUMPAD0);
00160     addToKeyMap(KEY_NUMPAD1);
00161     addToKeyMap(KEY_NUMPAD2);
00162     addToKeyMap(KEY_NUMPAD3);
00163     addToKeyMap(KEY_NUMPAD4);
00164     addToKeyMap(KEY_NUMPAD5);
00165     addToKeyMap(KEY_NUMPAD6);
00166     addToKeyMap(KEY_NUMPAD7);
00167     addToKeyMap(KEY_NUMPAD8);
00168     addToKeyMap(KEY_NUMPAD9);
00169     addToKeyMap(KEY_MULTIPLY);
00170     addToKeyMap(KEY_ADD);
00171     addToKeyMap(KEY_SEPARATOR);
00172     addToKeyMap(KEY_SUBTRACT);
00173     addToKeyMap(KEY_DECIMAL);
00174     addToKeyMap(KEY_DIVIDE);
00175     addToKeyMap(KEY_F1);
00176     addToKeyMap(KEY_F2);
00177     addToKeyMap(KEY_F3);
00178     addToKeyMap(KEY_F4);
00179     addToKeyMap(KEY_F5);
00180     addToKeyMap(KEY_F6);
00181     addToKeyMap(KEY_F7);
00182     addToKeyMap(KEY_F8);
00183     addToKeyMap(KEY_F9);
00184     addToKeyMap(KEY_F10);
00185     addToKeyMap(KEY_F11);
00186     addToKeyMap(KEY_F12);
00187     addToKeyMap(KEY_F13);
00188     addToKeyMap(KEY_F14);
00189     addToKeyMap(KEY_F15);
00190     addToKeyMap(KEY_F16);
00191     addToKeyMap(KEY_F17);
00192     addToKeyMap(KEY_F18);
00193     addToKeyMap(KEY_F19);
00194     addToKeyMap(KEY_F20);
00195     addToKeyMap(KEY_F21);
00196     addToKeyMap(KEY_F22);
00197     addToKeyMap(KEY_F23);
00198     addToKeyMap(KEY_F24);
00199     addToKeyMap(KEY_NUMLOCK);
00200     addToKeyMap(KEY_SCROLL);
00201     addToKeyMap(KEY_LSHIFT);
00202     addToKeyMap(KEY_RSHIFT);
00203     addToKeyMap(KEY_LCONTROL);
00204     addToKeyMap(KEY_RCONTROL);
00205     addToKeyMap(KEY_LMENU);
00206     addToKeyMap(KEY_RMENU);
00207     addToKeyMap(KEY_PLUS);
00208     addToKeyMap(KEY_COMMA);
00209     addToKeyMap(KEY_MINUS);
00210     addToKeyMap(KEY_PERIOD);
00211     addToKeyMap(KEY_ATTN);
00212     addToKeyMap(KEY_CRSEL);
00213     addToKeyMap(KEY_EXSEL);
00214     addToKeyMap(KEY_EREOF);
00215     addToKeyMap(KEY_PLAY);
00216     addToKeyMap(KEY_ZOOM);
00217     addToKeyMap(KEY_PA1);
00218     addToKeyMap(KEY_OEM_CLEAR);
00219 #undef addToKeyMap
00220 }
00221 
00222 // Angelscript: Increases the reference counter.
00223 void EventManager::refAdd()
00224 {
00225     // Dummy function.
00226 }
00227 
00228 // Angelscript: Decreases the reference counter.
00229 void EventManager::refRelease()
00230 {
00231     // Dummy function.
00232 }
00233 
00234 // Creates a new event group, a collection of events.
00235 bool EventManager::createEventGroup(const std::string &groupName)
00236 {
00237     // Check if the group doesn't already exist.
00238     std::map<std::string, std::map<std::string, EventSlot> >::iterator it;
00239     it = mEvents.find(groupName);
00240 
00241     if(it != mEvents.end())
00242        return false;
00243 
00244     // Create a new event group.
00245     std::map<std::string, EventSlot> group;
00246     mEvents[groupName] = group;
00247 
00248     return true;
00249 }
00250 
00251 // Creates a new event slot in the given event group.
00252 bool EventManager::createEventSlot(const std::string &groupName, const std::string &slotName)
00253 {
00254     // Get the given event group.
00255     std::map<std::string, std::map<std::string, EventSlot> >::iterator itGroups;
00256     itGroups = mEvents.find(groupName);
00257 
00258     if(itGroups == mEvents.end())
00259       return false;
00260 
00261     std::map<std::string, EventSlot> &group = itGroups->second;
00262 
00263     // Check if the given slot doesnt already exist.
00264     std::map<std::string, EventSlot>::iterator itSlots = group.find(slotName);
00265 
00266     if(itSlots != group.end())
00267       return false;
00268 
00269     // Create a new event slot.
00270     EventSlot slot;
00271     group[slotName] = slot;
00272 
00273     return true;
00274 }
00275 
00276 // Emits an event to the given event slot.
00277 bool EventManager::emitEvent(const std::string &groupName, const std::string &slotName, void *p)
00278 {
00279     // Get the given event group.
00280     std::map<std::string, std::map<std::string, EventSlot> >::iterator itGroups;
00281     itGroups = mEvents.find(groupName);
00282 
00283     if(itGroups == mEvents.end())
00284       return false;
00285 
00286     std::map<std::string, EventSlot> &group = itGroups->second;
00287 
00288     // Get the given event slot.
00289     std::map<std::string, EventSlot>::iterator itSlots = group.find(slotName);
00290 
00291     if(itSlots == group.end())
00292       return false;
00293 
00294     EventSlot &slot = itSlots->second;
00295 
00296     // Emit event.
00297     slot.emit(p);
00298     return true;
00299 }
00300 
00301 // Checks if the given key is down.
00302 bool EventManager::getIsKeyDown(EKEY_CODE keyCode) const
00303 {
00304     return mKeyState[keyCode];
00305 }
00306 
00307 // Checks if the given key is up.
00308 bool EventManager::getIsKeyUp(EKEY_CODE keyCode) const
00309 {
00310     return !mKeyState[keyCode];
00311 }
00312 
00313 // Returns the X-coordinate of the mouse position.
00314 s32 EventManager::getMouseX() const
00315 {
00316     return mMousePos.X;
00317 }
00318 
00319 // Returns the Y-coordinate of the mouse position.
00320 s32 EventManager::getMouseY() const
00321 {
00322     return mMousePos.Y;
00323 }
00324 
00325 // Returns the position of the mouse as a 2d vector.
00326 const vector2di& EventManager::getMousePos() const
00327 {
00328     return mMousePos;
00329 }
00330 
00331 // Gets the mouse wheel position.
00332 f32 EventManager::getMouseWheel() const
00333 {
00334     return mMouseWheel;
00335 }
00336 
00337 
00338 // Removes all event groups from the Event Manager.
00339 void EventManager::removeAllEventGroups()
00340 {
00341     // Remove all groups.
00342     mEvents.clear();
00343 }
00344 
00345 // Removes all event slots from the given event group.
00346 bool EventManager::removeAllEventSlots(const std::string &groupName)
00347 {
00348     // Get the given event group.
00349     std::map<std::string, std::map<std::string, EventSlot> >::iterator itGroups;
00350     itGroups = mEvents.find(groupName);
00351 
00352     if(itGroups == mEvents.end())
00353       return false;
00354 
00355     std::map<std::string, EventSlot> &group = itGroups->second;
00356 
00357     // Remove all slots.
00358     group.clear();
00359     return true;
00360 }
00361 
00362 // Removes the given event group from the Event Manager.
00363 bool EventManager::removeEventGroup(const std::string &groupName)
00364 {
00365     // Get the given event group.
00366     std::map<std::string, std::map<std::string, EventSlot> >::iterator itGroups;
00367     itGroups = mEvents.find(groupName);
00368 
00369     if(itGroups == mEvents.end())
00370       return false;
00371 
00372     // Remove it.
00373     mEvents.erase(itGroups);
00374     return true;
00375 }
00376 
00377 // Removes the given event slot from the given event group.
00378 bool EventManager::removeEventSlot(const std::string &groupName, const std::string &slotName)
00379 {
00380     // Get the given event group.
00381     std::map<std::string, std::map<std::string, EventSlot> >::iterator itGroups;
00382     itGroups = mEvents.find(groupName);
00383 
00384     if(itGroups == mEvents.end())
00385       return false;
00386 
00387     std::map<std::string, EventSlot> &group = itGroups->second;
00388 
00389     // Get the given event slot.
00390     std::map<std::string, EventSlot>::iterator itSlots = group.find(slotName);
00391 
00392     if(itSlots == group.end())
00393       return false;
00394 
00395     // Remove it.
00396     group.erase(itSlots);
00397     return true;
00398 }
00399 
00400 // Handles the events sent by the Irrlicht engine.
00401 bool EventManager::OnEvent(const SEvent &event)
00402 {
00403     // Keyboard event.
00404     if(event.EventType == EET_KEY_INPUT_EVENT)
00405     {
00406         // Store the value in the key map.
00407         mKeyState[event.KeyInput.Key] = event.KeyInput.PressedDown;
00408 
00409         // Emit the event.
00410         std::string slotName;
00411 
00412         if(event.KeyInput.PressedDown)
00413           slotName = "onKeyDown#";
00414 
00415         else slotName = "onKeyUp#";
00416 
00417         mEvents["EventManager"][slotName + mKeyMap[event.KeyInput.Key]].emit(0);
00418     }
00419 
00420     // Mouse event.
00421     if(event.EventType == EET_MOUSE_INPUT_EVENT)
00422     {
00423         switch(event.MouseInput.Event)
00424         {
00425            case EMIE_MOUSE_MOVED:   // Did the mouse move?
00426               mMousePos.X = event.MouseInput.X;
00427               mMousePos.Y = event.MouseInput.Y;
00428               mEvents["EventManager"]["onMouseMoved"].emit(0);
00429               break;
00430 
00431            case EMIE_LMOUSE_PRESSED_DOWN:   // Left mouse button was pressed down.
00432               mEvents["EventManager"]["onMouseDown#Left"].emit(0);
00433               break;
00434 
00435            case EMIE_RMOUSE_PRESSED_DOWN:   // Right mouse button was pressed down.
00436               mEvents["EventManager"]["onMouseDown#Right"].emit(0);
00437               break;
00438 
00439            case EMIE_MMOUSE_PRESSED_DOWN:   // Middle mouse button was pressed down.
00440               mEvents["EventManager"]["onMouseDown#Middle"].emit(0);
00441               break;
00442 
00443            case EMIE_LMOUSE_LEFT_UP:        // Left mouse button was left up.
00444               mEvents["EventManager"]["onMouseUp#Left"].emit(0);
00445               break;
00446 
00447            case EMIE_RMOUSE_LEFT_UP:        // Right mouse button was left up.
00448               mEvents["EventManager"]["onMouseUp#Right"].emit(0);
00449               break;
00450 
00451            case EMIE_MMOUSE_LEFT_UP:        // Middle mouse button was left up.
00452               mEvents["EventManager"]["onMouseUp#Middle"].emit(0);
00453               break;
00454 
00455            case EMIE_MOUSE_WHEEL:           // The mouse wheel was moved.
00456               mMouseWheel = event.MouseInput.Wheel;
00457               mEvents["EventManager"]["onMouseWheel"].emit(0);
00458               break;
00459 
00460            default: break;
00461         }
00462     }
00463 
00464     // GUI event.
00465     if(event.EventType == EET_GUI_EVENT)
00466       mEvents["EventManager"]["onGUIEvent"].emit((void*)&event);
00467 
00468     return false;
00469 }
00470 
00471 
00472 // EventManager Angelscript binding.
00473 void bindEventManager(asIScriptEngine *engine)
00474 {
00475     // Forward declarations.
00476     int r;
00477 
00478     // Bind EventManager class.
00479     r = engine->RegisterObjectType("EventManager", sizeof(EventManager), asOBJ_REF); assert(r >= 0);
00480 
00481     // Set EventManager behaviour.
00482     r = engine->RegisterObjectBehaviour("EventManager", asBEHAVE_ADDREF, "void f()",
00483                                         asMETHOD(EventManager, refAdd), asCALL_THISCALL); assert(r >= 0);
00484     r = engine->RegisterObjectBehaviour("EventManager", asBEHAVE_RELEASE, "void f()",
00485                                         asMETHOD(EventManager, refRelease), asCALL_THISCALL); assert(r >= 0);
00486 
00487     // Bind EventManager class functions.
00488     r = engine->RegisterObjectMethod("EventManager", "void init()",
00489                                      asMETHOD(EventManager, init), asCALL_THISCALL); assert(r >= 0);
00490     r = engine->RegisterObjectMethod("EventManager", "void clear()",
00491                                      asMETHOD(EventManager, clear), asCALL_THISCALL); assert(r >= 0);
00492 
00493     r = engine->RegisterObjectMethod("EventManager", "bool createEventGroup(const string &)",
00494                                      asMETHOD(EventManager, createEventGroup), asCALL_THISCALL); assert(r >= 0);
00495     r = engine->RegisterObjectMethod("EventManager", "bool createEventSlot(const string &, const string &)",
00496                                      asMETHOD(EventManager, createEventSlot), asCALL_THISCALL); assert(r >= 0);
00497 
00498     r = engine->RegisterObjectMethod("EventManager", "bool getIsKeyDown(EKEY_CODE)",
00499                                      asMETHOD(EventManager, getIsKeyDown), asCALL_THISCALL); assert(r >= 0);
00500     r = engine->RegisterObjectMethod("EventManager", "bool getIsKeyUp(EKEY_CODE)",
00501                                      asMETHOD(EventManager, getIsKeyDown), asCALL_THISCALL); assert(r >= 0);
00502 
00503     r = engine->RegisterObjectMethod("EventManager", "s32 getMouseX()",
00504                                      asMETHOD(EventManager, getMouseX), asCALL_THISCALL); assert(r >= 0);
00505     r = engine->RegisterObjectMethod("EventManager", "s32 getMouseY()",
00506                                      asMETHOD(EventManager, getMouseY), asCALL_THISCALL); assert(r >= 0);
00507     r = engine->RegisterObjectMethod("EventManager", "const vector2di& getMousePos()",
00508                                      asMETHOD(EventManager, getMousePos), asCALL_THISCALL); assert(r >= 0);
00509     r = engine->RegisterObjectMethod("EventManager", "f32 getMouseWheel()",
00510                                      asMETHOD(EventManager, getMouseWheel), asCALL_THISCALL); assert(r >= 0);
00511 
00512     r = engine->RegisterObjectMethod("EventManager", "void removeAllEventGroups()",
00513                                      asMETHOD(EventManager, removeAllEventGroups), asCALL_THISCALL); assert(r >= 0);
00514     r = engine->RegisterObjectMethod("EventManager", "bool removeAllEventSlots(const string &)",
00515                                      asMETHOD(EventManager, removeAllEventSlots), asCALL_THISCALL); assert(r >= 0);
00516     r = engine->RegisterObjectMethod("EventManager", "bool removeEventGroup(const string &)",
00517                                      asMETHOD(EventManager, removeEventGroup), asCALL_THISCALL); assert(r >= 0);
00518     r = engine->RegisterObjectMethod("EventManager", "bool removeEventSlot(const string &, const string &)",
00519                                      asMETHOD(EventManager, removeEventSlot), asCALL_THISCALL); assert(r >= 0);
00520 }
00521 
00522 // End of File.