OSDLEvents.h

Go to the documentation of this file.

#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, Flags, etc.

#include "SDL.h"                 // for SDL_Event

#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 Ceylan::Uint32 Hertz ;


        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 throw() ; 


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

                
                 virtual void useScheduler( bool on = true ) throw() ;
                                  

                
                virtual void setIdleCallback( 
                    Ceylan::System::Callback idleCallback, 
                    void * callbackData = 0, 
                    Ceylan::System::Microsecond 
                        callbackExpectedMaxDuration = 0 ) throw() ;
                            
                
                virtual void setEventLoopTargetFrequency( 
                    Hertz targetFrequency ) throw() ;
                
                                                        
                virtual void enterMainLoop() throw( EventsException ) ;


                virtual void requestQuit() throw() ;
                



                // Handler subsection.
                
                
                virtual bool hasKeyboardHandler() const throw() ;
                 
                
                virtual KeyboardHandler & getKeyboardHandler() const 
                    throw( EventsException ) ;
                                                            

                virtual void setKeyboardHandler( 
                    KeyboardHandler & newHandler ) throw() ;
                    
                                    
                 
                 
                virtual bool hasJoystickHandler() const throw() ;
                 
                
                virtual JoystickHandler & getJoystickHandler() 
                    const throw( EventsException ) ;
                                                            

                virtual void setJoystickHandler( 
                    JoystickHandler & newHandler ) throw() ;
                    


                virtual bool hasMouseHandler() const throw() ;
                 
                
                virtual MouseHandler & getMouseHandler() const 
                    throw( EventsException ) ;
                                                            

                virtual void setMouseHandler( 
                    MouseHandler & newHandler ) throw() ;
                    
                    
                    
                                    
                virtual void updateInputState() throw() ;
                
                    
                virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) 
                    const throw() ;


                
                // Static section.
                
                    
                static std::string DescribeEnvironmentVariables() throw() ; 



                static bool IsEventsInitialized() throw() ;
        
    
                static Ceylan::System::Millisecond GetMillisecondsSinceStartup()
                    throw( EventsException ) ; 


                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 ) throw() ;
    
    
    
                /*
                 * Basic event types, used to discriminate in the generic
                 * event structure which is the actual type.
                 *
                 */
                                                
                
                static std::string DescribeEvent( BasicEvent anEvent ) throw() ;
                  
    
                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 Hertz DefaultEventLoopTargetedFrequency = 100 ;
                
                
                
                
        protected :
        
        

                virtual void enterBasicMainLoop() throw( EventsException ) ;
                        
        
                
                
                // Keyboard section.
                
            
                virtual void onKeyboardFocusGained( 
                    const FocusEvent & keyboardFocusEvent ) throw() ;   

                
                virtual void onKeyboardFocusLost(
                    const FocusEvent & keyboardFocusEvent ) throw() ;   
                
                
                virtual void onKeyPressed( 
                    const KeyboardEvent & keyboardEvent ) throw() ;
        
        
                virtual void onKeyReleased( 
                    const KeyboardEvent & keyboardEvent ) throw() ;
        
    
    
    
                // Mouse section.
                
                            
                virtual void onMouseFocusGained( 
                    const FocusEvent & mouseFocus ) throw() ;   

                
                virtual void onMouseFocusLost( 
                    const FocusEvent & mouseFocus ) throw() ;   
                
        
        
                virtual void onMouseMotion( 
                    const MouseMotionEvent & mouseEvent ) throw() ; 
                
        
                virtual void onMouseButtonPressed( 
                    const MouseButtonEvent & mouseEvent ) throw() ; 
                
                
                virtual void onMouseButtonReleased( 
                    const MouseButtonEvent & mouseEvent ) throw() ; 
                
                
                

                // Joystick section.
                
                
                virtual void onJoystickAxisChanged( 
                    const JoystickAxisEvent & joystickEvent ) throw() ; 
                
                
                virtual void onJoystickTrackballChanged( 
                    const JoystickTrackballEvent & joystickEvent ) throw() ; 
                
                
                virtual void onJoystickHatChanged( 
                    const JoystickHatEvent & joystickEvent ) throw() ; 
                
                
                virtual void onJoystickButtonPressed( 
                    const JoystickButtonEvent & joystickEvent ) throw() ; 
                
                
                virtual void onJoystickButtonReleased( 
                        const JoystickButtonEvent & joystickEvent ) 
                    throw() ; 
                
                
            
                
                // Application-generic section.
                
                 
                virtual void onIdle() throw() ;
                 
        
                virtual void onApplicationFocusChanged( 
                    const FocusEvent & focusEvent ) throw() ;
                
                
                virtual void onApplicationIconified(
                     const FocusEvent & focusEvent ) throw() ;  

                
                virtual void onApplicationRestored( 
                    const FocusEvent & focusEvent ) throw() ;   


                virtual void onQuitRequested() throw() ;
                
                                
                virtual void onSystemSpecificWindowManagerEvent( 
                    const SystemSpecificWindowManagerEvent & wmEvent ) throw() ;
                    
                
                virtual void onResizedWindow( 
                    const WindowResizedEvent & resizeEvent ) throw() ;
                
                
                virtual void onScreenNeedsRedraw() throw() ;
                
                
                virtual void onUserEvent( const UserEvent & userEvent ) 
                    throw() ;
    

                virtual void onUnknownEventType( 
                    const BasicEvent & unknownEvent ) throw() ;
                
                                    
                    
                 
                // Section for protected attributes.
                                
                                        
                bool _useScheduler ;                


                KeyboardHandler * _keyboardHandler ;

                 
                JoystickHandler * _joystickHandler ;    
                                
                                
                MouseHandler * _mouseHandler ;  
                                
        
        
                static std::string _SDLEnvironmentVariables[] ;


                bool _quitRequested ;
                
                
                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 ) 
                    throw( EventsException ) ;
            
            
                virtual ~EventsModule() throw() ;
                    

                explicit EventsModule( const EventsModule & source ) throw() ;
            
            
                EventsModule & operator = ( const EventsModule & source )
                    throw() ;
                
        } ;
    
    }   
    
}



#endif // OSDL_EVENTS_H_

---