arsmessages.h

Go to the documentation of this file.

#if !defined( __ARSMESSAGES_H__ )
#define __ARSMESSAGES_H__

namespace Ars
{

class MessageClient;

class Message   {
public:

        enum EMessageType
        {
                UNKNOWN = 0,  
                KEYBOARD_KEYDOWN = 1,  
                KEYBOARD_KEYUP = 2,  
                MOUSE_BUTTONDOWN = 3,  
                MOUSE_BUTTONUP = 4,  
                MOUSE_MOVE = 5,  
                CTRL_LCLICK = 7,  
                CTRL_RCLICK = 8,  
                CTRL_MCLICK = 9,  
                CTRL_VALUECHANGE = 10,  
                CTRL_VALUECHANGING = 11,  
                CTRL_RESIZE = 12,  
                CTRL_TIMER = 13,        
                APP_PAINT = 14,  
                APP_EXIT = 15,  
                SETUP_WINDOW = 16, 
                LOST_FOCUS = 17 ,       
                SET_FOCUS = 18 ,                
                DEREG_CHILD = 19 ,      
                PLAY_MPEG = 20 ,        
                USER = 200 
        };

private:

        const EMessageType messageType;

        MessageClient   *destination;

public:

        void    *from;
        unsigned int    line;
        std::string     file;

        Message( const EMessageType MessageType , MessageClient *pdestination = 0 )
        : messageType( MessageType ) , destination( pdestination )      {}

        virtual ~Message( void )        {}

        const EMessageType MessageType( void ) const  { return messageType; }

        MessageClient *Destination( void ) const  { return destination; }

        void SetTarget( MessageClient *dest )   {       destination = dest;     }
};

class KeyboardMessage : public Message  {
private:

public:
        KeyboardMessage( const EMessageType MessageType, MessageClient *pDestination, const unsigned char ScanCode, const SDLMod Modifiers, const SDLKey Key, const Uint16 Unicode)
        : Message( MessageType , pDestination ) , ScanCode(ScanCode), Modifiers(Modifiers), Key(Key), Unicode(Unicode)
        {}

        const unsigned char ScanCode;  
        const SDLMod Modifiers;  
        const SDLKey Key;  
        const Uint16 Unicode;  
};


class MouseMessage : public Message     {
public:
        enum EMouseButton
        {
                NONE = 0, 
                LEFT = 1,  
                RIGHT = 2,  
                MIDDLE = 4  
        };

        MouseMessage( const  EMessageType MessageType, MessageClient* pDestination, const  XPoint &Point, const XPoint &Relative, const unsigned int Button)
        : Message( MessageType , pDestination ) , Point(Point), Relative(Relative), Button(Button)
        {}


        static unsigned int TranslateSDLButton(Uint8 SDLButton);

        static unsigned int TranslateSDLButtonState(Uint8 SDLButtonState);

        const XPoint Point;  
        const XPoint Relative;  
        const unsigned int Button;  
};


class CtrlMessage : public Message      {
public:
        CtrlMessage( const  EMessageType MessageType, MessageClient* pDestination, const  void* pSource, const  long int aValue = 0 )
        : Message( MessageType , pDestination ) , source( pSource ) , value( aValue )
        {}

        const void      *source;

        const long int value;
};



class ResizeMessage : public CtrlMessage        {
public:
        ResizeMessage( const EMessageType MessageType, MessageClient* pDestination, const void* pSource, const XPoint& NewSize)
        : CtrlMessage( MessageType , pDestination , pSource ) , size( NewSize )
        {}


        const XPoint size;
};


class UserMessage : public Message      {
private:
        const unsigned long int subMessage;

        const void *data;

public:
        UserMessage( const EMessageType MessageType , MessageClient* pDestination , const unsigned long int aSubMessage , const void *pData = 0 )
        : Message( MessageType , pDestination ) , subMessage( aSubMessage ) , data( pData ) 
        {}

        const unsigned long int SubMessage( void ) const        {       return subMessage;      }

        const void *Data( void ) const  {       return data;    }
};

class MessageClient     {
public:
        MessageClient( void );

        virtual ~MessageClient( void );

        virtual const bool HandleMessage( const Message &msg );

        virtual const bool IsVisible( void ) const      {       return true;    };

        virtual const bool evKeyDown( const KeyboardMessage &msg )      {       return false;   }
        virtual const bool evKeyUp( const KeyboardMessage &msg )        {       return false;   }
        virtual const bool evMouseButtonDown( const MouseMessage &msg ) {       return false;   }
        virtual const bool evMouseButtonUp( const MouseMessage &msg )   {       return false;   }
        virtual const bool evMouseMove( const MouseMessage &msg )       {       return false;   }
        virtual const bool evMouseLClick( const CtrlMessage &msg )      {       return false;   }
        virtual const bool evMouseMClick( const CtrlMessage &msg )      {       return false;   }
        virtual const bool evMouseRClick( const CtrlMessage &msg )      {       return false;   }
        virtual const bool evValueChange( const CtrlMessage &msg )      {       return false;   }
        virtual const bool evValueChanging( const CtrlMessage &msg )    {       return false;   }
        virtual const bool evTimer( const CtrlMessage &msg )    {       return false;   }
        virtual const bool wmResize( const ResizeMessage &msg ) {       return false;   }
        virtual const bool wmSetFocus( const Message &msg )     {       return false;   }
        virtual const bool wmLostFocus( const CtrlMessage &msg )        {       return false;   }
        virtual const bool wmPaint( const Message &msg )        {       return false;   }
        virtual const bool SetupWindow( const Message &msg )    {       return false;   }
        virtual const bool wmExit( const Message &msg ) {       return false;   }
        virtual const bool DeregChild( const CtrlMessage &msg ) {       return false;   }
        virtual const bool evPlayMpeg( const CtrlMessage &msg ) {       return false;   }
        virtual const bool evMessage( const UserMessage &msg )  {       return false;   }
};

//typedef std::multimap<unsigned char, CMessageClient*, std::greater<unsigned char> > t_MessageClientPriorityMap;

//typedef std::map<CMessage::EMessageType, t_MessageClientPriorityMap> t_MessageClientMap;



class MessageServer : public std::deque<Message *>      {
protected:

        friend class Form;

        static MessageServer    *instance;  
        std::map< Message::EMessageType , std::vector< std::pair<MessageClient *, bool> > >     messageClients;  

        MessageServer(void);

public:

        virtual ~MessageServer(void);

        static MessageServer& Instance( void );

        void RegisterMessageClient( MessageClient* pClient, const Message::EMessageType eMessageType );

        void DeregisterMessageClient( MessageClient* pClient, const Message::EMessageType eMessageType );

        void DeregisterMessageClient( MessageClient* pClient );

        void ProcessMessage( void );

        void QueueMessage( Message *msg , const int aLine , const std::string aFile , void *aFrom );
        
        void LaunchMessage( Message *msg);

        const bool IsRegistered( const Message::EMessageType &type , const MessageClient *target );

private:

        void HandleTillRoot( Message &msg );
};

#define ArsPostMessage( a )     MessageServer::Instance().QueueMessage( new a , __LINE__ , __FILE__ , this )
#define ArsSendMessage( a )     MessageServer::Instance().LaunchMessage( new a )

}

#endif

---