CWE-ou-minkata/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIControlHandlers.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==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  pfGUIControlHandlers Header                                             //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#ifndef _pfGUIControlHandlers_h
#define _pfGUIControlHandlers_h

#include "hsStream.h"

//// pfGUICtrlProcObject Definition //////////////////////////////////////////
//  Any control which "does something" (buttons, edit boxes on Enter/Return, 
//  etc) uses this in some form. Basically, each control will have an (optional?)
//  pointer to an object derived from this class type. The class has a single
//  standard, virtual function that gets called on the "do something" event.
//  Derive from this class, override the virtual and set the control's handler
//  to your object and you're all set. Kinda like windowProcs wrapped in a
//  C++ object.
//  Note: there are some predefined objects for simple, common events. See
//  below.
//  Note the second: DoSomething() takes a parameter--namely, a pointer to
//  the control that called it. Thus, you can make one object handle
//  several controls by just switch()ing on that parameter and save yourself
//  some object creation. 
//
//  UserCallback() is an additional function for use in communicating between
//  procs. Basically, if you want another proc to do something (another dialog),
//  and want you to get called once it's done, set the callback on the other
//  proc/whatever to you and override UserCallback().
//
//  HandleExtendedEvent() is similar to DoSomething(), but is called for extended
//  event types, such as value changing (for an edit control while typing) or
//  list scrolled. The event parameter is control-type-specific.
//
//  Dialogs will use a similar functionality, but with more functions available.

class pfGUIControlMod;
class pfGUICtrlProcObject
{
    protected:

        UInt32      fRefCnt;

    public:

        pfGUICtrlProcObject() { fRefCnt = 0; }
        virtual ~pfGUICtrlProcObject() { ; }

        virtual void    DoSomething( pfGUIControlMod *ctrl ) = 0;

        virtual void    HandleExtendedEvent( pfGUIControlMod *ctrl, UInt32 event ) { ; }

        virtual void    UserCallback( UInt32 userValue ) { ; }

        // ONLY THE GUI SYSTEM SHOULD CALL THESE
        void    IncRef( void ) { fRefCnt++; }
        hsBool  DecRef( void ) { fRefCnt--; return ( fRefCnt > 0 ) ? false : true; }
};

//// pfGUICtrlProcWriteableObject ////////////////////////////////////////////
//  This one is a read/writeable version of the above. Basically, you can just
//  call Read/Write() and it'll do all the mini-functionality of the factory
//  stuff so you don't have to worry about the derived type at runtime. Do
//  NOT derive from this class for your own handlers; this is just for the
//  handfull that will get added on export.

class pfGUICtrlProcWriteableObject : public pfGUICtrlProcObject
{
    protected:

        UInt32          fType;

        virtual void    IRead( hsStream *s ) = 0;
        virtual void    IWrite( hsStream *s ) = 0;

    public:

        enum Types
        {
            kNull,
            kConsoleCmd,
            kPythonScript,
            kCloseDlg
        };

        pfGUICtrlProcWriteableObject() { fType = kNull; }
        pfGUICtrlProcWriteableObject( UInt32 type ) : fType( type ) { ; }
        virtual ~pfGUICtrlProcWriteableObject() { ; }

        virtual void    DoSomething( pfGUIControlMod *ctrl ) = 0;

        static void Write( pfGUICtrlProcWriteableObject *obj, hsStream *s );

        static pfGUICtrlProcWriteableObject *Read( hsStream *s );
};

//// pfGUIConsoleCmdProc /////////////////////////////////////////////////////
//  Simply runs the console command specified. Exportable.

class pfGUIConsoleCmdProc : public pfGUICtrlProcWriteableObject
{
    protected:

        char            *fCommand;

        virtual void    IRead( hsStream *s );
        virtual void    IWrite( hsStream *s );
    
    public:

        pfGUIConsoleCmdProc();
        pfGUIConsoleCmdProc( const char *cmd );
        virtual ~pfGUIConsoleCmdProc();

        virtual void    DoSomething( pfGUIControlMod *ctrl );

        void            SetCommand( const char *cmd );
};

//// pfGUIPythonScriptProc ///////////////////////////////////////////////////

class pfGUIPythonScriptProc : public pfGUICtrlProcWriteableObject
{
    protected:

        virtual void    IRead( hsStream *s );
        virtual void    IWrite( hsStream *s );
    
    public:

        pfGUIPythonScriptProc();
        virtual ~pfGUIPythonScriptProc();

        virtual void    DoSomething( pfGUIControlMod *ctrl );
};

//// Simple Runtime Ones /////////////////////////////////////////////////////

class pfGUICloseDlgProc : public pfGUICtrlProcWriteableObject
{
    protected:

        virtual void    IRead( hsStream *s ) {}
        virtual void    IWrite( hsStream *s ) {}

    public:

        pfGUICloseDlgProc() : pfGUICtrlProcWriteableObject( kCloseDlg ) {}
        virtual ~pfGUICloseDlgProc() {}

        virtual void    DoSomething( pfGUIControlMod *ctrl );
};

#endif // _pfGUIControlHandlers_h