Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/eventsmanager.cpp	Lines:	9	142	6.3 %
Date:	2021-03-17	Branches:	2	89	2.2 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2012-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "eventsmanager.h"

#include "configuration.h"
#include "client.h"
#ifndef DYECMD
#include "game.h"
#endif  // DYECMD
#ifdef USE_MUMBLE
#include "mumblemanager.h"
#endif  // USE_MUMBLE
#include "sdlshared.h"
#include "settings.h"

#include "gui/windowmanager.h"

#include "being/localplayer.h"

#include "input/inputmanager.h"

#ifdef USE_SDL2
#include "render/graphics.h"
#else  // USE_SDL2
#include "logger.h"
#endif  // USE_SDL2

#include "utils/process.h"
#include "utils/sdlhelper.h"
#ifdef USE_X11
#include "utils/x11logger.h"
#endif  // USE_X11

#include "debug.h"

EventsManager eventsManager;

EventsManager::EventsManager() :
    ConfigListener(),
    mLogInput(false)
{
}

EventsManager::~EventsManager()
{
    CHECKLISTENERS
}

void EventsManager::init()
{
    mLogInput = config.getBoolValue("logInput");
    config.addListener("logInput", this);
}

void EventsManager::enableEvents()
{
    // disable unused SDL events
#ifndef USE_SDL2
    SDL_EventState(SDL_VIDEOEXPOSE, SDL_IGNORE);
#endif  // USE_SDL2

    SDL_EventState(SDL_SYSWMEVENT, mLogInput ? SDL_ENABLE : SDL_IGNORE);
    SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
}

void EventsManager::shutdown()
{
    config.removeListeners(this);
}

bool EventsManager::handleCommonEvents(const SDL_Event &event) const
{
    BLOCK_START("EventsManager::handleCommonEvents")
    if (mLogInput)
        logEvent(event);

    switch (event.type)
    {
        case SDL_QUIT:
            client->setState(State::EXIT);
            logger->log1("force exit");
            BLOCK_END("EventsManager::handleCommonEvents")
            return true;
#ifdef USE_SDL2
        case SDL_WINDOWEVENT:
            handleSDL2WindowEvent(event);
            BLOCK_END("EventsManager::handleCommonEvents")
            return true;
#else  // USE_SDL2
        case SDL_VIDEORESIZE:
            WindowManager::resizeVideo(event.resize.w,
                event.resize.h,
                false);
            BLOCK_END("EventsManager::handleCommonEvents")
            return true;
        case SDL_ACTIVEEVENT:
            handleActive(event);
            BLOCK_END("EventsManager::handleCommonEvents")
            return true;
#ifdef ANDROID
        case SDL_KEYBOARDSHOW:
            WindowManager::updateScreenKeyboard(event.user.code);
            BLOCK_END("EventsManager::handleCommonEvents")
            return true;
        case SDL_ACCELEROMETER:
            break;
#endif  // ANDROID
#endif  // USE_SDL2
        default:
            break;
    }

    if (inputManager.handleEvent(event))
    {
        BLOCK_END("EventsManager::handleCommonEvents")
        return true;
    }

    BLOCK_END("EventsManager::handleCommonEvents")
    return false;
}

bool EventsManager::handleEvents() const
{
    BLOCK_START("EventsManager::handleEvents")
#ifndef DYECMD
    if (Game::instance() != nullptr)
    {
        // Let the game handle the events while it is active
        Game::instance()->handleInput();
    }
    else
#endif  // DYECMD
    {
        SDL_Event event;
        // Handle SDL events
        while (SDL::PollEvent(&event))
        {
            if (!handleCommonEvents(event))
            {
#ifdef ANDROID
#ifndef USE_SDL2
                switch (event.type)
                {
                    case SDL_ACTIVEEVENT:
                        if ((event.active.state & SDL_APPACTIVE)
                            && !event.active.gain)
                        {
                            client->setState(State::EXIT);
                            logger->log1("exit on lost focus");
                        }
                        break;

                    default:
                        break;
                }
#endif  // USE_SDL2
#endif  // ANDROID
            }

#ifdef USE_MUMBLE
            if (localPlayer && mumbleManager)
            {
                mumbleManager->setPos(localPlayer->getTileX(),
                    localPlayer->getTileY(), localPlayer->getDirection());
            }
#endif  // USE_MUMBLE
        }
        if (client->getState() == State::EXIT)
        {
            BLOCK_END("EventsManager::handleEvents")
            return true;
        }
    }
    BLOCK_END("EventsManager::handleEvents")
    return false;
}

void EventsManager::handleGameEvents() const
{
    BLOCK_START("EventsManager::handleGameEvents")
#ifndef DYECMD
    Game *const game = Game::instance();

    // Events
    SDL_Event event;
    while (SDL::PollEvent(&event))
    {
        if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP)
            game->updateHistory(event);
        game->checkKeys();

        if (handleCommonEvents(event))
            break;
    }  // End while
#endif  // DYECMD

    BLOCK_END("EventsManager::handleGameEvents")
}

void EventsManager::optionChanged(const std::string &name)
{
    if (name == "logInput")
        mLogInput = config.getBoolValue("logInput");
}

