CWE-ou-minkata/Sources/Plasma/PubUtilLib/plInputCore/plInputInterfaceMgr.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  plInputInterfaceMgr.h - The manager of all input interface layers       //
//                                                                          //
//// History /////////////////////////////////////////////////////////////////
//                                                                          //
//  2.20.02 mcn - Created.                                                  //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#ifndef _plInputInterfaceMgr_h
#define _plInputInterfaceMgr_h

#include "pnModifier/plSingleModifier.h"
#include "hsTemplates.h"
#include "hsGeometry3.h"
#include "pnInputCore/plKeyMap.h"

//// Class Definition ////////////////////////////////////////////////////////

class hsStream;
class hsResMgr;
class plInputInterface;
//class plKeyMap;
enum plKeyDef;
enum ControlEventCode;
class plKey;
class plCtrlCmd;
class plKeyCombo;
class plDefaultKeyCatcher;
class plKeyBinding;

class plInputInterfaceMgr : public plSingleModifier
{
    protected:

        static plInputInterfaceMgr  *fInstance;

        hsTArray<plInputInterface *>    fInterfaces;
        hsTArray<plCtrlCmd *>           fMessageQueue;
        hsTArray<plKey>                 fReceivers;

#ifdef MCN_DISABLE_OLD_WITH_NEW_HACK
        hsTArray<ControlEventCode>      fDisabledCodes;
        hsTArray<UInt32>                fDisabledKeys;
#endif

        hsBool      fClickEnabled;
        Int32       fCurrentCursor;
        hsScalar    fCursorOpacity;
        hsBool      fForceCursorHidden;
        Int32       fForceCursorHiddenCount;
        plInputInterface        *fCurrentFocus;
        plDefaultKeyCatcher     *fDefaultCatcher;

        
        virtual hsBool IEval( double secs, hsScalar del, UInt32 dirty );

        void    IAddInterface( plInputInterface *iface );
        void    IRemoveInterface( plInputInterface *iface );

        void    IUpdateCursor( Int32 newCursor );
        hsBool  ICheckCursor(plInputInterface *iFace); // returns true if the iface changed cursor settings
            
        void    IWriteConsoleCmdKeys( plKeyMap *keyMap, FILE *keyFile );
        void    IWriteNonConsoleCmdKeys( plKeyMap *keyMap, FILE *keyFile );

        plKeyMap    *IGetRoutedKeyMap( ControlEventCode code ); // Null for console commands
        void        IUnbind( const plKeyCombo &key );

        const char  *IKeyComboToString( const plKeyCombo &combo );
        
    public:

        plInputInterfaceMgr();
        virtual ~plInputInterfaceMgr();

        CLASSNAME_REGISTER( plInputInterfaceMgr );
        GETINTERFACE_ANY( plInputInterfaceMgr, plSingleModifier );

        virtual hsBool  MsgReceive( plMessage *msg );
        virtual void    Read( hsStream* s, hsResMgr* mgr );
        virtual void    Write( hsStream* s, hsResMgr* mgr );

        void    Init( void );
        void    Shutdown( void );

        void        InitDefaultKeyMap( void );
        void        WriteKeyMap( void );
        void        RefreshInterfaceKeyMaps( void );

        void    SetCurrentFocus(plInputInterface *focus);
        void    ReleaseCurrentFocus(plInputInterface *focus);
        void    SetDefaultKeyCatcher( plDefaultKeyCatcher *c ) { fDefaultCatcher = c; }

        hsBool  IsClickEnabled() { return fClickEnabled; }

        void    ForceCursorHidden( hsBool requestedState );

        // Binding routers
        void    BindAction( const plKeyCombo &key, ControlEventCode code );
        void    BindAction( const plKeyCombo &key1, const plKeyCombo &key2, ControlEventCode code );
        void    BindConsoleCmd( const plKeyCombo &key, const char *cmd, plKeyMap::BindPref pref = plKeyMap::kNoPreference );

        const plKeyBinding* FindBinding( ControlEventCode code );
        const plKeyBinding* FindBindingByConsoleCmd( const char *cmd );

        void    ClearAllKeyMaps();
        void    ResetClickableState();
        static plInputInterfaceMgr  *GetInstance( void ) { return fInstance; }
};

//// plCtrlCmd ///////////////////////////////////////////////////////////////
//  Networkable helper class that represents a single control statement

class plCtrlCmd
{
    private:
        char*               fCmd;
        plInputInterface    *fSource;

    public:
        plCtrlCmd( plInputInterface *source ) : fCmd(nil),fPct(1.0f), fSource(source) {;}
        ~plCtrlCmd() { delete [] fCmd; }

        const char* GetCmdString()          { return fCmd; }
        void SetCmdString(const char* cs)   { delete [] fCmd; fCmd=hsStrcpy(cs); }

        ControlEventCode    fControlCode;
        hsBool              fControlActivated;
        hsPoint3            fPt;
        hsScalar            fPct;

        hsBool              fNetPropagateToPlayers;

        void Read( hsStream* s, hsResMgr* mgr );
        void Write( hsStream* s, hsResMgr* mgr );

        plInputInterface    *GetSource( void ) const { return fSource; }
};

//// Tiny Virtual Class For The Default Key Processor ////////////////////////
//
//  Basically, if you want to be the one to catch the leftover key events,
//  derive from this class and pass yourself to inputIFaceMgr.
//  (it'll auto-tell inputIFaceMgr when it goes away)
//
//  Note: if you want to do more than just get the darned key event (like
//  mouse events or key bindings or change the cursor or the like), don't do
//  this; create your own plInputInterface instead.

class plKeyEventMsg;
class plDefaultKeyCatcher
{
    public:
        virtual ~plDefaultKeyCatcher();
        virtual void    HandleKeyEvent( plKeyEventMsg *eventMsg ) = 0;
};


#endif // _plInputInterfaceMgr_h