FIFE
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
eventmanager.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2005-2013 by the FIFE team *
3  * http://www.fifengine.net *
4  * This file is part of FIFE. *
5  * *
6  * FIFE is free software; you can redistribute it and/or *
7  * modify it under the terms of the GNU Lesser General Public *
8  * License as published by the Free Software Foundation; either *
9  * version 2.1 of the License, or (at your option) any later version. *
10  * *
11  * This library is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * Lesser General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU Lesser General Public *
17  * License along with this library; if not, write to the *
18  * Free Software Foundation, Inc., *
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20  ***************************************************************************/
21 
22 // Standard C++ library includes
23 #include <iostream>
24 
25 // 3rd party library includes
26 
27 // FIFE includes
28 // These includes are split up in two parts, separated by one empty line
29 // First block: files included from the FIFE root src directory
30 // Second block: files included from the same folder
31 #include "util/base/exception.h"
32 #include "util/log/logger.h"
33 #include "util/math/fife_math.h"
39 #include "video/renderbackend.h"
40 
41 #include "eventmanager.h"
42 
43 namespace FIFE {
44  static Logger _log(LM_EVTCHANNEL);
45 
47  m_commandlisteners(),
48  m_keylisteners(),
49  m_mouselisteners(),
50  m_sdleventlisteners(),
51  m_keystatemap(),
52  m_keyfilter(0),
53  m_mousestate(0),
54  m_mostrecentbtn(MouseEvent::EMPTY),
55  m_mousesensitivity(0.0),
56  m_acceleration(false),
57  m_warp(false),
58  m_enter(false),
59  m_oldx(0),
60  m_oldy(0),
61  m_lastticks(0),
62  m_oldvelocity(0.0) {
63  }
64 
66  }
67 
68  template<typename T>
69  void removeListener(std::deque<T>& vec, T& listener) {
70  vec.push_back(listener);
71  }
72 
73  template<typename T>
74  void addListener(std::deque<T>& vec, T& listener) {
75  vec.push_back(listener);
76  }
77 
79  addListener<ICommandListener*>(m_pending_commandlisteners, listener);
80  }
81 
83  addListener<ICommandListener*>(m_pending_commandlisteners, listener);
84  }
85 
87  removeListener<ICommandListener*>(m_pending_cldeletions, listener);
88  }
89 
91  addListener<IKeyListener*>(m_pending_keylisteners, listener);
92  }
93 
95  addListener<IKeyListener*>(m_pending_keylisteners_front, listener);
96  }
97 
99  removeListener<IKeyListener*>(m_pending_kldeletions, listener);
100  }
101 
103  addListener<IMouseListener*>(m_pending_mouselisteners, listener);
104  }
105 
107  addListener<IMouseListener*>(m_pending_mouselisteners, listener);
108  }
109 
111  removeListener<IMouseListener*>(m_pending_mldeletions, listener);
112  }
113 
115  addListener<ISdlEventListener*>(m_pending_sdleventlisteners, listener);
116  }
117 
119  addListener<ISdlEventListener*>(m_pending_sdleventlisteners, listener);
120  }
121 
123  removeListener<ISdlEventListener*>(m_pending_sdldeletions, listener);
124  }
125 
127  if(!m_pending_commandlisteners.empty()) {
128  std::deque<ICommandListener*>::iterator i = m_pending_commandlisteners.begin();
129  while (i != m_pending_commandlisteners.end()) {
130  m_commandlisteners.push_back(*i);
131  ++i;
132  }
134  }
135 
136  if(!m_pending_commandlisteners_front.empty()) {
137  std::deque<ICommandListener*>::iterator i = m_pending_commandlisteners_front.begin();
138  while (i != m_pending_commandlisteners_front.end()) {
139  m_commandlisteners.push_front(*i);
140  ++i;
141  }
143  }
144 
145  if (!m_pending_cldeletions.empty()) {
146  std::deque<ICommandListener*>::iterator i = m_pending_cldeletions.begin();
147  while (i != m_pending_cldeletions.end()) {
148  std::deque<ICommandListener*>::iterator j = m_commandlisteners.begin();
149  while (j != m_commandlisteners.end()) {
150  if(*j == *i) {
151  m_commandlisteners.erase(j);
152  break;
153  }
154  ++j;
155  }
156  ++i;
157  }
158  m_pending_cldeletions.clear();
159  }
160 
161  std::deque<ICommandListener*>::iterator i = m_commandlisteners.begin();
162  while (i != m_commandlisteners.end()) {
163  (*i)->onCommand(command);
164  if (command.isConsumed()) {
165  break;
166  }
167  ++i;
168  }
169  }
170 
172  if(!m_pending_keylisteners.empty()) {
173  std::deque<IKeyListener*>::iterator i = m_pending_keylisteners.begin();
174  while (i != m_pending_keylisteners.end()) {
175  m_keylisteners.push_back(*i);
176  ++i;
177  }
178  m_pending_keylisteners.clear();
179  }
180 
181  if(!m_pending_keylisteners_front.empty()) {
182  std::deque<IKeyListener*>::iterator i = m_pending_keylisteners_front.begin();
183  while (i != m_pending_keylisteners_front.end()) {
184  m_keylisteners.push_front(*i);
185  ++i;
186  }
188  }
189 
190  if (!m_pending_kldeletions.empty()) {
191  std::deque<IKeyListener*>::iterator i = m_pending_kldeletions.begin();
192  while (i != m_pending_kldeletions.end()) {
193  std::deque<IKeyListener*>::iterator j = m_keylisteners.begin();
194  while (j != m_keylisteners.end()) {
195  if(*j == *i) {
196  m_keylisteners.erase(j);
197  break;
198  }
199  ++j;
200  }
201  ++i;
202  }
203  m_pending_kldeletions.clear();
204  }
205 
206  std::deque<IKeyListener*>::iterator i = m_keylisteners.begin();
207  while (i != m_keylisteners.end()) {
208  switch (evt.getType()) {
209  case KeyEvent::PRESSED:
210  (*i)->keyPressed(evt);
211  break;
212  case KeyEvent::RELEASED:
213  (*i)->keyReleased(evt);
214  break;
215  default:
216  break;
217  }
218  ++i;
219  }
220  }
221 
223  if(!m_pending_mouselisteners.empty()) {
224  std::deque<IMouseListener*>::iterator i = m_pending_mouselisteners.begin();
225  while (i != m_pending_mouselisteners.end()) {
226  m_mouselisteners.push_back(*i);
227  ++i;
228  }
229  m_pending_mouselisteners.clear();
230  }
231 
232  if(!m_pending_mouselisteners_front.empty()) {
233  std::deque<IMouseListener*>::iterator i = m_pending_mouselisteners_front.begin();
234  while (i != m_pending_mouselisteners_front.end()) {
235  m_mouselisteners.push_front(*i);
236  ++i;
237  }
239  }
240 
241  if (!m_pending_mldeletions.empty()) {
242  std::deque<IMouseListener*>::iterator i = m_pending_mldeletions.begin();
243  while (i != m_pending_mldeletions.end()) {
244  std::deque<IMouseListener*>::iterator j = m_mouselisteners.begin();
245  while (j != m_mouselisteners.end()) {
246  if(*j == *i) {
247  m_mouselisteners.erase(j);
248  break;
249  }
250  ++j;
251  }
252  ++i;
253  }
254  m_pending_mldeletions.clear();
255  }
256 
257  std::deque<IMouseListener*>::iterator i = m_mouselisteners.begin();
258  while (i != m_mouselisteners.end()) {
259  switch (evt.getType()) {
260  case MouseEvent::MOVED:
261  (*i)->mouseMoved(evt);
262  break;
263  case MouseEvent::PRESSED:
264  (*i)->mousePressed(evt);
265  break;
267  (*i)->mouseReleased(evt);
268  break;
270  (*i)->mouseWheelMovedDown(evt);
271  break;
273  (*i)->mouseWheelMovedUp(evt);
274  break;
275  case MouseEvent::CLICKED:
276  (*i)->mouseClicked(evt);
277  break;
278  case MouseEvent::ENTERED:
279  (*i)->mouseEntered(evt);
280  break;
281  case MouseEvent::EXITED:
282  (*i)->mouseExited(evt);
283  break;
284  case MouseEvent::DRAGGED:
285  (*i)->mouseDragged(evt);
286  break;
287  default:
288  break;
289  }
290  if (evt.isConsumed()) {
291  break;
292  }
293  ++i;
294  }
295  }
296 
297  bool EventManager::dispatchSdlEvent(SDL_Event& evt) {
298  bool ret = false;
299  if (!m_pending_sdleventlisteners.empty()) {
300  std::deque<ISdlEventListener*>::iterator i = m_pending_sdleventlisteners.begin();
301  while(i != m_pending_sdleventlisteners.end()) {
302  m_sdleventlisteners.push_back(*i);
303  ++i;
304  }
306  }
307 
308  if (!m_pending_sdleventlisteners_front.empty()) {
309  std::deque<ISdlEventListener*>::iterator i = m_pending_sdleventlisteners_front.begin();
310  while(i != m_pending_sdleventlisteners_front.end()) {
311  m_sdleventlisteners.push_front(*i);
312  ++i;
313  }
315  }
316 
317  if (!m_pending_sdldeletions.empty()) {
318  std::deque<ISdlEventListener*>::iterator i = m_pending_sdldeletions.begin();
319  while (i != m_pending_sdldeletions.end()) {
320  std::deque<ISdlEventListener*>::iterator j = m_sdleventlisteners.begin();
321  while (j != m_sdleventlisteners.end()) {
322  if(*j == *i) {
323  m_sdleventlisteners.erase(j);
324  break;
325  }
326  ++j;
327  }
328  ++i;
329  }
330  m_pending_sdldeletions.clear();
331  }
332 
333  std::deque<ISdlEventListener*>::iterator i = m_sdleventlisteners.begin();
334  while (i != m_sdleventlisteners.end()) {
335  ret = ret || (*i)->onSdlEvent(evt);
336  ++i;
337  }
338  return ret;
339  }
340 
341  bool EventManager::combineEvents(SDL_Event& event1, const SDL_Event& event2) {
342  if(event1.type == event2.type) {
343  switch (event1.type) {
344  case SDL_MOUSEMOTION:
345  if(event1.motion.state == event2.motion.state) {
346  event1.motion.x = event2.motion.x;
347  event1.motion.y = event2.motion.y;
348  event1.motion.xrel += event2.motion.xrel;
349  event1.motion.yrel += event2.motion.yrel;
350  return true;
351  }
352  return false;
353  }
354  }
355  return false;
356  }
357 
359  // The double SDL_PollEvent calls don't throw away events,
360  // but try to combine (mouse motion) events.
361  SDL_Event event, next_event;
362  bool has_next_event = (SDL_PollEvent(&event) != 0);
363  while (has_next_event) {
364  has_next_event = (SDL_PollEvent(&next_event) != 0);
365  if(has_next_event && combineEvents(event, next_event))
366  continue;
367 
368  switch (event.type) {
369  case SDL_QUIT: {
370  Command cmd;
371  cmd.setSource(this);
373  dispatchCommand(cmd);
374  }
375  break;
376 
377  case SDL_ACTIVEEVENT:
378  processActiveEvent(event);
379  break;
380 
381  case SDL_KEYDOWN:
382  case SDL_KEYUP:
383  processKeyEvent(event);
384  break;
385 
386  case SDL_MOUSEBUTTONUP:
387  case SDL_MOUSEMOTION:
388  case SDL_MOUSEBUTTONDOWN:
389  processMouseEvent(event);
390  break;
391  }
392  if(has_next_event)
393  event = next_event;
394  }
395  }
396 
397  void EventManager::processActiveEvent(SDL_Event event) {
398  if (dispatchSdlEvent(event)) {
399  return;
400  }
401 
402  SDL_ActiveEvent actevt = event.active;
403  std::vector<Command*> commands;
404 
405  if (actevt.state & SDL_APPMOUSEFOCUS) {
406  Command* cmd = new Command();
407  if (actevt.gain) {
409  m_enter = true;
410  } else {
412  }
413  commands.push_back(cmd);
414  }
415  if (actevt.state & SDL_APPINPUTFOCUS) {
416  Command* cmd = new Command();
417  if (actevt.gain) {
419  } else {
421  }
422  commands.push_back(cmd);
423  }
424  if (actevt.state & SDL_APPACTIVE) {
425  Command* cmd = new Command();
426  if (actevt.gain) {
428  } else {
430  }
431  commands.push_back(cmd);
432  }
433 
434  std::vector<Command*>::iterator it = commands.begin();
435  for (; it != commands.end(); ++it) {
436  dispatchCommand(**it);
437  delete *it;
438  }
439  }
440 
441  void EventManager::processKeyEvent(SDL_Event event) {
442  KeyEvent keyevt;
443  keyevt.setSource(this);
444  fillKeyEvent(event, keyevt);
445  m_keystatemap[keyevt.getKey().getValue()] = (keyevt.getType() == KeyEvent::PRESSED);
446 
447  bool dispatchAsSdl = !keyevt.getKey().isFunctionKey();
448  if( dispatchAsSdl && m_keyfilter ) {
449  dispatchAsSdl = !m_keyfilter->isFiltered(keyevt);
450  }
451 
452  if( dispatchAsSdl ) {
453  if( dispatchSdlEvent(event) )
454  return;
455  }
456 
457  dispatchKeyEvent(keyevt);
458  }
459 
460  void EventManager::processMouseEvent(SDL_Event event) {
461  if (event.type == SDL_MOUSEMOTION && (!Mathf::Equal(m_mousesensitivity, 0.0) || m_acceleration)) {
462  uint16_t tmp_x = event.motion.x;
463  uint16_t tmp_y = event.motion.y;
464  if (m_enter) {
465  m_oldx = tmp_x;
466  m_oldy = tmp_y;
467  m_oldvelocity = 0.0;
468  m_enter = false;
469  }
470 
471  float modifier;
472  if (m_acceleration) {
473  uint32_t ticks = SDL_GetTicks();
474  float difference = static_cast<float>((ticks - m_lastticks) + 1);
475  m_lastticks = ticks;
476  float dx = static_cast<float>(tmp_x - m_oldx);
477  float dy = static_cast<float>(tmp_y - m_oldy);
478  float distance = Mathf::Sqrt(dx * dx + dy * dy);
479  float acceleration = static_cast<float>((distance / difference) / difference);
480  float velocity = (m_oldvelocity + acceleration * difference)/2;
481  if (velocity > m_mousesensitivity+1) {
482  velocity = m_mousesensitivity+1;
483  }
484  m_oldvelocity = velocity;
485  modifier = velocity;
486  } else {
487  modifier = m_mousesensitivity;
488  }
489 
490  int16_t tmp_xrel = static_cast<int16_t>(tmp_x - m_oldx);
491  int16_t tmp_yrel = static_cast<int16_t>(tmp_y - m_oldy);
492  if ((tmp_xrel != 0) || (tmp_yrel != 0)) {
493  Rect screen = RenderBackend::instance()->getArea();
494  int16_t x_fact = static_cast<int16_t>(round(static_cast<float>(tmp_xrel * modifier)));
495  int16_t y_fact = static_cast<int16_t>(round(static_cast<float>(tmp_yrel * modifier)));
496  if ((tmp_x + x_fact) > screen.w) {
497  tmp_x = screen.w;
498  } else if ((tmp_x + x_fact) < screen.x) {
499  tmp_x = screen.x;
500  } else {
501  tmp_x += x_fact;
502  }
503 
504  if (tmp_y + y_fact > screen.h) {
505  tmp_y = screen.h;
506  } else if ((tmp_y + y_fact) < screen.y) {
507  tmp_y = screen.y;
508  } else {
509  tmp_y += y_fact;
510  }
511  m_oldx = tmp_x;
512  m_oldy = tmp_y;
513  event.motion.x = tmp_x;
514  event.motion.y = tmp_y;
515  m_warp = true; //don't trigger an event handler when warping
516  SDL_WarpMouse(tmp_x, tmp_y);
517  m_warp = false;
518  }
519 
520  }
521  if (dispatchSdlEvent(event)) {
522  return;
523  }
524  MouseEvent mouseevt;
525  mouseevt.setSource(this);
526  fillMouseEvent(event, mouseevt);
527  fillModifiers(mouseevt);
528  if (event.type == SDL_MOUSEBUTTONDOWN) {
529  m_mousestate |= static_cast<int32_t>(mouseevt.getButton());
530  m_mostrecentbtn = mouseevt.getButton();
531  } else if (event.type == SDL_MOUSEBUTTONUP) {
532  m_mousestate &= ~static_cast<int32_t>(mouseevt.getButton());
533  }
534  // fire scrollwheel events only once
535  if (event.button.button == SDL_BUTTON_WHEELDOWN || event.button.button == SDL_BUTTON_WHEELUP) {
536  if (event.type == SDL_MOUSEBUTTONUP) {
537  return;
538  }
539  }
540  dispatchMouseEvent(mouseevt);
541  }
542 
543 
544  void EventManager::fillMouseEvent(const SDL_Event& sdlevt, MouseEvent& mouseevt) {
545  if (m_warp) {
546  return;
547  }
548 
549  mouseevt.setX(sdlevt.button.x);
550  mouseevt.setY(sdlevt.button.y);
551 
552  mouseevt.setButton(MouseEvent::EMPTY);
553  mouseevt.setType(MouseEvent::MOVED);
554  if ((sdlevt.type == SDL_MOUSEBUTTONUP) || (sdlevt.type == SDL_MOUSEBUTTONDOWN)) {
555  switch (sdlevt.button.button) {
556  case SDL_BUTTON_LEFT:
557  mouseevt.setButton(MouseEvent::LEFT);
558  break;
559  case SDL_BUTTON_RIGHT:
560  mouseevt.setButton(MouseEvent::RIGHT);
561  break;
562  case SDL_BUTTON_MIDDLE:
563  mouseevt.setButton(MouseEvent::MIDDLE);
564  break;
565  default:
567  break;
568  }
569 
570  if (sdlevt.type == SDL_MOUSEBUTTONUP ) {
571  mouseevt.setType(MouseEvent::RELEASED);
572  } else {
573  mouseevt.setType(MouseEvent::PRESSED);
574  }
575 
576  switch (sdlevt.button.button) {
577  case SDL_BUTTON_WHEELDOWN:
579  break;
580  case SDL_BUTTON_WHEELUP:
582  break;
583  default:
584  break;
585  }
586  }
587  if ((mouseevt.getType() == MouseEvent::MOVED) && m_mousestate) {
588  mouseevt.setType(MouseEvent::DRAGGED);
589  mouseevt.setButton(m_mostrecentbtn);
590  }
591  }
592 
593  void EventManager::fillKeyEvent(const SDL_Event& sdlevt, KeyEvent& keyevt) {
594  if (sdlevt.type == SDL_KEYDOWN) {
595  keyevt.setType(KeyEvent::PRESSED);
596  } else if (sdlevt.type == SDL_KEYUP) {
597  keyevt.setType(KeyEvent::RELEASED);
598  } else {
599  FL_WARN(_log, LMsg("fillKeyEvent()")
600  << " Invalid key event type of " << sdlevt.type << ". Ignoring event.");
601  return;
602  }
603  SDL_keysym keysym = sdlevt.key.keysym;
604 
605  keyevt.setShiftPressed((keysym.mod & KMOD_SHIFT) != 0);
606  keyevt.setControlPressed((keysym.mod & KMOD_CTRL) != 0);
607  keyevt.setAltPressed((keysym.mod & KMOD_ALT) != 0);
608  keyevt.setMetaPressed((keysym.mod & KMOD_META) != 0);
609  keyevt.setNumericPad(keysym.sym >= SDLK_KP0 && keysym.sym <= SDLK_KP_EQUALS);
610  keyevt.setKey(Key(static_cast<Key::KeyType>(keysym.sym), keysym.unicode));
611  }
612 
623  }
624 
626  return ES_ENGINE;
627  }
628 
630  m_keyfilter = keyFilter;
631  }
632 
633  void EventManager::setMouseSensitivity(float sensitivity) {
634  if (sensitivity < -0.99) {
635  sensitivity = -0.99;
636  } else if (sensitivity > 10.0) {
637  sensitivity = 10.0;
638  }
639  m_mousesensitivity = sensitivity;
640  }
641 
643  return m_mousesensitivity;
644  }
645 
647  m_acceleration = acceleration;
648  }
649 
651  return m_acceleration;
652  }
653 }
#define FL_WARN(logger, msg)
Definition: logger.h:72
void removeMouseListener(IMouseListener *listener)
Removes an added listener from the controller.
KeyEventType getType() const
Definition: ec_keyevent.h:65
float getMouseSensitivity() const
Gets mouse sensitivity.
virtual void setControlPressed(bool pressed)
Definition: ec_inputevent.h:66
void setY(int32_t y)
Listener of SDL events.
void addKeyListenerFront(IKeyListener *listener)
Adds a listener to the front of the listener deque Listener will be notified via the corresponding ev...
Class for mouse events.
Definition: ec_mouseevent.h:42
virtual bool isConsumed() const
Checks if the event is consumed.
Definition: ec_command.h:70
static T Sqrt(T _val)
Definition: fife_math.h:276
T h
Height of the rectangle.
Definition: rect.h:93
IKeyFilter * m_keyfilter
Definition: eventmanager.h:168
void setKey(const Key &key)
Definition: ec_keyevent.h:72
Helper class to create log strings out from separate parts Usage: LMsg(&quot;some text&quot;) &lt;&lt; variable &lt;&lt; &quot;...
Definition: logger.h:82
KeyType getValue() const
Gets the value of the key.
Definition: ec_key.h:305
Controller provides a way to receive events from the system Using this interface, clients can subscri...
Definition: ec_ikeyfilter.h:42
Base class for input events (like mouse and keyboard)
Definition: ec_inputevent.h:42
MouseEventType getType() const
Gets the type of the event.
Definition: ec_mouseevent.h:98
T x
The X Coordinate.
Definition: rect.h:84
std::deque< IKeyListener * > m_pending_keylisteners
Definition: eventmanager.h:153
std::deque< IMouseListener * > m_pending_mouselisteners
Definition: eventmanager.h:158
std::deque< ISdlEventListener * > m_pending_sdleventlisteners_front
Definition: eventmanager.h:164
bool combineEvents(SDL_Event &event1, const SDL_Event &event2)
virtual void setShiftPressed(bool pressed)
Definition: ec_inputevent.h:76
Listener of command events.
virtual void setSource(IEventSource *source)
Sets the source of the event.
Definition: ec_command.h:72
virtual void setSource(IEventSource *source)
Sets the source of the event.
MouseButtonType getButton() const
Gets the button of the mouse event.
Definition: ec_mouseevent.h:91
void addSdlEventListener(ISdlEventListener *listener)
Adds a listener to the back of the listener deque Listener will be notified via the corresponding eve...
static Logger _log(LM_AUDIO)
void dispatchCommand(Command &command)
Use this method to send command to command listeners.
void addCommandListenerFront(ICommandListener *listener)
Adds a listener to the front of the listener deque Listener will be notified via the corresponding ev...
Listener of mouse events.
void setMouseAccelerationEnabled(bool acceleration)
Sets mouse acceleration if mouse acceleration is enabled, then the mouse sensitivity is used as speed...
virtual void setAltPressed(bool pressed)
Definition: ec_inputevent.h:61
std::deque< IKeyListener * > m_pending_kldeletions
Definition: eventmanager.h:155
virtual void setControlPressed(bool pressed)
Definition: ec_keyevent.h:77
static RenderBackend * instance()
Definition: singleton.h:84
virtual void setShiftPressed(bool pressed)
Definition: ec_keyevent.h:81
virtual void setSource(IEventSource *source)
Sets the source of the event.
Definition: ec_keyevent.h:88
void removeCommandListener(ICommandListener *listener)
Removes an added listener from the controller.
void dispatchMouseEvent(MouseEvent &evt)
const Key & getKey() const
Definition: ec_keyevent.h:71
std::deque< ISdlEventListener * > m_pending_sdleventlisteners
Definition: eventmanager.h:163
static bool Equal(T _val1, T _val2)
Definition: fife_math.h:286
virtual void setMetaPressed(bool pressed)
Definition: ec_keyevent.h:79
void addCommandListener(ICommandListener *listener)
Adds a listener to the back of the listener deque Listener will be notified via the corresponding eve...
std::deque< IKeyListener * > m_keylisteners
Definition: eventmanager.h:152
std::deque< ICommandListener * > m_pending_cldeletions
Definition: eventmanager.h:150
void removeListener(std::deque< T > &vec, T &listener)
Class for commands Commands are arbitrary events e.g.
Definition: ec_command.h:44
std::map< int32_t, bool > m_keystatemap
Definition: eventmanager.h:167
void fillMouseEvent(const SDL_Event &sdlevt, MouseEvent &mouseevt)
EventSourceType getEventSourceType()
Gets the source type of this event.
void addListener(std::deque< T > &vec, T &listener)
std::deque< IMouseListener * > m_pending_mouselisteners_front
Definition: eventmanager.h:159
Represents a key or a character.
Definition: ec_key.h:41
unsigned short uint16_t
Definition: core.h:39
T y
The Y Coordinate.
Definition: rect.h:87
std::iterator_traits< octet_iterator >::difference_type distance(octet_iterator first, octet_iterator last)
Definition: checked.h:187
void setKeyFilter(IKeyFilter *keyFilter)
std::deque< IMouseListener * > m_mouselisteners
Definition: eventmanager.h:157
void setX(int32_t x)
void setNumericPad(bool ispad)
Definition: ec_keyevent.h:69
void setButton(MouseButtonType type)
Definition: ec_mouseevent.h:92
void removeKeyListener(IKeyListener *listener)
Removes an added listener from the controller.
EventManager()
Constructor.
bool isFunctionKey() const
Definition: ec_key.h:299
virtual bool isConsumed() const
Checks if the event is consumed.
void setCommandType(CommandType type)
Definition: ec_command.h:61
void fillKeyEvent(const SDL_Event &sdlevt, KeyEvent &keyevt)
std::deque< IMouseListener * > m_pending_mldeletions
Definition: eventmanager.h:160
void setType(KeyEventType type)
Definition: ec_keyevent.h:66
MouseEvent::MouseButtonType m_mostrecentbtn
Definition: eventmanager.h:170
std::deque< IKeyListener * > m_pending_keylisteners_front
Definition: eventmanager.h:154
bool isMouseAccelerationEnabled() const
Returns if mouse acceleration is enabled or not.
Class for key events.
Definition: ec_keyevent.h:45
void addMouseListener(IMouseListener *listener)
Adds a listener to the back of the listener deque Listener will be notified via the corresponding eve...
std::deque< ISdlEventListener * > m_sdleventlisteners
Definition: eventmanager.h:162
void processKeyEvent(SDL_Event event)
virtual ~EventManager()
Destructor.
bool dispatchSdlEvent(SDL_Event &evt)
Listener of key events.
EventSourceType
Types for different event sources.
void processMouseEvent(SDL_Event event)
void setType(MouseEventType type)
Definition: ec_mouseevent.h:99
void fillModifiers(InputEvent &evt)
void addSdlEventListenerFront(ISdlEventListener *listener)
Adds a listener to the front of the listener deque Listener will be notified via the corresponding ev...
void setMouseSensitivity(float sensitivity)
Sets mouse sensitivity The sensitivity is limited to the range -0.99 - 10.0.
unsigned int uint32_t
Definition: core.h:40
std::deque< ICommandListener * > m_commandlisteners
Definition: eventmanager.h:147
void processEvents()
Process the SDL event queue.
virtual void setMetaPressed(bool pressed)
Definition: ec_inputevent.h:71
void addMouseListenerFront(IMouseListener *listener)
Adds a listener to the front of the listener deque Listener will be notified via the corresponding ev...
std::deque< ICommandListener * > m_pending_commandlisteners_front
Definition: eventmanager.h:149
T w
Width of the rectangle.
Definition: rect.h:90
std::deque< ISdlEventListener * > m_pending_sdldeletions
Definition: eventmanager.h:165
virtual void setAltPressed(bool pressed)
Definition: ec_keyevent.h:75
virtual bool isFiltered(const KeyEvent &event)=0
Check whether a keyevent should be filtered out.
std::deque< ICommandListener * > m_pending_commandlisteners
Definition: eventmanager.h:148
void addKeyListener(IKeyListener *listener)
Adds a listener to the back of the listener deque Listener will be notified via the corresponding eve...
void dispatchKeyEvent(KeyEvent &evt)
void processActiveEvent(SDL_Event event)
const Rect & getArea() const
void removeSdlEventListener(ISdlEventListener *listener)
Removes an added listener from the controller.