events.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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 3
 * of the License, or (at your option) any later version.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef EVENTS_EVENTS_H
#define EVENTS_EVENTS_H

#include <list>
#include <vector>

#include "src/common/types.h"
#include "src/common/ptrvector.h"
#include "src/common/singleton.h"
#include "src/common/mutex.h"

#include "src/events/types.h"
#include "src/events/joystick.h"

namespace Common {
    class UString;
}

namespace Events {

class Request;

class EventsManager : public Common::Singleton<EventsManager> {
public:
    EventsManager();

    // Initialization

    void init();
    void deinit();

    void reset();

    bool ready() const;


    // Quitting

    bool quitRequested() const;
    void requestQuit();

    void doQuit();

    // For the game thread to signal the main thread that the engine code threw

    bool fatalErrorRaised() const;
    void raiseFatalError();


    // Timing

    void delay(uint32 ms);
    uint32 getTimestamp() const;


    // Events

    void flushEvents();

    bool pollEvent(Event &event);

    bool pushEvent(Event &event);


    // Keyboard input

    void enableKeyRepeat(bool repeat = true);

    void enableTextInput(bool textInput = true);

    Common::UString getTextInput(const Event &event);


    // Joystick input

    size_t getJoystickCount() const;

    Joystick *getJoystickByIndex(size_t index) const;
    Joystick *getJoystickByName(const Common::UString &name) const;


    bool isQueueFull() const;

    void runMainLoop();


private:
    typedef Common::PtrVector<Joystick> Joysticks;

    typedef std::list<Event> EventQueue;
    typedef void (EventsManager::*RequestHandler)(Request &);

    static const RequestHandler _requestHandler[kITCEventMAX];

    bool _ready; 

    bool _quitRequested; 
    bool _doQuit;        

    bool _fatalError;

    Joysticks _joysticks;

    EventQueue _eventQueue;
    Common::Mutex _eventQueueMutex;

    size_t _queueSize;

    bool _fullQueue;
    Common::Condition _queueProcessed;

    bool _repeat;
    uint _repeatCounter;

    uint _textInputCounter;


    void initJoysticks();
    void deinitJoysticks();

    bool parseEventQuit(const Event &event);
    bool parseEventGraphics(const Event &event);
    bool parseITC(const Event &event);

    // Request handler
    void requestCallInMainThread(Request &request);
    void requestRebuildGLContainer(Request &request);
    void requestDestroyGLContainer(Request &request);

    void processEvents();

    friend class RequestManager;
};

} // End of namespace Events

#define EventMan Events::EventsManager::instance()

#endif // EVENTS_EVENTS_H