void EventsManager::logEvent(const SDL_Event &event)
{
    switch (event.type)
    {
#ifdef USE_SDL2
#define winEventLog(name, name2) \
    case name: \
        str = name2; \
        break

        case SDL_MOUSEMOTION:
            logger->log("event: SDL_MOUSEMOTION: %u, %d,%d, %d,%d",
                event.motion.state,
                event.motion.x,
                event.motion.y,
                event.motion.xrel,
                event.motion.yrel);
            break;
        case SDL_FINGERDOWN:
        {
            const SDL_TouchFingerEvent &touch = event.tfinger;
            const int w = mainGraphics->mWidth;
            const int h = mainGraphics->mHeight;
            logger->log("event: SDL_FINGERDOWN: %u,%u (%f,%f) (%f,%f) %f",
                CAST_U32(touch.touchId),
                CAST_U32(touch.fingerId),
                touch.x * w, touch.y * w,
                touch.dx * w, touch.dy * h,
                touch.pressure);
            break;
        }
        case SDL_FINGERUP:
        {
            const SDL_TouchFingerEvent &touch = event.tfinger;
            const int w = mainGraphics->mWidth;
            const int h = mainGraphics->mHeight;
            logger->log("event: SDL_FINGERUP: %u,%u (%f,%f) (%f,%f) %f",
                CAST_U32(touch.touchId),
                CAST_U32(touch.fingerId),
                touch.x * w, touch.y * w,
                touch.dx * w, touch.dy * h,
                touch.pressure);
            break;
        }
        case SDL_FINGERMOTION:
        {
            const SDL_TouchFingerEvent &touch = event.tfinger;
            const int w = mainGraphics->mWidth;
            const int h = mainGraphics->mHeight;
            logger->log("event: SDL_FINGERMOTION: %u,%u (%f,%f) (%f,%f) %f",
                CAST_U32(touch.touchId),
                CAST_U32(touch.fingerId),
                touch.x * w, touch.y * h,
                touch.dx * w, touch.dy * h,
                touch.pressure);
            break;
        }
        case SDL_MULTIGESTURE:
        {
            const SDL_MultiGestureEvent &gesture = event.mgesture;
            const int w = mainGraphics->mWidth;
            const int h = mainGraphics->mHeight;
            logger->log("event: SDL_MULTIGESTURE: %u %f,%f (%f,%f) %d",
                CAST_U32(gesture.touchId),
                gesture.dTheta, gesture.dDist,
                gesture.x * w, gesture.y * h,
                CAST_S32(gesture.numFingers));
            break;
        }
        case SDL_KEYDOWN:
            logger->log("event: SDL_KEYDOWN: %s(%d) %s(%d) %d,%d,%u",
                SDL_GetScancodeName(event.key.keysym.scancode),
                event.key.keysym.scancode,
                SDL_GetKeyName(event.key.keysym.sym),
                event.key.keysym.sym,
                event.key.state,
                event.key.repeat,
                CAST_U32(event.key.keysym.mod));
            break;
        case SDL_KEYUP:
            logger->log("event: SDL_KEYUP: %s(%d) %s(%d) %d,%d,%u",
                SDL_GetScancodeName(event.key.keysym.scancode),
                event.key.keysym.scancode,
                SDL_GetKeyName(event.key.keysym.sym),
                event.key.keysym.sym,
                event.key.state,
                event.key.repeat,
                CAST_U32(event.key.keysym.mod));
            break;
        case SDL_WINDOWEVENT:
        {
            const int data1 = event.window.data1;
            const int data2 = event.window.data2;
            std::string str;
            switch (event.window.event)
            {
                winEventLog(SDL_WINDOWEVENT_NONE, "SDL_WINDOWEVENT_NONE");
                winEventLog(SDL_WINDOWEVENT_SHOWN, "SDL_WINDOWEVENT_SHOWN");
                winEventLog(SDL_WINDOWEVENT_HIDDEN, "SDL_WINDOWEVENT_HIDDEN");
                winEventLog(SDL_WINDOWEVENT_EXPOSED,
                    "SDL_WINDOWEVENT_EXPOSED");
                winEventLog(SDL_WINDOWEVENT_MOVED, "SDL_WINDOWEVENT_MOVED");
                winEventLog(SDL_WINDOWEVENT_RESIZED,
                    "SDL_WINDOWEVENT_RESIZED");
                winEventLog(SDL_WINDOWEVENT_SIZE_CHANGED,
                    "SDL_WINDOWEVENT_SIZE_CHANGED");
                winEventLog(SDL_WINDOWEVENT_MINIMIZED,
                    "SDL_WINDOWEVENT_MINIMIZED");
                winEventLog(SDL_WINDOWEVENT_MAXIMIZED,
                    "SDL_WINDOWEVENT_MAXIMIZED");
                winEventLog(SDL_WINDOWEVENT_RESTORED,
                    "SDL_WINDOWEVENT_RESTORED");
                winEventLog(SDL_WINDOWEVENT_ENTER, "SDL_WINDOWEVENT_ENTER");
                winEventLog(SDL_WINDOWEVENT_LEAVE, "SDL_WINDOWEVENT_LEAVE");
                winEventLog(SDL_WINDOWEVENT_FOCUS_GAINED,
                    "SDL_WINDOWEVENT_FOCUS_GAINED");
                winEventLog(SDL_WINDOWEVENT_FOCUS_LOST,
                    "SDL_WINDOWEVENT_FOCUS_LOST");
                winEventLog(SDL_WINDOWEVENT_CLOSE, "SDL_WINDOWEVENT_CLOSE");
#if SDL_VERSION_ATLEAST(2, 0, 5)
                winEventLog(SDL_WINDOWEVENT_TAKE_FOCUS,
                    "SDL_WINDOWEVENT_TAKE_FOCUS");
                winEventLog(SDL_WINDOWEVENT_HIT_TEST,
                    "SDL_WINDOWEVENT_HIT_TEST");
#endif  // SDL_VERSION_ATLEAST(2, 0, 5)
                default:
                    str = strprintf("unknown: %d",
                        event.window.event);
                    break;
            }
            logger->log("event: SDL_WINDOWEVENT: %s: %d,%d",
                str.c_str(), data1, data2);
            break;
        }
        case SDL_TEXTINPUT:
        {
            const char *const text = event.text.text;
            logger->log("event: SDL_TEXTINPUT: %s", text);
            const size_t sz = strlen(event.text.text);
            for (size_t f = 0; f < sz; f ++)
                logger->log("dec: %d", text[f]);
            break;
        }
        case SDL_APP_TERMINATING:
            logger->log("SDL_APP_TERMINATING");
            break;
        case SDL_APP_LOWMEMORY:
            logger->log("SDL_APP_LOWMEMORY");
            break;
        case SDL_APP_WILLENTERBACKGROUND:
            logger->log("SDL_APP_WILLENTERBACKGROUND");
            break;
        case SDL_APP_WILLENTERFOREGROUND:
            logger->log("SDL_APP_WILLENTERFOREGROUND");
            break;
        case SDL_APP_DIDENTERFOREGROUND:
            logger->log("SDL_APP_DIDENTERFOREGROUND");
            break;
        case SDL_APP_DIDENTERBACKGROUND:
            logger->log("SDL_APP_DIDENTERBACKGROUND");
            break;
        case SDL_MOUSEWHEEL:
#if SDL_VERSION_ATLEAST(2, 0, 4)
            logger->log("event: SDL_MOUSEWHEEL: %u,%u, %d,%d, %u",
                event.wheel.windowID,
                event.wheel.which,
                event.wheel.x,
                event.wheel.y,
                event.wheel.direction);
#else  // SDL_VERSION_ATLEAST(2, 0, 4)

            logger->log("event: SDL_MOUSEWHEEL: %u,%u, %d,%d",
                event.wheel.windowID,
                event.wheel.which,
                event.wheel.x,
                event.wheel.y);
#endif  // SDL_VERSION_ATLEAST(2, 0, 4)
            break;
#if SDL_VERSION_ATLEAST(2, 0, 4)
        case SDL_AUDIODEVICEADDED:
            logger->log("event: SDL_AUDIODEVICEADDED: %u,%u",
                event.adevice.which,
                event.adevice.iscapture);
            break;
        case SDL_KEYMAPCHANGED:
            logger->log("event: SDL_KEYMAPCHANGED");
            break;
#endif  // SDL_VERSION_ATLEAST(2, 0, 4)
        case SDL_MOUSEBUTTONDOWN:
            logger->log("event: SDL_MOUSEBUTTONDOWN: %u,%u,%u, %d,%d",
                event.button.which,
                CAST_U32(event.button.button),
                CAST_U32(event.button.state),
                event.button.x,
                event.button.y);
            break;
        case SDL_MOUSEBUTTONUP:
            logger->log("event: SDL_MOUSEBUTTONUP: %u,%u,%u, %d,%d",
                event.button.which,
                CAST_U32(event.button.button),
                CAST_U32(event.button.state),
                event.button.x,
                event.button.y);
            break;
        case SDL_JOYDEVICEADDED:
            logger->log("event: SDL_JOYDEVICEADDED: %d",
                event.jdevice.which);
            break;
        case SDL_JOYDEVICEREMOVED:
            logger->log("event: SDL_JOYDEVICEREMOVED: %d",
                event.jdevice.which);
            break;
#else  // USE_SDL2

        case SDL_MOUSEMOTION:
            logger->log("event: SDL_MOUSEMOTION: %u,%d,%d",
                event.motion.state, event.motion.x, event.motion.y);
            break;
        case SDL_KEYDOWN:
            logger->log("event: SDL_KEYDOWN: %s(%d),%d,%d,%d",
                SDL_GetKeyName(event.key.keysym.sym),
                event.key.keysym.sym,
                event.key.keysym.scancode,
                event.key.state,
                event.key.keysym.unicode);
            break;
        case SDL_KEYUP:
            logger->log("event: SDL_KEYUP: %s(%d),%d,%d,%d",
                SDL_GetKeyName(event.key.keysym.sym),
                event.key.keysym.sym,
                event.key.keysym.scancode,
                event.key.state,
                event.key.keysym.unicode);
            break;
        case SDL_VIDEORESIZE:
            logger->log("event: SDL_VIDEORESIZE");
            break;
        case SDL_VIDEOEXPOSE:
            logger->log("event: SDL_VIDEOEXPOSE");
            break;
        case SDL_ACTIVEEVENT:
            logger->log("event: SDL_ACTIVEEVENT: %d %d",
                event.active.state, event.active.gain);
            break;
        case SDL_MOUSEBUTTONDOWN:
            logger->log("event: SDL_MOUSEBUTTONDOWN: %d,%d, %d,%d",
                event.button.button,
                event.button.state,
                event.button.x,
                event.button.y);
            break;
        case SDL_MOUSEBUTTONUP:
            logger->log("event: SDL_MOUSEBUTTONUP: %d,%d,%d,%d",
                event.button.button,
                event.button.state,
                event.button.x,
                event.button.y);
            break;
#endif  // USE_SDL2

        case SDL_JOYAXISMOTION:
            logger->log("event: SDL_JOYAXISMOTION: %d,%d,%d",
                event.jaxis.which, event.jaxis.axis, event.jaxis.value);
            break;
        case SDL_JOYBALLMOTION:
            logger->log("event: SDL_JOYBALLMOTION: %d,%d,%d,%d",
                event.jball.which, event.jball.ball,
                event.jball.xrel, event.jball.yrel);
            break;
        case SDL_JOYHATMOTION:
            logger->log("event: SDL_JOYHATMOTION: %d,%d,%d", event.jhat.which,
                event.jhat.hat, event.jhat.value);
            break;
        case SDL_JOYBUTTONDOWN:
            logger->log("event: SDL_JOYBUTTONDOWN: %d,%d,%d",
                event.jbutton.which, event.jbutton.button,
                event.jbutton.state);
            break;
        case SDL_JOYBUTTONUP:
            logger->log("event: SDL_JOYBUTTONUP: %d,%d,%d",
                event.jbutton.which, event.jbutton.button,
                event.jbutton.state);
            break;
        case SDL_QUIT:
            logger->log("event: SDL_QUIT");
            break;
        case SDL_SYSWMEVENT:
        {
#ifdef USE_X11
            const bool res = X11Logger::logEvent(event);
            if (res == false)
                logger->assertLog("event: SDL_SYSWMEVENT: not supported:");
#else  // USE_X11

            logger->assertLog("event: SDL_SYSWMEVENT: not supported:");
#endif  // USE_X11

            break;
        }
        case SDL_USEREVENT:
            logger->log("event: SDL_USEREVENT: %d",
                event.user.code);
            break;
#ifdef ANDROID
#ifndef USE_SDL2
        case SDL_ACCELEROMETER:
            logger->log("event: SDL_ACCELEROMETER");
            break;
#endif  // USE_SDL2
#endif  // ANDROID

        default:
            logger->assertLog("event: other: %u",
                CAST_U32(event.type));
            break;
    }
}

