OSDLEvents.h

Go to the documentation of this file.

/*
 * Copyright (C) 2003-2010 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option)
 * any later version.
 *
 * The OSDL 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 and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_EVENTS_H_
#define OSDL_EVENTS_H_


#include "OSDLEventsCommon.h"    // for typedefs
#include "OSDLTypes.h"           // for Flag
#include "OSDLException.h"       // for OSDL::Exception

#include "Ceylan.h"              // for Uint32, Hertz, Flags, etc.


#include <string>




namespace OSDL
{



    // The event module is managed by the common module:
    class CommonModule ;



    namespace Engine
    {

        // The event module can use the scheduler.
        class Scheduler ;

    }




    namespace Events
    {



        // The event module can manage the keyboard.
        class KeyboardHandler ;



        // The event module can manage the joysticks.
        class JoystickHandler ;



        // The event module can manage a mouse.
        class MouseHandler ;



        typedef Ceylan::Uint32 Tick ;



        typedef Tick EngineTick ;



        typedef Tick SimulationTick ;



        typedef Tick RenderingTick ;



        typedef Tick InputTick ;



        typedef EngineTick Period ;



        typedef Ceylan::Uint8 BasicEventType  ;



        typedef Ceylan::Uint8 UserEventType ;




        class OSDL_DLL EventsModule : public Ceylan::Module
        {



            // The common module has to create the event module.
            friend class OSDL::CommonModule ;



            public:


                virtual void waitForAnyKey( bool displayWaitingMessage = true )
                    const ;



                virtual void waitForAnyUserInput() const ;



                virtual bool hasPendingUserInput() const ;



                virtual bool getGrabInputMode() const ;



                virtual void setGrabInputMode( bool newMode ) ;



                virtual bool sleepFor( Ceylan::System::Second seconds,
                    Ceylan::System::Microsecond micros ) const ;



                virtual void useScheduler( bool on = true ) ;




                virtual bool isGUIEnabled() const ;



                virtual void setGUIEnableStatus( bool newStatus ) ;




                virtual void setIdleCallback(
                    Ceylan::System::Callback idleCallback,
                    void * callbackData = 0,
                    Ceylan::System::Microsecond
                        callbackExpectedMaxDuration = 0 ) ;



                virtual void setEventLoopTargetFrequency(
                    Ceylan::Maths::Hertz targetFrequency ) ;



                virtual void enterMainLoop() ;



                virtual void requestQuit() ;





                // Handler subsection.



                virtual bool hasKeyboardHandler() const ;



                virtual KeyboardHandler & getKeyboardHandler() const ;



                virtual void setKeyboardHandler(
                    KeyboardHandler & newHandler ) ;




                virtual bool hasJoystickHandler() const ;



                virtual JoystickHandler & getJoystickHandler() const ;



                virtual void setJoystickHandler(
                    JoystickHandler & newHandler ) ;




                virtual bool hasMouseHandler() const ;



                virtual MouseHandler & getMouseHandler() const ;



                virtual void setMouseHandler( MouseHandler & newHandler ) ;




                virtual void updateInputState() ;



                virtual const std::string toString(
                    Ceylan::VerbosityLevels level = Ceylan::high ) const ;




                // Static section.



                static std::string DescribeEnvironmentVariables() ;



                static bool IsEventsInitialized() ;



                static Ceylan::System::Millisecond
                    GetMillisecondsSinceStartup() ;



                static std::string DescribeEvent(
                    const FocusEvent & focusEvent ) ;



                static std::string DescribeEvent(
                    const KeyboardEvent & keyboardEvent ) ;



                static std::string DescribeEvent(
                    const MouseMotionEvent & mouseMotionEvent ) ;



                static std::string DescribeEvent(
                    const MouseButtonEvent & mouseButtonEvent ) ;



                static std::string DescribeEvent(
                    const JoystickAxisEvent & axisEvent ) ;



                static std::string DescribeEvent(
                    const JoystickTrackballEvent & ballEvent ) ;


                static std::string DescribeEvent(
                    const JoystickHatEvent & hatEvent ) ;



                static std::string DescribeEvent(
                    const JoystickButtonEvent & buttonEvent ) ;



                static std::string DescribeEvent(
                    const UserRequestedQuitEvent & quitEvent ) ;



                static std::string DescribeEvent(
                    const SystemSpecificWindowManagerEvent &
                        windowManagerEvent ) ;



                static std::string DescribeEvent(
                    const WindowResizedEvent & resizeEvent ) ;



                static std::string DescribeEvent(
                    const ScreenExposedEvent & redrawEvent ) ;



                static std::string DescribeEvent(
                    const UserEvent & userEvent ) ;



                static Ceylan::System::Microsecond EvaluateCallbackduration(
                    Ceylan::System::Callback callback,
                    void * callbackData ) ;



                /*
                 * Basic event types, used to discriminate in the generic event
                 * structure which is the actual type.
                 *
                 */


                static std::string DescribeEvent( BasicEvent anEvent ) ;



                static const BasicEventType ApplicationFocusChanged ;



                static const BasicEventType KeyPressed ;



                static const BasicEventType KeyReleased ;



                static const BasicEventType MouseMoved ;



                static const BasicEventType MouseButtonPressed ;



                static const BasicEventType MouseButtonReleased ;



                static const BasicEventType JoystickAxisChanged ;



                static const BasicEventType JoystickTrackballChanged ;



                static const BasicEventType JoystickHatPositionChanged ;



                static const BasicEventType JoystickButtonPressed ;



                static const BasicEventType JoystickButtonReleased ;



                static const BasicEventType UserRequestedQuit ;



                static const BasicEventType SystemSpecificTriggered ;



                static const BasicEventType UserResizedVideoMode ;



                static const BasicEventType ScreenNeedsRedraw ;



                static const BasicEventType FirstUserEventTriggered ;



                static const BasicEventType LastUserEventTriggered ;




                // User event types:


                static const UserEventType NoEvent ;



                static const UserEventType QuitRequested ;



                static const Ceylan::Maths::Hertz
                    DefaultEventLoopTargetedFrequency = 100 ;





        protected:



                virtual void enterBasicMainLoop() ;




                // Keyboard section.



                virtual void onKeyboardFocusGained(
                    const FocusEvent & keyboardFocusEvent ) ;



                virtual void onKeyboardFocusLost(
                    const FocusEvent & keyboardFocusEvent ) ;


                virtual void onKeyPressed(
                    const KeyboardEvent & keyboardEvent ) ;



                virtual void onKeyReleased(
                    const KeyboardEvent & keyboardEvent ) ;





                // Mouse section.



                virtual void onMouseFocusGained(
                    const FocusEvent & mouseFocus ) ;



                virtual void onMouseFocusLost(
                    const FocusEvent & mouseFocus ) ;



                virtual void onMouseMotion(
                    const MouseMotionEvent & mouseEvent ) ;



                virtual void onMouseButtonPressed(
                    const MouseButtonEvent & mouseEvent ) ;



                virtual void onMouseButtonReleased(
                    const MouseButtonEvent & mouseEvent ) ;





                // Joystick section.



                virtual void onJoystickAxisChanged(
                    const JoystickAxisEvent & joystickEvent ) ;



                virtual void onJoystickTrackballChanged(
                    const JoystickTrackballEvent & joystickEvent ) ;



                virtual void onJoystickHatChanged(
                    const JoystickHatEvent & joystickEvent ) ;



                virtual void onJoystickButtonPressed(
                    const JoystickButtonEvent & joystickEvent ) ;



                virtual void onJoystickButtonReleased(
                    const JoystickButtonEvent & joystickEvent ) ;





                // Application-generic section.



                virtual void onIdle() ;



                virtual void onApplicationFocusChanged(
                    const FocusEvent & focusEvent ) ;



                virtual void onApplicationIconified(
                     const FocusEvent & focusEvent ) ;



                virtual void onApplicationRestored(
                    const FocusEvent & focusEvent ) ;



                virtual void onQuitRequested() ;



                virtual void onSystemSpecificWindowManagerEvent(
                    const SystemSpecificWindowManagerEvent & wmEvent ) ;



                virtual void onResizedWindow(
                    const WindowResizedEvent & resizeEvent ) ;



                virtual void onScreenNeedsRedraw() ;



                virtual void onUserEvent( const UserEvent & userEvent ) ;



                virtual void onUnknownEventType(
                    const BasicEvent & unknownEvent ) ;





                // Section for protected attributes.



                bool _useScheduler ;


                bool _isGuiEnabled ;


                KeyboardHandler * _keyboardHandler ;



                JoystickHandler * _joystickHandler ;



                MouseHandler * _mouseHandler ;



                static const std::string _SDLEnvironmentVariables[] ;



                bool _quitRequested ;



                Ceylan::Maths::Hertz _loopTargetedFrequency ;



                Ceylan::Uint32 _idleCallsCount ;



                Ceylan::System::Callback _loopIdleCallback ;



                void * _loopIdleCallbackData ;



                Ceylan::System::Microsecond _loopIdleCallbackMaxDuration ;




                // Static section.



                static bool _EventsInitialized ;



                static const Ceylan::Uint32 _FrameTimingSlotsCount ;



                static const Ceylan::Sint16 _MouseFocus ;



                static const Ceylan::Sint16 _KeyboardFocus ;



                static const Ceylan::Sint16 _ApplicationFocus ;



                static const std::string _MessageHeader ;



                static const Ceylan::Uint32 _MouseButtonCount ;





        private:



                explicit EventsModule( Ceylan::Flags eventsFlag ) ;



                virtual ~EventsModule() throw() ;



                explicit EventsModule( const EventsModule & source ) ;



                EventsModule & operator = ( const EventsModule & source ) ;


        } ;


    }

}



#endif // OSDL_EVENTS_H_

---