EventsManager Class Reference

#include <eventsmanager.h>

Inheritance diagram for EventsManager:

Public Member Functions
	EventsManager ()
	~EventsManager ()
void	init ()
void	enableEvents ()
void	shutdown ()
bool	handleEvents () const
bool	handleCommonEvents (const SDL_Event &event) const
void	handleGameEvents () const
void	optionChanged (const std::string &name)
Public Member Functions inherited from ConfigListener
	ConfigListener ()
virtual	~ConfigListener ()

Static Public Member Functions
static void	handleActive (const SDL_Event &event)
static void	logEvent (const SDL_Event &event)

Protected Attributes
bool	mLogInput

Detailed Description

Definition at line 34 of file eventsmanager.h.

Constructor & Destructor Documentation

EventsManager()

EventsManager::EventsManager

(

)

Definition at line 57 of file eventsmanager.cpp.

                             :
    ConfigListener(),
    mLogInput(false)
{
}

~EventsManager()

EventsManager::~EventsManager

(

)

Definition at line 63 of file eventsmanager.cpp.

{
    CHECKLISTENERS
}

References CHECKLISTENERS.

Member Function Documentation

enableEvents()

void EventsManager::enableEvents

(

)

Definition at line 74 of file eventsmanager.cpp.

{
    // 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);
}

References mLogInput.

Referenced by Client::gameInit().

handleActive()

void EventsManager::handleActive ( const SDL_Event &  event )

static

< The application is active

< The app has input focus

< The app has mouse coverage

Definition at line 622 of file eventsmanager.cpp.

{
#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
}

References Settings::awayMode, client, config, State::EXIT, KeyboardFocus::Focused, State::GAME, Configuration::getIntValue(), Client::getState(), Settings::inputFocused, Game::instance(), localPlayer, Settings::mouseFocused, LocalPlayer::setHalfAway(), WindowManager::setIsMinimized(), setPriority(), Client::setState(), settings, KeyboardFocus::Unfocused, Game::updateFrameRate(), Being::updateName(), and LocalPlayer::updateStatus().

Referenced by handleCommonEvents().

handleCommonEvents()

bool EventsManager::handleCommonEvents

(

const SDL_Event &

event

)

const

Definition at line 90 of file eventsmanager.cpp.

{
    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;
}

References BLOCK_END, BLOCK_START, client, State::EXIT, handleActive(), InputManager::handleEvent(), inputManager, Logger::log1(), logEvent(), logger, mLogInput, WindowManager::resizeVideo(), Client::setState(), and WindowManager::updateScreenKeyboard().

Referenced by handleEvents(), and handleGameEvents().

handleEvents()

bool EventsManager::handleEvents

(

)

const

Definition at line 142 of file eventsmanager.cpp.

{
    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;
}

References BLOCK_END, BLOCK_START, client, State::EXIT, Being::getDirection(), Client::getState(), Being::getTileX(), Being::getTileY(), handleCommonEvents(), Game::handleInput(), Game::instance(), localPlayer, Logger::log1(), logger, SDL::PollEvent(), and Client::setState().

Referenced by Client::gameExec().

handleGameEvents()

void EventsManager::handleGameEvents

(

)

const

Definition at line 198 of file eventsmanager.cpp.

{
    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")
}

References BLOCK_END, BLOCK_START, handleCommonEvents(), Game::instance(), and SDL::PollEvent().

Referenced by Game::handleInput().

init()

void EventsManager::init

(

)

Definition at line 68 of file eventsmanager.cpp.

{
    mLogInput = config.getBoolValue("logInput");
    config.addListener("logInput", this);
}

References Configuration::addListener(), config, Configuration::getBoolValue(), and mLogInput.

Referenced by Client::gameInit().

logEvent()

void EventsManager::logEvent ( const SDL_Event &  event )

static

Definition at line 226 of file eventsmanager.cpp.

{
    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;
    }
}

References Logger::assertLog(), CAST_S32, CAST_U32, Logger::log(), logger, mainGraphics, Graphics::mHeight, Graphics::mWidth, and strprintf().

Referenced by handleCommonEvents().

optionChanged()

void EventsManager::optionChanged ( const std::string &  name )

virtual

Called when an option changed. The config listener will have to be registered to the option name first.

Implements ConfigListener.

Definition at line 220 of file eventsmanager.cpp.

{
    if (name == "logInput")
        mLogInput = config.getBoolValue("logInput");
}

References config, Configuration::getBoolValue(), and mLogInput.

shutdown()

void EventsManager::shutdown

(

)

Definition at line 85 of file eventsmanager.cpp.

{
    config.removeListeners(this);
}

References config, and Configuration::removeListeners().

Referenced by Client::gameClear().

Field Documentation

mLogInput

bool EventsManager::mLogInput

protected

Definition at line 67 of file eventsmanager.h.

Referenced by enableEvents(), handleCommonEvents(), init(), and optionChanged().

---

The documentation for this class was generated from the following files:

• src/eventsmanager.h (986a3bf)
• src/eventsmanager.cpp (986a3bf)