#ifdef USE_SDL2
void EventsManager::handleSDL2WindowEvent(const SDL_Event &event)
{
#ifndef DYECMD
    int fpsLimit = 0;
#endif  // DYECMD

    const int eventType = event.window.event;
    const bool inGame = (client->getState() == State::GAME);
    switch (eventType)
    {
        case SDL_WINDOWEVENT_RESIZED:
            WindowManager::resizeVideo(event.window.data1,
                event.window.data2,
                false);
            break;
        case SDL_WINDOWEVENT_ENTER:
            settings.mouseFocused = true;
            break;
        case SDL_WINDOWEVENT_LEAVE:
            settings.mouseFocused = false;
            break;
        case SDL_WINDOWEVENT_FOCUS_GAINED:
            settings.inputFocused = KeyboardFocus::Focused;
            break;
#if SDL_VERSION_ATLEAST(2, 0, 5)
        case SDL_WINDOWEVENT_TAKE_FOCUS:
            settings.inputFocused = KeyboardFocus::Focused2;
            break;
#endif  // SDL_VERSION_ATLEAST(2, 0, 5)

        case SDL_WINDOWEVENT_FOCUS_LOST:
            settings.inputFocused = KeyboardFocus::Unfocused;
            break;
        case SDL_WINDOWEVENT_MINIMIZED:
            WindowManager::setIsMinimized(true);
#ifndef DYECMD
            fpsLimit = config.getIntValue("altfpslimit");
            if (localPlayer)
                localPlayer->setHalfAway(true);
#endif  // DYECMD

            setPriority(false);
            break;
        case SDL_WINDOWEVENT_RESTORED:
        case SDL_WINDOWEVENT_MAXIMIZED:
            WindowManager::setIsMinimized(false);
#ifndef DYECMD
            fpsLimit = config.getIntValue("fpslimit");
            if (localPlayer)
                localPlayer->setHalfAway(false);
#endif  // DYECMD

            setPriority(true);
            break;
        default:
            break;
    }

    if (!inGame)
        return;

#ifndef DYECMD
    if (eventType == SDL_WINDOWEVENT_MINIMIZED
        || eventType == SDL_WINDOWEVENT_RESTORED
        || eventType == SDL_WINDOWEVENT_MAXIMIZED)
    {
        if (localPlayer)
        {
            localPlayer->updateStatus();
            localPlayer->updateName();
        }
        Game::instance()->updateFrameRate(fpsLimit);
    }
#endif  // DYECMD
}
#else  // USE_SDL2

