/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ // Standard C++ library includes #include // 3rd party library includes // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "util/base/exception.h" #include "util/log/logger.h" #include "util/math/fife_math.h" #include "eventchannel/joystick/joystickmanager.h" #include "eventchannel/key/key.h" #include "eventchannel/key/keyevent.h" #include "eventchannel/key/ikeyfilter.h" #include "eventchannel/mouse/mouseevent.h" #include "eventchannel/command/command.h" #include "video/renderbackend.h" #include "eventmanager.h" namespace FIFE { static Logger _log(LM_EVTCHANNEL); EventManager::EventManager(): m_commandListeners(), m_keyListeners(), m_textListeners(), m_mouseListeners(), m_sdleventListeners(), m_keystatemap(), m_keyfilter(0), m_mousestate(0), m_mostrecentbtn(MouseEvent::EMPTY), m_mouseSensitivity(0.0), m_acceleration(false), m_warp(false), m_enter(false), m_oldX(0), m_oldY(0), m_lastTicks(0), m_oldVelocity(0.0), m_joystickManager(NULL) { } EventManager::~EventManager() { delete m_joystickManager; } template void addListener(std::deque& vec, T& listener) { if (!listener->isActive()) { listener->setActive(true); vec.push_back(listener); } } template void addListenerFront(std::deque& vec, T& listener) { if (!listener->isActive()) { listener->setActive(true); vec.push_front(listener); } } template void removeListener(std::deque& vec, T& listener) { if (listener->isActive()) { listener->setActive(false); for (typename std::deque::iterator it = vec.begin(); it != vec.end(); ++it) { if (*it == listener) { vec.erase(it); break; } } } } void EventManager::addCommandListener(ICommandListener* listener) { addListener(m_commandListeners, listener); } void EventManager::addCommandListenerFront(ICommandListener* listener) { addListenerFront(m_commandListeners, listener); } void EventManager::removeCommandListener(ICommandListener* listener) { removeListener(m_commandListeners, listener); } void EventManager::addKeyListener(IKeyListener* listener) { addListener(m_keyListeners, listener); } void EventManager::addKeyListenerFront(IKeyListener* listener) { addListenerFront(m_keyListeners, listener); } void EventManager::removeKeyListener(IKeyListener* listener) { removeListener(m_keyListeners, listener); } void EventManager::addTextListener(ITextListener* listener) { addListener(m_textListeners, listener); } void EventManager::addTextListenerFront(ITextListener* listener) { addListenerFront(m_textListeners, listener); } void EventManager::removeTextListener(ITextListener* listener) { removeListener(m_textListeners, listener); } void EventManager::addMouseListener(IMouseListener* listener) { addListener(m_mouseListeners, listener); } void EventManager::addMouseListenerFront(IMouseListener* listener) { addListenerFront(m_mouseListeners, listener); } void EventManager::removeMouseListener(IMouseListener* listener) { removeListener(m_mouseListeners, listener); } void EventManager::addSdlEventListener(ISdlEventListener* listener) { addListener(m_sdleventListeners, listener); } void EventManager::addSdlEventListenerFront(ISdlEventListener* listener) { addListenerFront(m_sdleventListeners, listener); } void EventManager::removeSdlEventListener(ISdlEventListener* listener) { removeListener(m_sdleventListeners, listener); } void EventManager::addDropListener(IDropListener* listener) { addListener(m_dropListeners, listener); } void EventManager::addDropListenerFront(IDropListener* listener) { addListenerFront(m_dropListeners, listener); } void EventManager::removeDropListener(IDropListener* listener) { removeListener(m_dropListeners, listener); } void EventManager::addJoystickListener(IJoystickListener* listener) { if (m_joystickManager) { m_joystickManager->addJoystickListener(listener); } } void EventManager::addJoystickListenerFront(IJoystickListener* listener) { if (m_joystickManager) { m_joystickManager->addJoystickListenerFront(listener); } } void EventManager::removeJoystickListener(IJoystickListener* listener) { if (m_joystickManager) { m_joystickManager->removeJoystickListener(listener); } } void EventManager::dispatchCommand(Command& command) { std::deque listeners = m_commandListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive()) continue; (*i)->onCommand(command); if (command.isConsumed()) { break; } } } void EventManager::dispatchKeyEvent(KeyEvent& evt) { std::deque listeners = m_keyListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive() || (evt.isConsumedByWidgets() && !(*i)->isGlobalListener())) continue; switch (evt.getType()) { case KeyEvent::PRESSED: (*i)->keyPressed(evt); break; case KeyEvent::RELEASED: (*i)->keyReleased(evt); break; default: break; } if (evt.isConsumed()) { break; } } } void EventManager::dispatchTextEvent(TextEvent& evt) { std::deque listeners = m_textListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive()) continue; switch (evt.getType()) { case TextEvent::INPUT: (*i)->textInput(evt); break; case TextEvent::EDIT: (*i)->textEdit(evt); break; default: break; } if (evt.isConsumed()) { break; } } } void EventManager::dispatchMouseEvent(MouseEvent& evt) { std::deque listeners = m_mouseListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive() || (evt.isConsumedByWidgets() && !(*i)->isGlobalListener())) continue; switch (evt.getType()) { case MouseEvent::MOVED: (*i)->mouseMoved(evt); break; case MouseEvent::PRESSED: (*i)->mousePressed(evt); break; case MouseEvent::RELEASED: (*i)->mouseReleased(evt); break; case MouseEvent::WHEEL_MOVED_DOWN: (*i)->mouseWheelMovedDown(evt); break; case MouseEvent::WHEEL_MOVED_UP: (*i)->mouseWheelMovedUp(evt); break; case MouseEvent::WHEEL_MOVED_RIGHT: (*i)->mouseWheelMovedRight(evt); break; case MouseEvent::WHEEL_MOVED_LEFT: (*i)->mouseWheelMovedLeft(evt); break; case MouseEvent::CLICKED: (*i)->mouseClicked(evt); break; case MouseEvent::ENTERED: (*i)->mouseEntered(evt); break; case MouseEvent::EXITED: (*i)->mouseExited(evt); break; case MouseEvent::DRAGGED: (*i)->mouseDragged(evt); break; default: break; } if (evt.isConsumed()) { break; } } } bool EventManager::dispatchSdlEvent(SDL_Event& evt) { bool ret = false; std::deque listeners = m_sdleventListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive()) continue; ret = ret || (*i)->onSdlEvent(evt); } return ret; } void EventManager::dispatchDropEvent(DropEvent& evt) { std::deque listeners = m_dropListeners; std::deque::iterator i = listeners.begin(); for (; i != listeners.end(); ++i) { if (!(*i)->isActive()) continue; (*i)->fileDropped(evt); if (evt.isConsumed()) { break; } } } bool EventManager::combineEvents(SDL_Event& event1, const SDL_Event& event2) { if(event1.type == event2.type) { switch (event1.type) { case SDL_MOUSEMOTION: if(event1.motion.state == event2.motion.state) { event1.motion.x = event2.motion.x; event1.motion.y = event2.motion.y; event1.motion.xrel += event2.motion.xrel; event1.motion.yrel += event2.motion.yrel; return true; } return false; } } return false; } void EventManager::processEvents() { // The double SDL_PollEvent calls don't throw away events, // but try to combine (mouse motion) events. SDL_Event event, next_event; bool has_next_event = (SDL_PollEvent(&event) != 0); while (has_next_event) { has_next_event = (SDL_PollEvent(&next_event) != 0); if (has_next_event && combineEvents(event, next_event)) { continue; } switch (event.type) { case SDL_QUIT: { Command cmd; cmd.setSource(this); cmd.setCommandType(CMD_QUIT_GAME); dispatchCommand(cmd); } break; case SDL_WINDOWEVENT: processWindowEvent(event); break; case SDL_KEYDOWN: case SDL_KEYUP: processKeyEvent(event); break; //case SDL_TEXTEDITING: // is buggy with SDL 2.0.1 case SDL_TEXTINPUT: processTextEvent(event); break; case SDL_MOUSEWHEEL: case SDL_MOUSEBUTTONUP: case SDL_MOUSEMOTION: case SDL_MOUSEBUTTONDOWN: processMouseEvent(event); break; case SDL_DROPFILE: processDropEvent(event); break; case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: case SDL_JOYAXISMOTION: case SDL_JOYHATMOTION: case SDL_JOYDEVICEADDED: case SDL_JOYDEVICEREMOVED: { if (m_joystickManager) { m_joystickManager->processJoystickEvent(event); } break; } case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP: case SDL_CONTROLLERAXISMOTION: { if (m_joystickManager) { m_joystickManager->processControllerEvent(event); } break; } } if (has_next_event) { event = next_event; } } } void EventManager::processWindowEvent(SDL_Event event) { if (dispatchSdlEvent(event)) { return; } CommandType ct = CMD_UNKNOWN; switch (event.window.event) { case SDL_WINDOWEVENT_CLOSE: ct = CMD_QUIT_GAME; break; case SDL_WINDOWEVENT_ENTER: ct = CMD_MOUSE_FOCUS_GAINED; break; case SDL_WINDOWEVENT_LEAVE: ct = CMD_MOUSE_FOCUS_LOST; break; case SDL_WINDOWEVENT_FOCUS_GAINED: ct = CMD_INPUT_FOCUS_GAINED; break; case SDL_WINDOWEVENT_FOCUS_LOST: ct = CMD_INPUT_FOCUS_LOST; break; case SDL_WINDOWEVENT_SHOWN: ct = CMD_APP_RESTORED; break; case SDL_WINDOWEVENT_MINIMIZED: case SDL_WINDOWEVENT_HIDDEN: ct = CMD_APP_ICONIFIED; break; default: ct = CMD_UNKNOWN; } if (ct != CMD_UNKNOWN) { Command cmd; cmd.setCommandType(ct); dispatchCommand(cmd); } } void EventManager::processKeyEvent(SDL_Event event) { KeyEvent keyevt; keyevt.setSource(this); fillKeyEvent(event, keyevt); m_keystatemap[keyevt.getKey().getValue()] = (keyevt.getType() == KeyEvent::PRESSED); // if event is not filtered it gets dispatched, even it is a function key if (!m_keyfilter || !m_keyfilter->isFiltered(keyevt)) { if (dispatchSdlEvent(event)) keyevt.consumedByWidgets(); } dispatchKeyEvent(keyevt); } void EventManager::processTextEvent(SDL_Event event) { if (dispatchSdlEvent(event)) { return; } TextEvent txtevt; txtevt.setSource(this); fillTextEvent(event, txtevt); dispatchTextEvent(txtevt); } void EventManager::processMouseEvent(SDL_Event event) { if (event.type == SDL_MOUSEMOTION && (!Mathf::Equal(m_mouseSensitivity, 0.0) || m_acceleration)) { uint16_t tmp_x = event.motion.x; uint16_t tmp_y = event.motion.y; if (m_enter) { m_oldX = tmp_x; m_oldY = tmp_y; m_oldVelocity = 0.0; m_enter = false; } float modifier; if (m_acceleration) { uint32_t ticks = SDL_GetTicks(); float difference = static_cast((ticks - m_lastTicks) + 1); m_lastTicks = ticks; float dx = static_cast(tmp_x - m_oldX); float dy = static_cast(tmp_y - m_oldY); float distance = Mathf::Sqrt(dx * dx + dy * dy); float acceleration = static_cast((distance / difference) / difference); float velocity = (m_oldVelocity + acceleration * difference)/2; if (velocity > m_mouseSensitivity+1) { velocity = m_mouseSensitivity+1; } m_oldVelocity = velocity; modifier = velocity; } else { modifier = m_mouseSensitivity; } int16_t tmp_xrel = static_cast(tmp_x - m_oldX); int16_t tmp_yrel = static_cast(tmp_y - m_oldY); if ((tmp_xrel != 0) || (tmp_yrel != 0)) { Rect screen = RenderBackend::instance()->getArea(); int16_t x_fact = static_cast(round(static_cast(tmp_xrel * modifier))); int16_t y_fact = static_cast(round(static_cast(tmp_yrel * modifier))); if ((tmp_x + x_fact) > screen.w) { tmp_x = screen.w; } else if ((tmp_x + x_fact) < screen.x) { tmp_x = screen.x; } else { tmp_x += x_fact; } if (tmp_y + y_fact > screen.h) { tmp_y = screen.h; } else if ((tmp_y + y_fact) < screen.y) { tmp_y = screen.y; } else { tmp_y += y_fact; } m_oldX = tmp_x; m_oldY = tmp_y; event.motion.x = tmp_x; event.motion.y = tmp_y; m_warp = true; //don't trigger an event handler when warping SDL_WarpMouseInWindow(RenderBackend::instance()->getWindow(), tmp_x, tmp_y); m_warp = false; } } MouseEvent mouseevt; mouseevt.setSource(this); fillMouseEvent(event, mouseevt); fillModifiers(mouseevt); if (event.type == SDL_MOUSEBUTTONDOWN) { m_mousestate |= static_cast(mouseevt.getButton()); m_mostrecentbtn = mouseevt.getButton(); } else if (event.type == SDL_MOUSEBUTTONUP) { m_mousestate &= ~static_cast(mouseevt.getButton()); } if (dispatchSdlEvent(event)) mouseevt.consumedByWidgets(); dispatchMouseEvent(mouseevt); } void EventManager::processDropEvent(SDL_Event event) { // only dispatched as DropEvent //if (dispatchSdlEvent(event)) { // return; //} char* tmp = event.drop.file; std::string path(tmp); SDL_free(tmp); DropEvent drop; drop.setPath(path); drop.setSource(this); dispatchDropEvent(drop); } void EventManager::fillMouseEvent(const SDL_Event& sdlevt, MouseEvent& mouseevt) { if (m_warp) { return; } mouseevt.setX(sdlevt.button.x); mouseevt.setY(sdlevt.button.y); mouseevt.setButton(MouseEvent::EMPTY); mouseevt.setType(MouseEvent::MOVED); if ((sdlevt.type == SDL_MOUSEBUTTONUP) || (sdlevt.type == SDL_MOUSEBUTTONDOWN)) { switch (sdlevt.button.button) { case SDL_BUTTON_LEFT: mouseevt.setButton(MouseEvent::LEFT); break; case SDL_BUTTON_RIGHT: mouseevt.setButton(MouseEvent::RIGHT); break; case SDL_BUTTON_MIDDLE: mouseevt.setButton(MouseEvent::MIDDLE); break; case SDL_BUTTON_X1: mouseevt.setButton(MouseEvent::X1); break; case SDL_BUTTON_X2: mouseevt.setButton(MouseEvent::X2); break; default: mouseevt.setButton(MouseEvent::UNKNOWN_BUTTON); break; } if (sdlevt.button.state == SDL_RELEASED) { mouseevt.setType(MouseEvent::RELEASED); } else { mouseevt.setType(MouseEvent::PRESSED); } } if (sdlevt.type == SDL_MOUSEWHEEL) { #if SDL_VERSION_ATLEAST(2,0,4) if (sdlevt.wheel.y > 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.y < 0)) { mouseevt.setType(MouseEvent::WHEEL_MOVED_UP); } else if (sdlevt.wheel.y < 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.y > 0)) { mouseevt.setType(MouseEvent::WHEEL_MOVED_DOWN); } if (sdlevt.wheel.x > 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.x < 0)) { mouseevt.setType(MouseEvent::WHEEL_MOVED_RIGHT); } else if (sdlevt.wheel.x < 0 || (sdlevt.wheel.direction == SDL_MOUSEWHEEL_FLIPPED && sdlevt.wheel.x > 0)) { mouseevt.setType(MouseEvent::WHEEL_MOVED_LEFT); } #else if (sdlevt.wheel.y > 0) { mouseevt.setType(MouseEvent::WHEEL_MOVED_UP); } else if (sdlevt.wheel.y < 0) { mouseevt.setType(MouseEvent::WHEEL_MOVED_DOWN); } if (sdlevt.wheel.x > 0) { mouseevt.setType(MouseEvent::WHEEL_MOVED_RIGHT); } else if (sdlevt.wheel.x < 0) { mouseevt.setType(MouseEvent::WHEEL_MOVED_LEFT); } #endif } if ((mouseevt.getType() == MouseEvent::MOVED) && ((m_mousestate & m_mostrecentbtn) != 0)) { mouseevt.setType(MouseEvent::DRAGGED); mouseevt.setButton(m_mostrecentbtn); } } void EventManager::fillKeyEvent(const SDL_Event& sdlevt, KeyEvent& keyevt) { if (sdlevt.type == SDL_KEYDOWN) { keyevt.setType(KeyEvent::PRESSED); } else if (sdlevt.type == SDL_KEYUP) { keyevt.setType(KeyEvent::RELEASED); } else { FL_WARN(_log, LMsg("fillKeyEvent()") << " Invalid key event type of " << sdlevt.type << ". Ignoring event."); return; } SDL_Keysym keysym = sdlevt.key.keysym; keyevt.setShiftPressed((keysym.mod & KMOD_SHIFT) != 0); keyevt.setControlPressed((keysym.mod & KMOD_CTRL) != 0); keyevt.setAltPressed((keysym.mod & KMOD_ALT) != 0); keyevt.setMetaPressed((keysym.mod & KMOD_GUI) != 0); // currently gui/super keys keyevt.setNumericPad((keysym.mod & KMOD_NUM) != 0); keyevt.setKey(Key(static_cast(keysym.sym))); } void EventManager::fillTextEvent(const SDL_Event& sdlevt, TextEvent& txtevt) { if (sdlevt.type == SDL_TEXTINPUT) { txtevt.setType(TextEvent::INPUT); Text t(sdlevt.text.text); txtevt.setText(t); } else if (sdlevt.type == SDL_TEXTEDITING) { txtevt.setType(TextEvent::EDIT); Text t(sdlevt.edit.text, sdlevt.edit.start, sdlevt.edit.length); txtevt.setText(t); } else { FL_WARN(_log, LMsg("fillTextEvent()") << " Invalid text event type of " << sdlevt.type << ". Ignoring event."); } } void EventManager::fillModifiers(InputEvent& evt) { evt.setAltPressed(m_keystatemap[Key::ALT_GR] | m_keystatemap[Key::LEFT_ALT] | m_keystatemap[Key::RIGHT_ALT]); evt.setControlPressed(m_keystatemap[Key::LEFT_CONTROL] | m_keystatemap[Key::RIGHT_CONTROL]); evt.setShiftPressed(m_keystatemap[Key::LEFT_SHIFT] | m_keystatemap[Key::RIGHT_SHIFT]); } EventSourceType EventManager::getEventSourceType() { return ES_ENGINE; } void EventManager::setKeyFilter(IKeyFilter* keyFilter) { m_keyfilter = keyFilter; } void EventManager::setMouseSensitivity(float sensitivity) { if (sensitivity < -0.99) { sensitivity = -0.99; } else if (sensitivity > 10.0) { sensitivity = 10.0; } m_mouseSensitivity = sensitivity; } float EventManager::getMouseSensitivity() const { return m_mouseSensitivity; } void EventManager::setMouseAccelerationEnabled(bool acceleration) { m_acceleration = acceleration; } bool EventManager::isMouseAccelerationEnabled() const { return m_acceleration; } bool EventManager::isClipboardText() const { return SDL_HasClipboardText(); } std::string EventManager::getClipboardText() const { std::string text; if (SDL_HasClipboardText()) { text = std::string(SDL_GetClipboardText()); } return text; } void EventManager::setClipboardText(const std::string& text) { SDL_SetClipboardText(text.c_str()); } void EventManager::setJoystickSupport(bool support) { if (support && !m_joystickManager) { m_joystickManager = new JoystickManager(); } else if (!support && m_joystickManager) { delete m_joystickManager; m_joystickManager = NULL; } } Joystick* EventManager::getJoystick(int32_t instanceId) { if (m_joystickManager) { return m_joystickManager->getJoystick(instanceId); } return NULL; } uint8_t EventManager::getJoystickCount() const { if (m_joystickManager) { return m_joystickManager->getJoystickCount(); } return 0; } void EventManager::loadGamepadMapping(const std::string& file) { if (m_joystickManager) { m_joystickManager->loadMapping(file); } } void EventManager::saveGamepadMapping(const std::string guid, const std::string& file) { if (m_joystickManager) { m_joystickManager->saveMapping(guid, file); } } void EventManager::saveGamepadMappings(const std::string& file) { if (m_joystickManager) { m_joystickManager->saveMappings(file); } } std::string EventManager::getGamepadStringMapping(const std::string& guid) { std::string mapping; if (m_joystickManager) { mapping = m_joystickManager->getStringMapping(guid); } return mapping; } void EventManager::setGamepadStringMapping(const std::string& mapping) { if (m_joystickManager) { m_joystickManager->setStringMapping(mapping); } } }