31 #include "util/base/exception.h"
32 #include "eventchannel/key/ec_key.h"
33 #include "eventchannel/key/ec_keyevent.h"
34 #include "eventchannel/key/ec_ikeyfilter.h"
35 #include "eventchannel/mouse/ec_mouseevent.h"
36 #include "eventchannel/command/ec_command.h"
38 #include "eventmanager.h"
46 m_sdleventlisteners(),
58 void removeListener(std::deque<T>& vec, T& listener) {
59 vec.push_back(listener);
63 void addListener(std::deque<T>& vec, T& listener) {
64 vec.push_back(listener);
68 addListener<ICommandListener*>(m_pending_commandlisteners, listener);
72 addListener<ICommandListener*>(m_pending_commandlisteners, listener);
76 removeListener<ICommandListener*>(m_pending_cldeletions, listener);
80 addListener<IKeyListener*>(m_pending_keylisteners, listener);
84 addListener<IKeyListener*>(m_pending_keylisteners_front, listener);
88 removeListener<IKeyListener*>(m_pending_kldeletions, listener);
92 addListener<IMouseListener*>(m_pending_mouselisteners, listener);
96 addListener<IMouseListener*>(m_pending_mouselisteners, listener);
100 removeListener<IMouseListener*>(m_pending_mldeletions, listener);
104 addListener<ISdlEventListener*>(m_pending_sdleventlisteners, listener);
108 addListener<ISdlEventListener*>(m_pending_sdleventlisteners, listener);
112 removeListener<ISdlEventListener*>(m_pending_sdldeletions, listener);
116 if(!m_pending_commandlisteners.empty()) {
117 std::deque<ICommandListener*>::iterator i = m_pending_commandlisteners.begin();
118 while (i != m_pending_commandlisteners.end()) {
119 m_commandlisteners.push_back(*i);
122 m_pending_commandlisteners.clear();
125 if(!m_pending_commandlisteners_front.empty()) {
126 std::deque<ICommandListener*>::iterator i = m_pending_commandlisteners_front.begin();
127 while (i != m_pending_commandlisteners_front.end()) {
128 m_commandlisteners.push_front(*i);
131 m_pending_commandlisteners_front.clear();
134 if (!m_pending_cldeletions.empty()) {
135 std::deque<ICommandListener*>::iterator i = m_pending_cldeletions.begin();
136 while (i != m_pending_cldeletions.end()) {
137 std::deque<ICommandListener*>::iterator j = m_commandlisteners.begin();
138 while (j != m_commandlisteners.end()) {
140 m_commandlisteners.erase(j);
147 m_pending_cldeletions.clear();
150 std::deque<ICommandListener*>::iterator i = m_commandlisteners.begin();
151 while (i != m_commandlisteners.end()) {
152 (*i)->onCommand(command);
160 void EventManager::dispatchKeyEvent(
KeyEvent& evt) {
161 if(!m_pending_keylisteners.empty()) {
162 std::deque<IKeyListener*>::iterator i = m_pending_keylisteners.begin();
163 while (i != m_pending_keylisteners.end()) {
164 m_keylisteners.push_back(*i);
167 m_pending_keylisteners.clear();
170 if(!m_pending_keylisteners_front.empty()) {
171 std::deque<IKeyListener*>::iterator i = m_pending_keylisteners_front.begin();
172 while (i != m_pending_keylisteners_front.end()) {
173 m_keylisteners.push_front(*i);
176 m_pending_keylisteners_front.clear();
179 if (!m_pending_kldeletions.empty()) {
180 std::deque<IKeyListener*>::iterator i = m_pending_kldeletions.begin();
181 while (i != m_pending_kldeletions.end()) {
182 std::deque<IKeyListener*>::iterator j = m_keylisteners.begin();
183 while (j != m_keylisteners.end()) {
185 m_keylisteners.erase(j);
192 m_pending_kldeletions.clear();
195 std::deque<IKeyListener*>::iterator i = m_keylisteners.begin();
196 while (i != m_keylisteners.end()) {
197 switch (evt.getType()) {
198 case KeyEvent::PRESSED:
199 (*i)->keyPressed(evt);
201 case KeyEvent::RELEASED:
202 (*i)->keyReleased(evt);
211 void EventManager::dispatchMouseEvent(MouseEvent& evt) {
212 if(!m_pending_mouselisteners.empty()) {
213 std::deque<IMouseListener*>::iterator i = m_pending_mouselisteners.begin();
214 while (i != m_pending_mouselisteners.end()) {
215 m_mouselisteners.push_back(*i);
218 m_pending_mouselisteners.clear();
221 if(!m_pending_mouselisteners_front.empty()) {
222 std::deque<IMouseListener*>::iterator i = m_pending_mouselisteners_front.begin();
223 while (i != m_pending_mouselisteners_front.end()) {
224 m_mouselisteners.push_front(*i);
227 m_pending_mouselisteners_front.clear();
230 if (!m_pending_mldeletions.empty()) {
231 std::deque<IMouseListener*>::iterator i = m_pending_mldeletions.begin();
232 while (i != m_pending_mldeletions.end()) {
233 std::deque<IMouseListener*>::iterator j = m_mouselisteners.begin();
234 while (j != m_mouselisteners.end()) {
236 m_mouselisteners.erase(j);
243 m_pending_mldeletions.clear();
246 std::deque<IMouseListener*>::iterator i = m_mouselisteners.begin();
247 while (i != m_mouselisteners.end()) {
248 switch (evt.getType()) {
249 case MouseEvent::MOVED:
250 (*i)->mouseMoved(evt);
252 case MouseEvent::PRESSED:
253 (*i)->mousePressed(evt);
255 case MouseEvent::RELEASED:
256 (*i)->mouseReleased(evt);
258 case MouseEvent::WHEEL_MOVED_DOWN:
259 (*i)->mouseWheelMovedDown(evt);
261 case MouseEvent::WHEEL_MOVED_UP:
262 (*i)->mouseWheelMovedUp(evt);
264 case MouseEvent::CLICKED:
265 (*i)->mouseClicked(evt);
267 case MouseEvent::ENTERED:
268 (*i)->mouseEntered(evt);
270 case MouseEvent::EXITED:
271 (*i)->mouseExited(evt);
273 case MouseEvent::DRAGGED:
274 (*i)->mouseDragged(evt);
279 if (evt.isConsumed()) {
286 bool EventManager::dispatchSdlEvent(SDL_Event& evt) {
288 if (!m_pending_sdleventlisteners.empty()) {
289 std::deque<ISdlEventListener*>::iterator i = m_pending_sdleventlisteners.begin();
290 while(i != m_pending_sdleventlisteners.end()) {
291 m_sdleventlisteners.push_back(*i);
294 m_pending_sdleventlisteners.clear();
297 if (!m_pending_sdleventlisteners_front.empty()) {
298 std::deque<ISdlEventListener*>::iterator i = m_pending_sdleventlisteners_front.begin();
299 while(i != m_pending_sdleventlisteners_front.end()) {
300 m_sdleventlisteners.push_front(*i);
303 m_pending_sdleventlisteners_front.clear();
306 if (!m_pending_sdldeletions.empty()) {
307 std::deque<ISdlEventListener*>::iterator i = m_pending_sdldeletions.begin();
308 while (i != m_pending_sdldeletions.end()) {
309 std::deque<ISdlEventListener*>::iterator j = m_sdleventlisteners.begin();
310 while (j != m_sdleventlisteners.end()) {
312 m_sdleventlisteners.erase(j);
319 m_pending_sdldeletions.clear();
322 std::deque<ISdlEventListener*>::iterator i = m_sdleventlisteners.begin();
323 while (i != m_sdleventlisteners.end()) {
324 ret = ret || (*i)->onSdlEvent(evt);
330 bool EventManager::combineEvents(SDL_Event& event1,
const SDL_Event& event2) {
331 if(event1.type == event2.type) {
332 switch (event1.type) {
333 case SDL_MOUSEMOTION:
334 if(event1.motion.state == event2.motion.state) {
335 event1.motion.x = event2.motion.x;
336 event1.motion.y = event2.motion.y;
337 event1.motion.xrel += event2.motion.xrel;
338 event1.motion.yrel += event2.motion.yrel;
350 SDL_Event event, next_event;
351 bool has_next_event = SDL_PollEvent(&event);
352 while (has_next_event) {
353 has_next_event = SDL_PollEvent(&next_event);
354 if(has_next_event && combineEvents(event, next_event))
357 switch (event.type) {
361 cmd.setCommandType(CMD_QUIT_GAME);
366 case SDL_ACTIVEEVENT:
367 processActiveEvent(event);
372 processKeyEvent(event);
375 case SDL_MOUSEBUTTONUP:
376 case SDL_MOUSEMOTION:
377 case SDL_MOUSEBUTTONDOWN:
378 processMouseEvent(event);
386 void EventManager::processActiveEvent(SDL_Event event) {
387 if(dispatchSdlEvent(event))
392 SDL_ActiveEvent actevt =
event.active;
393 if (actevt.state == SDL_APPMOUSEFOCUS)
396 cmd.setCommandType(CMD_MOUSE_FOCUS_GAINED);
398 cmd.setCommandType(CMD_MOUSE_FOCUS_LOST);
400 else if (actevt.state == SDL_APPINPUTFOCUS)
403 cmd.setCommandType(CMD_INPUT_FOCUS_GAINED);
405 cmd.setCommandType(CMD_INPUT_FOCUS_LOST);
407 else if (actevt.state == SDL_APPACTIVE)
410 cmd.setCommandType(CMD_APP_RESTORED);
412 cmd.setCommandType(CMD_APP_ICONIFIED);
417 void EventManager::processKeyEvent(SDL_Event event) {
419 keyevt.setSource(
this);
420 fillKeyEvent(event, keyevt);
421 m_keystatemap[keyevt.getKey().getValue()] = (keyevt.getType() == KeyEvent::PRESSED);
423 bool dispatchAsSdl = !keyevt.getKey().isFunctionKey();
424 if( dispatchAsSdl && m_keyfilter ) {
425 dispatchAsSdl = !m_keyfilter->
isFiltered(keyevt);
428 if( dispatchAsSdl ) {
429 if( dispatchSdlEvent(event) )
433 dispatchKeyEvent(keyevt);
436 void EventManager::processMouseEvent(SDL_Event event) {
437 if(dispatchSdlEvent(event))
441 mouseevt.setSource(
this);
442 fillMouseEvent(event, mouseevt);
443 fillModifiers(mouseevt);
444 if (event.type == SDL_MOUSEBUTTONDOWN) {
445 m_mousestate |=
static_cast<int>(mouseevt.getButton());
446 m_mostrecentbtn = mouseevt.getButton();
447 }
else if (event.type == SDL_MOUSEBUTTONUP) {
448 m_mousestate &= ~static_cast<
int>(mouseevt.getButton());
451 if (event.button.button == SDL_BUTTON_WHEELDOWN || event.button.button == SDL_BUTTON_WHEELUP) {
452 if (event.type == SDL_MOUSEBUTTONUP) {
456 dispatchMouseEvent(mouseevt);
460 void EventManager::fillMouseEvent(
const SDL_Event& sdlevt, MouseEvent& mouseevt) {
461 mouseevt.setX(sdlevt.button.x);
462 mouseevt.setY(sdlevt.button.y);
463 mouseevt.setButton(MouseEvent::EMPTY);
464 mouseevt.setType(MouseEvent::MOVED);
465 if ((sdlevt.type == SDL_MOUSEBUTTONUP) || (sdlevt.type == SDL_MOUSEBUTTONDOWN)) {
466 switch (sdlevt.button.button) {
467 case SDL_BUTTON_LEFT:
468 mouseevt.setButton(MouseEvent::LEFT);
470 case SDL_BUTTON_RIGHT:
471 mouseevt.setButton(MouseEvent::RIGHT);
473 case SDL_BUTTON_MIDDLE:
474 mouseevt.setButton(MouseEvent::MIDDLE);
477 mouseevt.setButton(MouseEvent::UNKNOWN_BUTTON);
481 if (sdlevt.type == SDL_MOUSEBUTTONUP ) {
482 mouseevt.setType(MouseEvent::RELEASED);
484 mouseevt.setType(MouseEvent::PRESSED);
487 switch (sdlevt.button.button) {
488 case SDL_BUTTON_WHEELDOWN:
489 mouseevt.setType(MouseEvent::WHEEL_MOVED_DOWN);
491 case SDL_BUTTON_WHEELUP:
492 mouseevt.setType(MouseEvent::WHEEL_MOVED_UP);
498 if ((mouseevt.getType() == MouseEvent::MOVED) && m_mousestate) {
499 mouseevt.setType(MouseEvent::DRAGGED);
500 mouseevt.setButton(m_mostrecentbtn);
504 void EventManager::fillKeyEvent(
const SDL_Event& sdlevt, KeyEvent& keyevt) {
505 if (sdlevt.type == SDL_KEYDOWN) {
506 keyevt.setType(KeyEvent::PRESSED);
507 }
else if (sdlevt.type == SDL_KEYUP) {
508 keyevt.setType(KeyEvent::RELEASED);
510 throw EventException(
"Invalid event type in fillKeyEvent");
512 SDL_keysym keysym = sdlevt.key.keysym;
514 keyevt.setShiftPressed(keysym.mod & KMOD_SHIFT);
515 keyevt.setControlPressed(keysym.mod & KMOD_CTRL);
516 keyevt.setAltPressed(keysym.mod & KMOD_ALT);
517 keyevt.setMetaPressed(keysym.mod & KMOD_META);
518 keyevt.setNumericPad(keysym.sym >= SDLK_KP0 && keysym.sym <= SDLK_KP_EQUALS);
519 keyevt.setKey(Key(static_cast<Key::KeyType>(keysym.sym), keysym.unicode));
522 void EventManager::fillModifiers(InputEvent& evt) {
523 evt.setAltPressed(m_keystatemap[Key::ALT_GR] |
524 m_keystatemap[Key::LEFT_ALT] |
525 m_keystatemap[Key::RIGHT_ALT]);
526 evt.setControlPressed(m_keystatemap[Key::LEFT_CONTROL] |
527 m_keystatemap[Key::RIGHT_CONTROL]);
528 evt.setMetaPressed(m_keystatemap[Key::LEFT_META] |
529 m_keystatemap[Key::RIGHT_META]);
530 evt.setShiftPressed(m_keystatemap[Key::LEFT_SHIFT] |
531 m_keystatemap[Key::RIGHT_SHIFT]);
538 void EventManager::setKeyFilter(
IKeyFilter* keyFilter) {
539 m_keyfilter = keyFilter;