void EventsManager::handleActive(const SDL_Event &event)
{
#ifndef DYECMD
    int fpsLimit = 0;
    const bool inGame = (client->getState() == State::GAME);
#endif  // DYECMD

    if ((event.active.state & SDL_APPACTIVE) != 0)
    {
        if (event.active.gain != 0U)
        {   // window restore
            WindowManager::setIsMinimized(false);
#ifndef DYECMD
            if (localPlayer != nullptr)
            {
                if (!settings.awayMode)
                    fpsLimit = config.getIntValue("fpslimit");
                localPlayer->setHalfAway(false);
            }
#endif  // DYECMD

            setPriority(true);
        }
        else
        {   // window minimization
#ifdef ANDROID
            client->setState(State::EXIT);
#else  // ANDROID
            WindowManager::setIsMinimized(true);
#ifndef DYECMD
            if (localPlayer != nullptr && !settings.awayMode)
            {
                fpsLimit = config.getIntValue("altfpslimit");
                localPlayer->setHalfAway(true);
            }
#endif  // DYECMD

            setPriority(false);
#endif  // ANDROID
        }
#ifndef DYECMD
        if (inGame && (localPlayer != nullptr))
            localPlayer->updateStatus();
#endif  // DYECMD
    }
#ifndef DYECMD
    if (inGame && (localPlayer != nullptr))
        localPlayer->updateName();
#endif  // DYECMD

    if ((event.active.state & SDL_APPINPUTFOCUS) != 0)
    {
        settings.inputFocused = (event.active.gain != 0U) ?
            KeyboardFocus::Focused : KeyboardFocus::Unfocused;
    }
    if ((event.active.state & SDL_APPMOUSEFOCUS) != 0)
        settings.mouseFocused = (event.active.gain != 0U);
#ifndef DYECMD
    if (inGame)
        Game::instance()->updateFrameRate(fpsLimit);
#endif  // DYECMD
}
#endif  // USE_SDL2


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2012-2019 The ManaPlus Developers
4			* Copyright (C) 2019-2021 Andrei Karas
5			*
6			* This file is part of The ManaPlus Client.
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20			*/
21
22			#include "eventsmanager.h"
23
24			#include "configuration.h"
25			#include "client.h"
26			#ifndef DYECMD
27			#include "game.h"
28			#endif // DYECMD
29			#ifdef USE_MUMBLE
30			#include "mumblemanager.h"
31			#endif // USE_MUMBLE
32			#include "sdlshared.h"
33			#include "settings.h"
34
35			#include "gui/windowmanager.h"
36
37			#include "being/localplayer.h"
38
39			#include "input/inputmanager.h"
40
41			#ifdef USE_SDL2
42			#include "render/graphics.h"
43			#else // USE_SDL2
44			#include "logger.h"
45			#endif // USE_SDL2
46
47			#include "utils/process.h"
48			#include "utils/sdlhelper.h"
49			#ifdef USE_X11
50			#include "utils/x11logger.h"
51			#endif // USE_X11
52
53			#include "debug.h"
54
55		1	EventsManager eventsManager;
56
57		1	EventsManager::EventsManager() :
58			ConfigListener(),
59		2	mLogInput(false)
60			{
61			}
62
63		1	EventsManager::~EventsManager()
64			{
65			CHECKLISTENERS
66		1	}
67
68			void EventsManager::init()
69			{
70			mLogInput = config.getBoolValue("logInput");
71			config.addListener("logInput", this);
72			}
73
74			void EventsManager::enableEvents()
75			{
76			// disable unused SDL events
77			#ifndef USE_SDL2
78			SDL_EventState(SDL_VIDEOEXPOSE, SDL_IGNORE);
79			#endif // USE_SDL2
80
81			SDL_EventState(SDL_SYSWMEVENT, mLogInput ? SDL_ENABLE : SDL_IGNORE);
82			SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
83			}
84
85		215	void EventsManager::shutdown()
86			{
87		215	config.removeListeners(this);
88		215	}
89
90			bool EventsManager::handleCommonEvents(const SDL_Event &event) const
91			{
92			BLOCK_START("EventsManager::handleCommonEvents")
93			if (mLogInput)
94			logEvent(event);
95
96			switch (event.type)
97			{
98			case SDL_QUIT:
99			client->setState(State::EXIT);
100			logger->log1("force exit");
101			BLOCK_END("EventsManager::handleCommonEvents")
102			return true;
103			#ifdef USE_SDL2
104			case SDL_WINDOWEVENT:
105			handleSDL2WindowEvent(event);
106			BLOCK_END("EventsManager::handleCommonEvents")
107			return true;
108			#else // USE_SDL2
109			case SDL_VIDEORESIZE:
110			WindowManager::resizeVideo(event.resize.w,
111			event.resize.h,
112			false);
113			BLOCK_END("EventsManager::handleCommonEvents")
114			return true;
115			case SDL_ACTIVEEVENT:
116			handleActive(event);
117			BLOCK_END("EventsManager::handleCommonEvents")
118			return true;
119			#ifdef ANDROID
120			case SDL_KEYBOARDSHOW:
121			WindowManager::updateScreenKeyboard(event.user.code);
122			BLOCK_END("EventsManager::handleCommonEvents")
123			return true;
124			case SDL_ACCELEROMETER:
125			break;
126			#endif // ANDROID
127			#endif // USE_SDL2
128			default:
129			break;
130			}
131
132			if (inputManager.handleEvent(event))
133			{
134			BLOCK_END("EventsManager::handleCommonEvents")
135			return true;
136			}
137
138			BLOCK_END("EventsManager::handleCommonEvents")
139			return false;
140			}
141
142			bool EventsManager::handleEvents() const
143			{
144			BLOCK_START("EventsManager::handleEvents")
145			#ifndef DYECMD
146			if (Game::instance() != nullptr)
147			{
148			// Let the game handle the events while it is active
149			Game::instance()->handleInput();
150			}
151			else
152			#endif // DYECMD
153			{
154			SDL_Event event;
155			// Handle SDL events
156			while (SDL::PollEvent(&event))
157			{
158			if (!handleCommonEvents(event))
159			{
160			#ifdef ANDROID
161			#ifndef USE_SDL2
162			switch (event.type)
163			{
164			case SDL_ACTIVEEVENT:
165			if ((event.active.state & SDL_APPACTIVE)
166			&& !event.active.gain)
167			{
168			client->setState(State::EXIT);
169			logger->log1("exit on lost focus");
170			}
171			break;
172
173			default:
174			break;
175			}
176			#endif // USE_SDL2
177			#endif // ANDROID
178			}
179
180			#ifdef USE_MUMBLE
181			if (localPlayer && mumbleManager)
182			{
183			mumbleManager->setPos(localPlayer->getTileX(),
184			localPlayer->getTileY(), localPlayer->getDirection());
185			}
186			#endif // USE_MUMBLE
187			}
188			if (client->getState() == State::EXIT)
189			{
190			BLOCK_END("EventsManager::handleEvents")
191			return true;
192			}
193			}
194			BLOCK_END("EventsManager::handleEvents")
195			return false;
196			}
197
198			void EventsManager::handleGameEvents() const
199			{
200			BLOCK_START("EventsManager::handleGameEvents")
201			#ifndef DYECMD
202			Game *const game = Game::instance();
203
204			// Events
205			SDL_Event event;
206			while (SDL::PollEvent(&event))
207			{
208			if (event.type == SDL_KEYDOWN \|\| event.type == SDL_KEYUP)
209			game->updateHistory(event);
210			game->checkKeys();
211
212			if (handleCommonEvents(event))
213			break;
214			} // End while
215			#endif // DYECMD
216
217			BLOCK_END("EventsManager::handleGameEvents")
218			}
219
220			void EventsManager::optionChanged(const std::string &name)
221			{
222			if (name == "logInput")
223			mLogInput = config.getBoolValue("logInput");
224			}
225
226			void EventsManager::logEvent(const SDL_Event &event)
227			{
228			switch (event.type)
229			{
230			#ifdef USE_SDL2
231			#define winEventLog(name, name2) \
232			case name: \
233			str = name2; \
234			break
235
236			case SDL_MOUSEMOTION:
237			logger->log("event: SDL_MOUSEMOTION: %u, %d,%d, %d,%d",
238			event.motion.state,
239			event.motion.x,
240			event.motion.y,
241			event.motion.xrel,
242			event.motion.yrel);
243			break;
244			case SDL_FINGERDOWN:
245			{
246			const SDL_TouchFingerEvent &touch = event.tfinger;
247			const int w = mainGraphics->mWidth;
248			const int h = mainGraphics->mHeight;
249			logger->log("event: SDL_FINGERDOWN: %u,%u (%f,%f) (%f,%f) %f",
250			CAST_U32(touch.touchId),
251			CAST_U32(touch.fingerId),
252			touch.x * w, touch.y * w,
253			touch.dx * w, touch.dy * h,
254			touch.pressure);
255			break;
256			}
257			case SDL_FINGERUP:
258			{
259			const SDL_TouchFingerEvent &touch = event.tfinger;
260			const int w = mainGraphics->mWidth;
261			const int h = mainGraphics->mHeight;
262			logger->log("event: SDL_FINGERUP: %u,%u (%f,%f) (%f,%f) %f",
263			CAST_U32(touch.touchId),
264			CAST_U32(touch.fingerId),
265			touch.x * w, touch.y * w,
266			touch.dx * w, touch.dy * h,
267			touch.pressure);
268			break;
269			}
270			case SDL_FINGERMOTION:
271			{
272			const SDL_TouchFingerEvent &touch = event.tfinger;
273			const int w = mainGraphics->mWidth;
274			const int h = mainGraphics->mHeight;
275			logger->log("event: SDL_FINGERMOTION: %u,%u (%f,%f) (%f,%f) %f",
276			CAST_U32(touch.touchId),
277			CAST_U32(touch.fingerId),
278			touch.x * w, touch.y * h,
279			touch.dx * w, touch.dy * h,
280			touch.pressure);
281			break;
282			}
283			case SDL_MULTIGESTURE:
284			{
285			const SDL_MultiGestureEvent &gesture = event.mgesture;
286			const int w = mainGraphics->mWidth;
287			const int h = mainGraphics->mHeight;
288			logger->log("event: SDL_MULTIGESTURE: %u %f,%f (%f,%f) %d",
289			CAST_U32(gesture.touchId),
290			gesture.dTheta, gesture.dDist,
291			gesture.x * w, gesture.y * h,
292			CAST_S32(gesture.numFingers));
293			break;
294			}
295			case SDL_KEYDOWN:
296			logger->log("event: SDL_KEYDOWN: %s(%d) %s(%d) %d,%d,%u",
297			SDL_GetScancodeName(event.key.keysym.scancode),
298			event.key.keysym.scancode,
299			SDL_GetKeyName(event.key.keysym.sym),
300			event.key.keysym.sym,
301			event.key.state,
302			event.key.repeat,
303			CAST_U32(event.key.keysym.mod));
304			break;
305			case SDL_KEYUP:
306			logger->log("event: SDL_KEYUP: %s(%d) %s(%d) %d,%d,%u",
307			SDL_GetScancodeName(event.key.keysym.scancode),
308			event.key.keysym.scancode,
309			SDL_GetKeyName(event.key.keysym.sym),
310			event.key.keysym.sym,
311			event.key.state,
312			event.key.repeat,
313			CAST_U32(event.key.keysym.mod));
314			break;
315			case SDL_WINDOWEVENT:
316			{
317			const int data1 = event.window.data1;
318			const int data2 = event.window.data2;
319			std::string str;
320			switch (event.window.event)
321			{
322			winEventLog(SDL_WINDOWEVENT_NONE, "SDL_WINDOWEVENT_NONE");
323			winEventLog(SDL_WINDOWEVENT_SHOWN, "SDL_WINDOWEVENT_SHOWN");
324			winEventLog(SDL_WINDOWEVENT_HIDDEN, "SDL_WINDOWEVENT_HIDDEN");
325			winEventLog(SDL_WINDOWEVENT_EXPOSED,
326			"SDL_WINDOWEVENT_EXPOSED");
327			winEventLog(SDL_WINDOWEVENT_MOVED, "SDL_WINDOWEVENT_MOVED");
328			winEventLog(SDL_WINDOWEVENT_RESIZED,
329			"SDL_WINDOWEVENT_RESIZED");
330			winEventLog(SDL_WINDOWEVENT_SIZE_CHANGED,
331			"SDL_WINDOWEVENT_SIZE_CHANGED");
332			winEventLog(SDL_WINDOWEVENT_MINIMIZED,
333			"SDL_WINDOWEVENT_MINIMIZED");
334			winEventLog(SDL_WINDOWEVENT_MAXIMIZED,
335			"SDL_WINDOWEVENT_MAXIMIZED");
336			winEventLog(SDL_WINDOWEVENT_RESTORED,
337			"SDL_WINDOWEVENT_RESTORED");
338			winEventLog(SDL_WINDOWEVENT_ENTER, "SDL_WINDOWEVENT_ENTER");
339			winEventLog(SDL_WINDOWEVENT_LEAVE, "SDL_WINDOWEVENT_LEAVE");
340			winEventLog(SDL_WINDOWEVENT_FOCUS_GAINED,
341			"SDL_WINDOWEVENT_FOCUS_GAINED");
342			winEventLog(SDL_WINDOWEVENT_FOCUS_LOST,
343			"SDL_WINDOWEVENT_FOCUS_LOST");
344			winEventLog(SDL_WINDOWEVENT_CLOSE, "SDL_WINDOWEVENT_CLOSE");
345			#if SDL_VERSION_ATLEAST(2, 0, 5)
346			winEventLog(SDL_WINDOWEVENT_TAKE_FOCUS,
347			"SDL_WINDOWEVENT_TAKE_FOCUS");
348			winEventLog(SDL_WINDOWEVENT_HIT_TEST,
349			"SDL_WINDOWEVENT_HIT_TEST");
350			#endif // SDL_VERSION_ATLEAST(2, 0, 5)
351			default:
352			str = strprintf("unknown: %d",
353			event.window.event);
354			break;
355			}
356			logger->log("event: SDL_WINDOWEVENT: %s: %d,%d",
357			str.c_str(), data1, data2);
358			break;
359			}
360			case SDL_TEXTINPUT:
361			{
362			const char *const text = event.text.text;
363			logger->log("event: SDL_TEXTINPUT: %s", text);
364			const size_t sz = strlen(event.text.text);
365			for (size_t f = 0; f < sz; f ++)
366			logger->log("dec: %d", text[f]);
367			break;
368			}
369			case SDL_APP_TERMINATING:
370			logger->log("SDL_APP_TERMINATING");
371			break;
372			case SDL_APP_LOWMEMORY:
373			logger->log("SDL_APP_LOWMEMORY");
374			break;
375			case SDL_APP_WILLENTERBACKGROUND:
376			logger->log("SDL_APP_WILLENTERBACKGROUND");
377			break;
378			case SDL_APP_WILLENTERFOREGROUND:
379			logger->log("SDL_APP_WILLENTERFOREGROUND");
380			break;
381			case SDL_APP_DIDENTERFOREGROUND:
382			logger->log("SDL_APP_DIDENTERFOREGROUND");
383			break;
384			case SDL_APP_DIDENTERBACKGROUND:
385			logger->log("SDL_APP_DIDENTERBACKGROUND");
386			break;
387			case SDL_MOUSEWHEEL:
388			#if SDL_VERSION_ATLEAST(2, 0, 4)
389			logger->log("event: SDL_MOUSEWHEEL: %u,%u, %d,%d, %u",
390			event.wheel.windowID,
391			event.wheel.which,
392			event.wheel.x,
393			event.wheel.y,
394			event.wheel.direction);
395			#else // SDL_VERSION_ATLEAST(2, 0, 4)
396
397			logger->log("event: SDL_MOUSEWHEEL: %u,%u, %d,%d",
398			event.wheel.windowID,
399			event.wheel.which,
400			event.wheel.x,
401			event.wheel.y);
402			#endif // SDL_VERSION_ATLEAST(2, 0, 4)
403			break;
404			#if SDL_VERSION_ATLEAST(2, 0, 4)
405			case SDL_AUDIODEVICEADDED:
406			logger->log("event: SDL_AUDIODEVICEADDED: %u,%u",
407			event.adevice.which,
408			event.adevice.iscapture);
409			break;
410			case SDL_KEYMAPCHANGED:
411			logger->log("event: SDL_KEYMAPCHANGED");
412			break;
413			#endif // SDL_VERSION_ATLEAST(2, 0, 4)
414			case SDL_MOUSEBUTTONDOWN:
415			logger->log("event: SDL_MOUSEBUTTONDOWN: %u,%u,%u, %d,%d",
416			event.button.which,
417			CAST_U32(event.button.button),
418			CAST_U32(event.button.state),
419			event.button.x,
420			event.button.y);
421			break;
422			case SDL_MOUSEBUTTONUP:
423			logger->log("event: SDL_MOUSEBUTTONUP: %u,%u,%u, %d,%d",
424			event.button.which,
425			CAST_U32(event.button.button),
426			CAST_U32(event.button.state),
427			event.button.x,
428			event.button.y);
429			break;
430			case SDL_JOYDEVICEADDED:
431			logger->log("event: SDL_JOYDEVICEADDED: %d",
432			event.jdevice.which);
433			break;
434			case SDL_JOYDEVICEREMOVED:
435			logger->log("event: SDL_JOYDEVICEREMOVED: %d",
436			event.jdevice.which);
437			break;
438			#else // USE_SDL2
439
440			case SDL_MOUSEMOTION:
441			logger->log("event: SDL_MOUSEMOTION: %u,%d,%d",
442			event.motion.state, event.motion.x, event.motion.y);
443			break;
444			case SDL_KEYDOWN:
445			logger->log("event: SDL_KEYDOWN: %s(%d),%d,%d,%d",
446			SDL_GetKeyName(event.key.keysym.sym),
447			event.key.keysym.sym,
448			event.key.keysym.scancode,
449			event.key.state,
450			event.key.keysym.unicode);
451			break;
452			case SDL_KEYUP:
453			logger->log("event: SDL_KEYUP: %s(%d),%d,%d,%d",
454			SDL_GetKeyName(event.key.keysym.sym),
455			event.key.keysym.sym,
456			event.key.keysym.scancode,
457			event.key.state,
458			event.key.keysym.unicode);
459			break;
460			case SDL_VIDEORESIZE:
461			logger->log("event: SDL_VIDEORESIZE");
462			break;
463			case SDL_VIDEOEXPOSE:
464			logger->log("event: SDL_VIDEOEXPOSE");
465			break;
466			case SDL_ACTIVEEVENT:
467			logger->log("event: SDL_ACTIVEEVENT: %d %d",
468			event.active.state, event.active.gain);
469			break;
470			case SDL_MOUSEBUTTONDOWN:
471			logger->log("event: SDL_MOUSEBUTTONDOWN: %d,%d, %d,%d",
472			event.button.button,
473			event.button.state,
474			event.button.x,
475			event.button.y);
476			break;
477			case SDL_MOUSEBUTTONUP:
478			logger->log("event: SDL_MOUSEBUTTONUP: %d,%d,%d,%d",
479			event.button.button,
480			event.button.state,
481			event.button.x,
482			event.button.y);
483			break;
484			#endif // USE_SDL2
485
486			case SDL_JOYAXISMOTION:
487			logger->log("event: SDL_JOYAXISMOTION: %d,%d,%d",
488			event.jaxis.which, event.jaxis.axis, event.jaxis.value);
489			break;
490			case SDL_JOYBALLMOTION:
491			logger->log("event: SDL_JOYBALLMOTION: %d,%d,%d,%d",
492			event.jball.which, event.jball.ball,
493			event.jball.xrel, event.jball.yrel);
494			break;
495			case SDL_JOYHATMOTION:
496			logger->log("event: SDL_JOYHATMOTION: %d,%d,%d", event.jhat.which,
497			event.jhat.hat, event.jhat.value);
498			break;
499			case SDL_JOYBUTTONDOWN:
500			logger->log("event: SDL_JOYBUTTONDOWN: %d,%d,%d",
501			event.jbutton.which, event.jbutton.button,
502			event.jbutton.state);
503			break;
504			case SDL_JOYBUTTONUP:
505			logger->log("event: SDL_JOYBUTTONUP: %d,%d,%d",
506			event.jbutton.which, event.jbutton.button,
507			event.jbutton.state);
508			break;
509			case SDL_QUIT:
510			logger->log("event: SDL_QUIT");
511			break;
512			case SDL_SYSWMEVENT:
513			{
514			#ifdef USE_X11
515			const bool res = X11Logger::logEvent(event);
516			if (res == false)
517			logger->assertLog("event: SDL_SYSWMEVENT: not supported:");
518			#else // USE_X11
519
520			logger->assertLog("event: SDL_SYSWMEVENT: not supported:");
521			#endif // USE_X11
522
523			break;
524			}
525			case SDL_USEREVENT:
526			logger->log("event: SDL_USEREVENT: %d",
527			event.user.code);
528			break;
529			#ifdef ANDROID
530			#ifndef USE_SDL2
531			case SDL_ACCELEROMETER:
532			logger->log("event: SDL_ACCELEROMETER");
533			break;
534			#endif // USE_SDL2
535			#endif // ANDROID
536
537			default:
538			logger->assertLog("event: other: %u",
539			CAST_U32(event.type));
540			break;
541			}
542			}
543
544			#ifdef USE_SDL2
545			void EventsManager::handleSDL2WindowEvent(const SDL_Event &event)
546			{
547			#ifndef DYECMD
548			int fpsLimit = 0;
549			#endif // DYECMD
550
551			const int eventType = event.window.event;
552			const bool inGame = (client->getState() == State::GAME);
553			switch (eventType)
554			{
555			case SDL_WINDOWEVENT_RESIZED:
556			WindowManager::resizeVideo(event.window.data1,
557			event.window.data2,
558			false);
559			break;
560			case SDL_WINDOWEVENT_ENTER:
561			settings.mouseFocused = true;
562			break;
563			case SDL_WINDOWEVENT_LEAVE:
564			settings.mouseFocused = false;
565			break;
566			case SDL_WINDOWEVENT_FOCUS_GAINED:
567			settings.inputFocused = KeyboardFocus::Focused;
568			break;
569			#if SDL_VERSION_ATLEAST(2, 0, 5)
570			case SDL_WINDOWEVENT_TAKE_FOCUS:
571			settings.inputFocused = KeyboardFocus::Focused2;
572			break;
573			#endif // SDL_VERSION_ATLEAST(2, 0, 5)
574
575			case SDL_WINDOWEVENT_FOCUS_LOST:
576			settings.inputFocused = KeyboardFocus::Unfocused;
577			break;
578			case SDL_WINDOWEVENT_MINIMIZED:
579			WindowManager::setIsMinimized(true);
580			#ifndef DYECMD
581			fpsLimit = config.getIntValue("altfpslimit");
582			if (localPlayer)
583			localPlayer->setHalfAway(true);
584			#endif // DYECMD
585
586			setPriority(false);
587			break;
588			case SDL_WINDOWEVENT_RESTORED:
589			case SDL_WINDOWEVENT_MAXIMIZED:
590			WindowManager::setIsMinimized(false);
591			#ifndef DYECMD
592			fpsLimit = config.getIntValue("fpslimit");
593			if (localPlayer)
594			localPlayer->setHalfAway(false);
595			#endif // DYECMD
596
597			setPriority(true);
598			break;
599			default:
600			break;
601			}
602
603			if (!inGame)
604			return;
605
606			#ifndef DYECMD
607			if (eventType == SDL_WINDOWEVENT_MINIMIZED
608			\|\| eventType == SDL_WINDOWEVENT_RESTORED
609			\|\| eventType == SDL_WINDOWEVENT_MAXIMIZED)
610			{
611			if (localPlayer)
612			{
613			localPlayer->updateStatus();
614			localPlayer->updateName();
615			}
616			Game::instance()->updateFrameRate(fpsLimit);
617			}
618			#endif // DYECMD
619			}
620			#else // USE_SDL2
621
622			void EventsManager::handleActive(const SDL_Event &event)
623			{
624			#ifndef DYECMD
625			int fpsLimit = 0;
626			const bool inGame = (client->getState() == State::GAME);
627			#endif // DYECMD
628
629			if ((event.active.state & SDL_APPACTIVE) != 0)
630			{
631			if (event.active.gain != 0U)
632			{ // window restore
633			WindowManager::setIsMinimized(false);
634			#ifndef DYECMD
635			if (localPlayer != nullptr)
636			{
637			if (!settings.awayMode)
638			fpsLimit = config.getIntValue("fpslimit");
639			localPlayer->setHalfAway(false);
640			}
641			#endif // DYECMD
642
643			setPriority(true);
644			}
645			else
646			{ // window minimization
647			#ifdef ANDROID
648			client->setState(State::EXIT);
649			#else // ANDROID
650			WindowManager::setIsMinimized(true);
651			#ifndef DYECMD
652			if (localPlayer != nullptr && !settings.awayMode)
653			{
654			fpsLimit = config.getIntValue("altfpslimit");
655			localPlayer->setHalfAway(true);
656			}
657			#endif // DYECMD
658
659			setPriority(false);
660			#endif // ANDROID
661			}
662			#ifndef DYECMD
663			if (inGame && (localPlayer != nullptr))
664			localPlayer->updateStatus();
665			#endif // DYECMD
666			}
667			#ifndef DYECMD
668			if (inGame && (localPlayer != nullptr))
669			localPlayer->updateName();
670			#endif // DYECMD
671
672			if ((event.active.state & SDL_APPINPUTFOCUS) != 0)
673			{
674			settings.inputFocused = (event.active.gain != 0U) ?
675			KeyboardFocus::Focused : KeyboardFocus::Unfocused;
676			}
677			if ((event.active.state & SDL_APPMOUSEFOCUS) != 0)
678			settings.mouseFocused = (event.active.gain != 0U);
679			#ifndef DYECMD
680			if (inGame)
681			Game::instance()->updateFrameRate(fpsLimit);
682			#endif // DYECMD
683	✓✗✓✗	3	}
684			#endif // USE_SDL2