Debian Codegraph @

engine/core/eventchannel/eventmanager.cpp

raw
1 /***************************************************************************
2 * Copyright (C) 2005-2019 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"
34 #include "eventchannel/joystick/joystickmanager.h"
35 #include "eventchannel/key/key.h"
36 #include "eventchannel/key/keyevent.h"
37 #include "eventchannel/key/ikeyfilter.h"
38 #include "eventchannel/mouse/mouseevent.h"
39 #include "eventchannel/command/command.h"
40 #include "video/renderbackend.h"
41
42 #include "eventmanager.h"
43
44 namespace FIFE {
45 static Logger _log(LM_EVTCHANNEL);
46
47 EventManager::EventManager():
48 m_commandListeners(),
49 m_keyListeners(),
50 m_textListeners(),
51 m_mouseListeners(),
52 m_sdleventListeners(),
53 m_keystatemap(),
54 m_keyfilter(0),
55 m_mousestate(0),
56 m_mostrecentbtn(MouseEvent::EMPTY),
57 m_mouseSensitivity(0.0),
58 m_acceleration(false),
59 m_warp(false),
60 m_enter(false),
61 m_oldX(0),
62 m_oldY(0),
63 m_lastTicks(0),
64 m_oldVelocity(0.0),
65 m_joystickManager(NULL) {
66 }
67
68 EventManager::~EventManager() {
69 delete m_joystickManager;
70 }
71
72 template<typename T>
73 void addListener(std::deque<T>& vec, T& listener) {
74 if (!listener->isActive()) {
75 listener->setActive(true);
76 vec.push_back(listener);
77 }
78 }
79
80 template<typename T>
81 void addListenerFront(std::deque<T>& vec, T& listener) {
82 if (!listener->isActive()) {
83 listener->setActive(true);
84 vec.push_front(listener);
85 }
86 }
87
88 template<typename T>
89 void removeListener(std::deque<T>& vec, T& listener) {
90 if (listener->isActive()) {
91 listener->setActive(false);
92 for (typename std::deque<T>::iterator it = vec.begin(); it != vec.end(); ++it) {
93 if (*it == listener) {
94 vec.erase(it);
95 break;
96 }
97 }
98 }
99 }
100
101 void EventManager::addCommandListener(ICommandListener* listener) {
102 addListener<ICommandListener*>(m_commandListeners, listener);
103 }
104
105 void EventManager::addCommandListenerFront(ICommandListener* listener) {
106 addListenerFront<ICommandListener*>(m_commandListeners, listener);
107 }
108
109 void EventManager::removeCommandListener(ICommandListener* listener) {
110 removeListener<ICommandListener*>(m_commandListeners, listener);
111 }
112
113 void EventManager::addKeyListener(IKeyListener* listener) {
114 addListener<IKeyListener*>(m_keyListeners, listener);
115 }
116
117 void EventManager::addKeyListenerFront(IKeyListener* listener) {
118 addListenerFront<IKeyListener*>(m_keyListeners, listener);
119 }
120
121 void EventManager::removeKeyListener(IKeyListener* listener) {
122 removeListener<IKeyListener*>(m_keyListeners, listener);
123 }
124
125 void EventManager::addTextListener(ITextListener* listener) {
126 addListener<ITextListener*>(m_textListeners, listener);
127 }
128
129 void EventManager::addTextListenerFront(ITextListener* listener) {
130 addListenerFront<ITextListener*>(m_textListeners, listener);
131 }
132
133 void EventManager::removeTextListener(ITextListener* listener) {
134 removeListener<ITextListener*>(m_textListeners, listener);
135 }
136
137 void EventManager::addMouseListener(IMouseListener* listener) {
138 addListener<IMouseListener*>(m_mouseListeners, listener);
139 }
140
141 void EventManager::addMouseListenerFront(IMouseListener* listener) {
142 addListenerFront<IMouseListener*>(m_mouseListeners, listener);
143 }
144
145 void EventManager::removeMouseListener(IMouseListener* listener) {
146 removeListener<IMouseListener*>(m_mouseListeners, listener);
147 }
148
149 void EventManager::addSdlEventListener(ISdlEventListener* listener) {
150 addListener<ISdlEventListener*>(m_sdleventListeners, listener);
151 }
152
153 void EventManager::addSdlEventListenerFront(ISdlEventListener* listener) {
154 addListenerFront<ISdlEventListener*>(m_sdleventListeners, listener);
155 }
156
157 void EventManager::removeSdlEventListener(ISdlEventListener* listener) {
158 removeListener<ISdlEventListener*>(m_sdleventListeners, listener);
159 }
160
161 void EventManager::addDropListener(IDropListener* listener) {
162 addListener<IDropListener*>(m_dropListeners, listener);
163 }
164
165 void EventManager::addDropListenerFront(IDropListener* listener) {
166 addListenerFront<IDropListener*>(m_dropListeners, listener);
167 }
168
169 void EventManager::removeDropListener(IDropListener* listener) {
170 removeListener<IDropListener*>(m_dropListeners, listener);
171 }
172
173 void EventManager::addJoystickListener(IJoystickListener* listener) {
174 if (m_joystickManager) {
175 m_joystickManager->addJoystickListener(listener);
176 }
177 }
178
179 void EventManager::addJoystickListenerFront(IJoystickListener* listener) {
180 if (m_joystickManager) {
181 m_joystickManager->addJoystickListenerFront(listener);
182 }
183 }
184
185 void EventManager::removeJoystickListener(IJoystickListener* listener) {
186 if (m_joystickManager) {
187 m_joystickManager->removeJoystickListener(listener);
188 }
189 }
190
191 void EventManager::dispatchCommand(Command& command) {
192 std::deque<ICommandListener*> listeners = m_commandListeners;
193 std::deque<ICommandListener*>::iterator i = listeners.begin();
194 for (; i != listeners.end(); ++i) {
195 if (!(*i)->isActive()) continue;
196 (*i)->onCommand(command);
197 if (command.isConsumed()) {
198 break;
199 }
200 }
201 }
202
203 void EventManager::dispatchKeyEvent(KeyEvent& evt) {
204 std::deque<IKeyListener*> listeners = m_keyListeners;
205 std::deque<IKeyListener*>::iterator i = listeners.begin();
206 for (; i != listeners.end(); ++i) {
207 if (!(*i)->isActive() || (evt.isConsumedByWidgets() && !(*i)->isGlobalListener())) continue;
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 if (evt.isConsumed()) {
219 break;
220 }
221 }
222 }
223
224 void EventManager::dispatchTextEvent(TextEvent& evt) {
225 std::deque<ITextListener*> listeners = m_textListeners;
226 std::deque<ITextListener*>::iterator i = listeners.begin();
227 for (; i != listeners.end(); ++i) {
228 if (!(*i)->isActive()) continue;
229 switch (evt.getType()) {
230 case TextEvent::INPUT:
231 (*i)->textInput(evt);
232 break;
233 case TextEvent::EDIT:
234 (*i)->textEdit(evt);
235 break;
236 default:
237 break;
238 }
239 if (evt.isConsumed()) {
240 break;
241 }
242 }
243 }
244
245 void EventManager::dispatchMouseEvent(MouseEvent& evt) {
246 std::deque<IMouseListener*> listeners = m_mouseListeners;
247 std::deque<IMouseListener*>::iterator i = listeners.begin();
248 for (; i != listeners.end(); ++i) {
249 if (!(*i)->isActive() || (evt.isConsumedByWidgets() && !(*i)->isGlobalListener())) continue;
250 switch (evt.getType()) {
251 case MouseEvent::MOVED:
252 (*i)->mouseMoved(evt);
253 break;
254 case MouseEvent::PRESSED:
255 (*i)->mousePressed(evt);
256 break;
257 case MouseEvent::RELEASED:
258 (*i)->mouseReleased(evt);
259 break;
260 case MouseEvent::WHEEL_MOVED_DOWN:
261 (*i)->mouseWheelMovedDown(evt);
262 break;
263 case MouseEvent::WHEEL_MOVED_UP:
264 (*i)->mouseWheelMovedUp(evt);
265 break;
266 case MouseEvent::WHEEL_MOVED_RIGHT:
267 (*i)->mouseWheelMovedRight(evt);
268 break;
269 case MouseEvent::WHEEL_MOVED_LEFT:
270 (*i)->mouseWheelMovedLeft(evt);
271 break;
272 case MouseEvent::CLICKED:
273 (*i)->mouseClicked(evt);
274 break;
275 case MouseEvent::ENTERED:
276 (*i)->mouseEntered(evt);
277 break;
278 case MouseEvent::EXITED:
279 (*i)->mouseExited(evt);
280 break;
281 case MouseEvent::DRAGGED:
282 (*i)->mouseDragged(evt);
283 break;
284 default:
285 break;
286 }
287 if (evt.isConsumed()) {
288 break;
289 }
290 }
291 }
292
293 bool EventManager::dispatchSdlEvent(SDL_Event& evt) {
294 bool ret = false;
295 std::deque<ISdlEventListener*> listeners = m_sdleventListeners;
296 std::deque<ISdlEventListener*>::iterator i = listeners.begin();
297 for (; i != listeners.end(); ++i) {
298 if (!(*i)->isActive()) continue;
299 ret = ret || (*i)->onSdlEvent(evt);
300 }
301 return ret;
302 }
303
304 void EventManager::dispatchDropEvent(DropEvent& evt) {
305 std::deque<IDropListener*> listeners = m_dropListeners;
306 std::deque<IDropListener*>::iterator i = listeners.begin();
307 for (; i != listeners.end(); ++i) {
308 if (!(*i)->isActive()) continue;
309 (*i)->fileDropped(evt);
310 if (evt.isConsumed()) {
311 break;
312 }
313 }
314 }
315
316 bool EventManager::combineEvents(SDL_Event& event1, const SDL_Event& event2) {
317 if(event1.type == event2.type) {
318 switch (event1.type) {
319 case SDL_MOUSEMOTION:
320 if(event1.motion.state == event2.motion.state) {
321 event1.motion.x = event2.motion.x;
322 event1.motion.y = event2.motion.y;
323 event1.motion.xrel += event2.motion.xrel;
324 event1.motion.yrel += event2.motion.yrel;
325 return true;
326 }
327 return false;
328 }
329 }
330 return false;
331 }
332
333 void EventManager::processEvents() {
334 // The double SDL_PollEvent calls don't throw away events,
335 // but try to combine (mouse motion) events.
336 SDL_Event event, next_event;
337 bool has_next_event = (SDL_PollEvent(&event) != 0);
338 while (has_next_event) {
339 has_next_event = (SDL_PollEvent(&next_event) != 0);
340 if (has_next_event && combineEvents(event, next_event)) {
341 continue;
342 }
343 switch (event.type) {
344 case SDL_QUIT: {
345 Command cmd;
346 cmd.setSource(this);
347 cmd.setCommandType(CMD_QUIT_GAME);
348 dispatchCommand(cmd);
349 }
350 break;
351
352 case SDL_WINDOWEVENT:
353 processWindowEvent(event);
354 break;
355
356 case SDL_KEYDOWN:
357 case SDL_KEYUP:
358 processKeyEvent(event);
359 break;
360
361 //case SDL_TEXTEDITING: // is buggy with SDL 2.0.1
362 case SDL_TEXTINPUT:
363 processTextEvent(event);
364 break;
365
366 case SDL_MOUSEWHEEL:
367 case SDL_MOUSEBUTTONUP:
368 case SDL_MOUSEMOTION:
369 case SDL_MOUSEBUTTONDOWN:
370 processMouseEvent(event);
371 break;
372
373 case SDL_DROPFILE:
374 processDropEvent(event);
375 break;
376
377 case SDL_JOYBUTTONDOWN:
378 case SDL_JOYBUTTONUP:
379 case SDL_JOYAXISMOTION:
380 case SDL_JOYHATMOTION:
381 case SDL_JOYDEVICEADDED:
382 case SDL_JOYDEVICEREMOVED: {
383 if (m_joystickManager) {
384 m_joystickManager->processJoystickEvent(event);
385 }
386 break;
387 }
388 case SDL_CONTROLLERBUTTONDOWN:
389 case SDL_CONTROLLERBUTTONUP:
390 case SDL_CONTROLLERAXISMOTION: {
391 if (m_joystickManager) {
392 m_joystickManager->processControllerEvent(event);
393 }
394 break;
395 }
396
397 }
398 if (has_next_event) {
399 event = next_event;
400 }
401 }
402 }
403
404 void EventManager::processWindowEvent(SDL_Event event) {
405 if (dispatchSdlEvent(event)) {
406 return;
407 }
408
409 CommandType ct = CMD_UNKNOWN;
410 switch (event.window.event) {
411 case SDL_WINDOWEVENT_CLOSE:
412 ct = CMD_QUIT_GAME;
413 break;
414
415 case SDL_WINDOWEVENT_ENTER:
416 ct = CMD_MOUSE_FOCUS_GAINED;
417 break;
418
419 case SDL_WINDOWEVENT_LEAVE:
420 ct = CMD_MOUSE_FOCUS_LOST;
421 break;
422
423 case SDL_WINDOWEVENT_FOCUS_GAINED:
424 ct = CMD_INPUT_FOCUS_GAINED;
425 break;
426
427 case SDL_WINDOWEVENT_FOCUS_LOST:
428 ct = CMD_INPUT_FOCUS_LOST;
429 break;
430
431 case SDL_WINDOWEVENT_SHOWN:
432 ct = CMD_APP_RESTORED;
433 break;
434
435 case SDL_WINDOWEVENT_MINIMIZED:
436 case SDL_WINDOWEVENT_HIDDEN:
437 ct = CMD_APP_ICONIFIED;
438 break;
439
440 default:
441 ct = CMD_UNKNOWN;
442 }
443 if (ct != CMD_UNKNOWN) {
444 Command cmd;
445 cmd.setCommandType(ct);
446 dispatchCommand(cmd);
447 }
448 }
449
450 void EventManager::processKeyEvent(SDL_Event event) {
451 KeyEvent keyevt;
452 keyevt.setSource(this);
453 fillKeyEvent(event, keyevt);
454 m_keystatemap[keyevt.getKey().getValue()] = (keyevt.getType() == KeyEvent::PRESSED);
455 // if event is not filtered it gets dispatched, even it is a function key
456 if (!m_keyfilter || !m_keyfilter->isFiltered(keyevt)) {
457 if (dispatchSdlEvent(event))
458 keyevt.consumedByWidgets();
459 }
460
461 dispatchKeyEvent(keyevt);
462 }
463
464 void EventManager::processTextEvent(SDL_Event event) {
465 if (dispatchSdlEvent(event)) {
466 return;
467 }
468
469 TextEvent txtevt;
470 txtevt.setSource(this);
471 fillTextEvent(event, txtevt);
472 dispatchTextEvent(txtevt);
473 }
474
475 void EventManager::processMouseEvent(SDL_Event event) {
476 if (event.type == SDL_MOUSEMOTION && (!Mathf::Equal(m_mouseSensitivity, 0.0) || m_acceleration)) {
477 uint16_t tmp_x = event.motion.x;
478 uint16_t tmp_y = event.motion.y;
479 if (m_enter) {
480 m_oldX = tmp_x;
481 m_oldY = tmp_y;
482 m_oldVelocity = 0.0;
483 m_enter = false;
484 }
485
486 float modifier;
487 if (m_acceleration) {
488 uint32_t ticks = SDL_GetTicks();
489 float difference = static_cast<float>((ticks - m_lastTicks) + 1);
490 m_lastTicks = ticks;
491 float dx = static_cast<float>(tmp_x - m_oldX);
492 float dy = static_cast<float>(tmp_y - m_oldY);
493 float distance = Mathf::Sqrt(dx * dx + dy * dy);
494 float acceleration = static_cast<float>((distance / difference) / difference);
495 float velocity = (m_oldVelocity + acceleration * difference)/2;
496 if (velocity > m_mouseSensitivity+1) {
497 velocity = m_mouseSensitivity+1;
498 }
499 m_oldVelocity = velocity;
500 modifier = velocity;
501 } else {
502 modifier = m_mouseSensitivity;
503 }
504
505 int16_t tmp_xrel = static_cast<int16_t>(tmp_x - m_oldX);
506 int16_t tmp_yrel = static_cast<int16_t>(tmp_y - m_oldY);
507 if ((tmp_xrel != 0) || (tmp_yrel != 0)) {
508 Rect screen = RenderBackend::instance()->getArea();
509 int16_t x_fact = static_cast<int16_t>(round(static_cast<float>(tmp_xrel * modifier)));
510 int16_t y_fact = static_cast<int16_t>(round(static_cast<float>(tmp_yrel * modifier)));
511 if ((tmp_x + x_fact) > screen.w) {
512 tmp_x = screen.w;
513 } else if ((tmp_x + x_fact) < screen.x) {
514 tmp_x = screen.x;
515 } else {
516 tmp_x += x_fact;
517 }
518
519 if (tmp_y + y_fact > screen.h) {
520 tmp_y = screen.h;
521 } else if ((tmp_y + y_fact) < screen.y) {
522 tmp_y = screen.y;
523 } else {
524 tmp_y += y_fact;
525 }
526 m_oldX = tmp_x;
527 m_oldY = tmp_y;
528 event.motion.x = tmp_x;
529 event.motion.y = tmp_y;
530 m_warp = true; //don't trigger an event handler when warping
531 SDL_WarpMouseInWindow(RenderBackend::instance()->getWindow(), tmp_x, tmp_y);
532 m_warp = false;
533 }
534 }
535
536 MouseEvent mouseevt;
537 mouseevt.setSource(this);
538 fillMouseEvent(event, mouseevt);
539 fillModifiers(mouseevt);
540 if (event.type == SDL_MOUSEBUTTONDOWN) {
541 m_mousestate |= static_cast<int32_t>(mouseevt.getButton());
542 m_mostrecentbtn = mouseevt.getButton();
543 } else if (event.type == SDL_MOUSEBUTTONUP) {
544 m_mousestate &= ~static_cast<int32_t>(mouseevt.getButton());
545 }
546
547 if (dispatchSdlEvent(event))
548 mouseevt.consumedByWidgets();
549
550 dispatchMouseEvent(mouseevt);
551 }
552
553 void EventManager::processDropEvent(SDL_Event event) {
554 // only dispatched as DropEvent
555 //if (dispatchSdlEvent(event)) {
556 // return;
557 //}
558
559 char* tmp = event.drop.file;
560 std::string path(tmp);
561 SDL_free(tmp);
562
563 DropEvent drop;
564 drop.setPath(path);
565 drop.setSource(this);
566 dispatchDropEvent(drop);
567 }
568
569 void EventManager::fillMouseEvent(const SDL_Event& sdlevt, MouseEvent& mouseevt) {
570 if (m_warp) {
571 return;
572 }
573
574 mouseevt.setX(sdlevt.button.x);
575 mouseevt.setY(sdlevt.button.y);
576
577 mouseevt.setButton(MouseEvent::EMPTY);
578 mouseevt.setType(MouseEvent::MOVED);
579 if ((sdlevt.type == SDL_MOUSEBUTTONUP) || (sdlevt.type == SDL_MOUSEBUTTONDOWN)) {
580 switch (sdlevt.button.button) {
581 case SDL_BUTTON_LEFT:
582 mouseevt.setButton(MouseEvent::LEFT);
583 break;
584 case SDL_BUTTON_RIGHT:
585 mouseevt.setButton(MouseEvent::RIGHT);
586 break;
587 case SDL_BUTTON_MIDDLE:
588 mouseevt.setButton(MouseEvent::MIDDLE);
589 break;
590 case SDL_BUTTON_X1:
591 mouseevt.setButton(MouseEvent::X1);
592 break;
593 case SDL_BUTTON_X2:
594 mouseevt.setButton(MouseEvent::X2);
595 break;
596 default:
597 mouseevt.setButton(MouseEvent::UNKNOWN_BUTTON);
598 break;
599 }
600
601 if (sdlevt.button.state == SDL_RELEASED) {
602 mouseevt.setType(MouseEvent::RELEASED);
603 } else {
604 mouseevt.setType(MouseEvent::PRESSED);
605 }
606 }
607 if (sdlevt.type == SDL_MOUSEWHEEL) {
608 #if SDL_VERSION_ATLEAST(2,0,4)
609 if (sdlevt.wheel.y > 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.y < 0)) {
610 mouseevt.setType(MouseEvent::WHEEL_MOVED_UP);
611 } else if (sdlevt.wheel.y < 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.y > 0)) {
612 mouseevt.setType(MouseEvent::WHEEL_MOVED_DOWN);
613 }
614 if (sdlevt.wheel.x > 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.x < 0)) {
615 mouseevt.setType(MouseEvent::WHEEL_MOVED_RIGHT);
616 } else if (sdlevt.wheel.x < 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.x > 0)) {
617 mouseevt.setType(MouseEvent::WHEEL_MOVED_LEFT);
618 }
619 #else
620 if (sdlevt.wheel.y > 0) {
621 mouseevt.setType(MouseEvent::WHEEL_MOVED_UP);
622 } else if (sdlevt.wheel.y < 0) {
623 mouseevt.setType(MouseEvent::WHEEL_MOVED_DOWN);
624 }
625 if (sdlevt.wheel.x > 0) {
626 mouseevt.setType(MouseEvent::WHEEL_MOVED_RIGHT);
627 } else if (sdlevt.wheel.x < 0) {
628 mouseevt.setType(MouseEvent::WHEEL_MOVED_LEFT);
629 }
630 #endif
631 }
632
633 if ((mouseevt.getType() == MouseEvent::MOVED) && ((m_mousestate & m_mostrecentbtn) != 0)) {
634 mouseevt.setType(MouseEvent::DRAGGED);
635 mouseevt.setButton(m_mostrecentbtn);
636 }
637 }
638
639 void EventManager::fillKeyEvent(const SDL_Event& sdlevt, KeyEvent& keyevt) {
640 if (sdlevt.type == SDL_KEYDOWN) {
641 keyevt.setType(KeyEvent::PRESSED);
642 } else if (sdlevt.type == SDL_KEYUP) {
643 keyevt.setType(KeyEvent::RELEASED);
644 } else {
645 FL_WARN(_log, LMsg("fillKeyEvent()")
646 << " Invalid key event type of " << sdlevt.type << ". Ignoring event.");
647 return;
648 }
649
650 SDL_Keysym keysym = sdlevt.key.keysym;
651 keyevt.setShiftPressed((keysym.mod & KMOD_SHIFT) != 0);
652 keyevt.setControlPressed((keysym.mod & KMOD_CTRL) != 0);
653 keyevt.setAltPressed((keysym.mod & KMOD_ALT) != 0);
654 keyevt.setMetaPressed((keysym.mod & KMOD_GUI) != 0); // currently gui/super keys
655 keyevt.setNumericPad((keysym.mod & KMOD_NUM) != 0);
656 keyevt.setKey(Key(static_cast<Key::KeyType>(keysym.sym)));
657 }
658
659 void EventManager::fillTextEvent(const SDL_Event& sdlevt, TextEvent& txtevt) {
660 if (sdlevt.type == SDL_TEXTINPUT) {
661 txtevt.setType(TextEvent::INPUT);
662 Text t(sdlevt.text.text);
663 txtevt.setText(t);
664 } else if (sdlevt.type == SDL_TEXTEDITING) {
665 txtevt.setType(TextEvent::EDIT);
666 Text t(sdlevt.edit.text, sdlevt.edit.start, sdlevt.edit.length);
667 txtevt.setText(t);
668 } else {
669 FL_WARN(_log, LMsg("fillTextEvent()")
670 << " Invalid text event type of " << sdlevt.type << ". Ignoring event.");
671 }
672 }
673
674 void EventManager::fillModifiers(InputEvent& evt) {
675 evt.setAltPressed(m_keystatemap[Key::ALT_GR] |
676 m_keystatemap[Key::LEFT_ALT] |
677 m_keystatemap[Key::RIGHT_ALT]);
678 evt.setControlPressed(m_keystatemap[Key::LEFT_CONTROL] |
679 m_keystatemap[Key::RIGHT_CONTROL]);
680 evt.setShiftPressed(m_keystatemap[Key::LEFT_SHIFT] |
681 m_keystatemap[Key::RIGHT_SHIFT]);
682 }
683
684 EventSourceType EventManager::getEventSourceType() {
685 return ES_ENGINE;
686 }
687
688 void EventManager::setKeyFilter(IKeyFilter* keyFilter) {
689 m_keyfilter = keyFilter;
690 }
691
692 void EventManager::setMouseSensitivity(float sensitivity) {
693 if (sensitivity < -0.99) {
694 sensitivity = -0.99;
695 } else if (sensitivity > 10.0) {
696 sensitivity = 10.0;
697 }
698 m_mouseSensitivity = sensitivity;
699 }
700
701 float EventManager::getMouseSensitivity() const {
702 return m_mouseSensitivity;
703 }
704
705 void EventManager::setMouseAccelerationEnabled(bool acceleration) {
706 m_acceleration = acceleration;
707 }
708
709 bool EventManager::isMouseAccelerationEnabled() const {
710 return m_acceleration;
711 }
712
713 bool EventManager::isClipboardText() const {
714 return SDL_HasClipboardText();
715 }
716
717 std::string EventManager::getClipboardText() const {
718 std::string text;
719 if (SDL_HasClipboardText()) {
720 text = std::string(SDL_GetClipboardText());
721 }
722 return text;
723 }
724
725 void EventManager::setClipboardText(const std::string& text) {
726 SDL_SetClipboardText(text.c_str());
727 }
728
729 void EventManager::setJoystickSupport(bool support) {
730 if (support && !m_joystickManager) {
731 m_joystickManager = new JoystickManager();
732 } else if (!support && m_joystickManager) {
733 delete m_joystickManager;
734 m_joystickManager = NULL;
735 }
736 }
737
738 Joystick* EventManager::getJoystick(int32_t instanceId) {
739 if (m_joystickManager) {
740 return m_joystickManager->getJoystick(instanceId);
741 }
742 return NULL;
743 }
744
745 uint8_t EventManager::getJoystickCount() const {
746 if (m_joystickManager) {
747 return m_joystickManager->getJoystickCount();
748 }
749 return 0;
750 }
751
752 void EventManager::loadGamepadMapping(const std::string& file) {
753 if (m_joystickManager) {
754 m_joystickManager->loadMapping(file);
755 }
756 }
757
758 void EventManager::saveGamepadMapping(const std::string guid, const std::string& file) {
759 if (m_joystickManager) {
760 m_joystickManager->saveMapping(guid, file);
761 }
762 }
763
764 void EventManager::saveGamepadMappings(const std::string& file) {
765 if (m_joystickManager) {
766 m_joystickManager->saveMappings(file);
767 }
768 }
769
770 std::string EventManager::getGamepadStringMapping(const std::string& guid) {
771 std::string mapping;
772 if (m_joystickManager) {
773 mapping = m_joystickManager->getStringMapping(guid);
774 }
775 return mapping;
776 }
777
778 void EventManager::setGamepadStringMapping(const std::string& mapping) {
779 if (m_joystickManager) {
780 m_joystickManager->setStringMapping(mapping);
781 }
782 }
783 }