251cced1f8
Various minor things done to project files Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way) Updated regex project file and makefile --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971
710 lines
22 KiB
C++
710 lines
22 KiB
C++
//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#ifndef CONVAR_H
|
|
#define CONVAR_H
|
|
|
|
#if _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier0/dbg.h"
|
|
#include "tier1/iconvar.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "tier1/utlstring.h"
|
|
#include "icvar.h"
|
|
|
|
#ifdef _WIN32
|
|
#define FORCEINLINE_CVAR FORCEINLINE
|
|
#elif _LINUX
|
|
#define FORCEINLINE_CVAR inline
|
|
#else
|
|
#error "implement me"
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class ConVar;
|
|
class CCommand;
|
|
class ConCommand;
|
|
class ConCommandBase;
|
|
struct characterset_t;
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Any executable that wants to use ConVars need to implement one of
|
|
// these to hook up access to console variables.
|
|
//-----------------------------------------------------------------------------
|
|
class IConCommandBaseAccessor
|
|
{
|
|
public:
|
|
// Flags is a combination of FCVAR flags in cvar.h.
|
|
// hOut is filled in with a handle to the variable.
|
|
virtual bool RegisterConCommandBase( ConCommandBase *pVar ) = 0;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper method for console development
|
|
//-----------------------------------------------------------------------------
|
|
#if defined( _X360 ) && !defined( _RETAIL )
|
|
void ConVar_PublishToVXConsole();
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when a ConCommand needs to execute
|
|
//-----------------------------------------------------------------------------
|
|
typedef void ( *FnCommandCallbackV1_t )( void );
|
|
typedef void ( *FnCommandCallback_t )( const CCommand &command );
|
|
|
|
#define COMMAND_COMPLETION_MAXITEMS 64
|
|
#define COMMAND_COMPLETION_ITEM_LENGTH 64
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns 0 to COMMAND_COMPLETION_MAXITEMS worth of completion strings
|
|
//-----------------------------------------------------------------------------
|
|
typedef int ( *FnCommandCompletionCallback )( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Interface version
|
|
//-----------------------------------------------------------------------------
|
|
class ICommandCallback
|
|
{
|
|
public:
|
|
virtual void CommandCallback( const CCommand &command ) = 0;
|
|
};
|
|
|
|
class ICommandCompletionCallback
|
|
{
|
|
public:
|
|
virtual int CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) = 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: The base console invoked command/cvar interface
|
|
//-----------------------------------------------------------------------------
|
|
class ConCommandBase
|
|
{
|
|
friend class CCvar;
|
|
friend class ConVar;
|
|
friend class ConCommand;
|
|
friend void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor );
|
|
friend void ConVar_PublishToVXConsole();
|
|
|
|
// FIXME: Remove when ConVar changes are done
|
|
friend class CDefaultCvar;
|
|
|
|
public:
|
|
ConCommandBase( void );
|
|
ConCommandBase( const char *pName, const char *pHelpString = 0,
|
|
int flags = 0 );
|
|
|
|
virtual ~ConCommandBase( void );
|
|
|
|
virtual bool IsCommand( void ) const;
|
|
|
|
// Check flag
|
|
virtual bool IsFlagSet( int flag ) const;
|
|
// Set flag
|
|
virtual void AddFlags( int flags );
|
|
|
|
// Return name of cvar
|
|
virtual const char *GetName( void ) const;
|
|
|
|
// Return help text for cvar
|
|
virtual const char *GetHelpText( void ) const;
|
|
|
|
// Deal with next pointer
|
|
const ConCommandBase *GetNext( void ) const;
|
|
ConCommandBase *GetNext( void );
|
|
|
|
void SetNext(ConCommandBase *pBase)
|
|
{
|
|
m_pNext = pBase;
|
|
}
|
|
|
|
virtual bool IsRegistered( void ) const;
|
|
|
|
// Returns the DLL identifier
|
|
virtual CVarDLLIdentifier_t GetDLLIdentifier() const;
|
|
|
|
protected:
|
|
virtual void Create( const char *pName, const char *pHelpString = 0,
|
|
int flags = 0 );
|
|
|
|
// Used internally by OneTimeInit to initialize/shutdown
|
|
virtual void Init();
|
|
void Shutdown();
|
|
|
|
// Internal copy routine ( uses new operator from correct module )
|
|
char *CopyString( const char *from );
|
|
|
|
private:
|
|
// Next ConVar in chain
|
|
// Prior to register, it points to the next convar in the DLL.
|
|
// Once registered, though, m_pNext is reset to point to the next
|
|
// convar in the global list
|
|
ConCommandBase *m_pNext;
|
|
|
|
// Has the cvar been added to the global list?
|
|
bool m_bRegistered;
|
|
|
|
// Static data
|
|
const char *m_pszName;
|
|
const char *m_pszHelpString;
|
|
|
|
// ConVar flags
|
|
int m_nFlags;
|
|
|
|
protected:
|
|
// ConVars add themselves to this list for the executable.
|
|
// Then ConVar_Register runs through all the console variables
|
|
// and registers them into a global list stored in vstdlib.dll
|
|
static ConCommandBase *s_pConCommandBases;
|
|
|
|
// ConVars in this executable use this 'global' to access values.
|
|
static IConCommandBaseAccessor *s_pAccessor;
|
|
public: // Hackalicous
|
|
inline int GetFlags() const
|
|
{
|
|
return m_nFlags;
|
|
}
|
|
inline void SetFlags(int flags)
|
|
{
|
|
m_nFlags = flags;
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Command tokenizer
|
|
//-----------------------------------------------------------------------------
|
|
class CCommand
|
|
{
|
|
public:
|
|
CCommand();
|
|
CCommand( int nArgC, const char **ppArgV );
|
|
bool Tokenize( const char *pCommand, characterset_t *pBreakSet = NULL );
|
|
void Reset();
|
|
|
|
int ArgC() const;
|
|
const char **ArgV() const;
|
|
const char *ArgS() const; // All args that occur after the 0th arg, in string form
|
|
const char *GetCommandString() const; // The entire command in string form, including the 0th arg
|
|
const char *operator[]( int nIndex ) const; // Gets at arguments
|
|
const char *Arg( int nIndex ) const; // Gets at arguments
|
|
|
|
// Helper functions to parse arguments to commands.
|
|
const char* FindArg( const char *pName ) const;
|
|
int FindArgInt( const char *pName, int nDefaultVal ) const;
|
|
|
|
static int MaxCommandLength();
|
|
static characterset_t* DefaultBreakSet();
|
|
|
|
private:
|
|
enum
|
|
{
|
|
COMMAND_MAX_ARGC = 64,
|
|
COMMAND_MAX_LENGTH = 512,
|
|
};
|
|
|
|
int m_nArgc;
|
|
int m_nArgv0Size;
|
|
char m_pArgSBuffer[ COMMAND_MAX_LENGTH ];
|
|
char m_pArgvBuffer[ COMMAND_MAX_LENGTH ];
|
|
const char* m_ppArgv[ COMMAND_MAX_ARGC ];
|
|
};
|
|
|
|
inline int CCommand::MaxCommandLength()
|
|
{
|
|
return COMMAND_MAX_LENGTH - 1;
|
|
}
|
|
|
|
inline int CCommand::ArgC() const
|
|
{
|
|
return m_nArgc;
|
|
}
|
|
|
|
inline const char **CCommand::ArgV() const
|
|
{
|
|
return m_nArgc ? (const char**)m_ppArgv : NULL;
|
|
}
|
|
|
|
inline const char *CCommand::ArgS() const
|
|
{
|
|
return m_nArgv0Size ? &m_pArgSBuffer[m_nArgv0Size] : "";
|
|
}
|
|
|
|
inline const char *CCommand::GetCommandString() const
|
|
{
|
|
return m_nArgc ? m_pArgSBuffer : "";
|
|
}
|
|
|
|
inline const char *CCommand::Arg( int nIndex ) const
|
|
{
|
|
// FIXME: Many command handlers appear to not be particularly careful
|
|
// about checking for valid argc range. For now, we're going to
|
|
// do the extra check and return an empty string if it's out of range
|
|
if ( nIndex < 0 || nIndex >= m_nArgc )
|
|
return "";
|
|
return m_ppArgv[nIndex];
|
|
}
|
|
|
|
inline const char *CCommand::operator[]( int nIndex ) const
|
|
{
|
|
return Arg( nIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: The console invoked command
|
|
//-----------------------------------------------------------------------------
|
|
class ConCommand : public ConCommandBase
|
|
{
|
|
friend class CCvar;
|
|
|
|
public:
|
|
typedef ConCommandBase BaseClass;
|
|
|
|
ConCommand( const char *pName, FnCommandCallbackV1_t callback,
|
|
const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );
|
|
ConCommand( const char *pName, FnCommandCallback_t callback,
|
|
const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );
|
|
ConCommand( const char *pName, ICommandCallback *pCallback,
|
|
const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );
|
|
|
|
virtual ~ConCommand( void );
|
|
|
|
virtual bool IsCommand( void ) const;
|
|
|
|
virtual int AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands );
|
|
|
|
virtual bool CanAutoComplete( void );
|
|
|
|
// Invoke the function
|
|
virtual void Dispatch( const CCommand &command );
|
|
|
|
private:
|
|
// NOTE: To maintain backward compat, we have to be very careful:
|
|
// All public virtual methods must appear in the same order always
|
|
// since engine code will be calling into this code, which *does not match*
|
|
// in the mod code; it's using slightly different, but compatible versions
|
|
// of this class. Also: Be very careful about adding new fields to this class.
|
|
// Those fields will not exist in the version of this class that is instanced
|
|
// in mod code.
|
|
|
|
// Call this function when executing the command
|
|
union
|
|
{
|
|
FnCommandCallbackV1_t m_fnCommandCallbackV1;
|
|
FnCommandCallback_t m_fnCommandCallback;
|
|
ICommandCallback *m_pCommandCallback;
|
|
};
|
|
|
|
union
|
|
{
|
|
FnCommandCompletionCallback m_fnCompletionCallback;
|
|
ICommandCompletionCallback *m_pCommandCompletionCallback;
|
|
};
|
|
|
|
bool m_bHasCompletionCallback : 1;
|
|
bool m_bUsingNewCommandCallback : 1;
|
|
bool m_bUsingCommandCallbackInterface : 1;
|
|
public: // Hackalicous
|
|
inline FnCommandCallback_t GetCallback() const
|
|
{
|
|
return m_fnCommandCallback;
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A console variable
|
|
//-----------------------------------------------------------------------------
|
|
class ConVar : public ConCommandBase, public IConVar
|
|
{
|
|
friend class CCvar;
|
|
friend class ConVarRef;
|
|
|
|
public:
|
|
typedef ConCommandBase BaseClass;
|
|
|
|
ConVar( const char *pName, const char *pDefaultValue, int flags = 0);
|
|
|
|
ConVar( const char *pName, const char *pDefaultValue, int flags,
|
|
const char *pHelpString );
|
|
ConVar( const char *pName, const char *pDefaultValue, int flags,
|
|
const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax );
|
|
ConVar( const char *pName, const char *pDefaultValue, int flags,
|
|
const char *pHelpString, FnChangeCallback_t callback );
|
|
ConVar( const char *pName, const char *pDefaultValue, int flags,
|
|
const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax,
|
|
FnChangeCallback_t callback );
|
|
|
|
virtual ~ConVar( void );
|
|
|
|
virtual bool IsFlagSet( int flag ) const;
|
|
virtual const char* GetHelpText( void ) const;
|
|
virtual bool IsRegistered( void ) const;
|
|
virtual const char *GetName( void ) const;
|
|
virtual void AddFlags( int flags );
|
|
virtual bool IsCommand( void ) const;
|
|
|
|
// Install a change callback (there shouldn't already be one....)
|
|
void InstallChangeCallback( FnChangeCallback_t callback );
|
|
|
|
// Retrieve value
|
|
FORCEINLINE_CVAR float GetFloat( void ) const;
|
|
FORCEINLINE_CVAR int GetInt( void ) const;
|
|
FORCEINLINE_CVAR bool GetBool() const { return !!GetInt(); }
|
|
FORCEINLINE_CVAR char const *GetString( void ) const;
|
|
|
|
// Any function that allocates/frees memory needs to be virtual or else you'll have crashes
|
|
// from alloc/free across dll/exe boundaries.
|
|
|
|
// These just call into the IConCommandBaseAccessor to check flags and set the var (which ends up calling InternalSetValue).
|
|
virtual void SetValue( const char *value );
|
|
virtual void SetValue( float value );
|
|
virtual void SetValue( int value );
|
|
|
|
// Reset to default value
|
|
void Revert( void );
|
|
|
|
// True if it has a min/max setting
|
|
bool GetMin( float& minVal ) const;
|
|
bool GetMax( float& maxVal ) const;
|
|
const char *GetDefault( void ) const;
|
|
|
|
private:
|
|
// Called by CCvar when the value of a var is changing.
|
|
virtual void InternalSetValue(const char *value);
|
|
// For CVARs marked FCVAR_NEVER_AS_STRING
|
|
virtual void InternalSetFloatValue( float fNewValue );
|
|
virtual void InternalSetIntValue( int nValue );
|
|
|
|
virtual bool ClampValue( float& value );
|
|
virtual void ChangeStringValue( const char *tempVal, float flOldValue );
|
|
|
|
virtual void Create( const char *pName, const char *pDefaultValue, int flags = 0,
|
|
const char *pHelpString = 0, bool bMin = false, float fMin = 0.0,
|
|
bool bMax = false, float fMax = false, FnChangeCallback_t callback = 0 );
|
|
|
|
// Used internally by OneTimeInit to initialize.
|
|
virtual void Init();
|
|
|
|
private:
|
|
|
|
// This either points to "this" or it points to the original declaration of a ConVar.
|
|
// This allows ConVars to exist in separate modules, and they all use the first one to be declared.
|
|
// m_pParent->m_pParent must equal m_pParent (ie: m_pParent must be the root, or original, ConVar).
|
|
ConVar *m_pParent;
|
|
|
|
// Static data
|
|
const char *m_pszDefaultValue;
|
|
|
|
// Value
|
|
// Dynamically allocated
|
|
char *m_pszString;
|
|
int m_StringLength;
|
|
|
|
// Values
|
|
float m_fValue;
|
|
int m_nValue;
|
|
|
|
// Min/Max values
|
|
bool m_bHasMin;
|
|
float m_fMinVal;
|
|
bool m_bHasMax;
|
|
float m_fMaxVal;
|
|
|
|
// Call this function when ConVar changes
|
|
FnChangeCallback_t m_fnChangeCallback;
|
|
public: // Hackalicous
|
|
inline FnChangeCallback_t GetCallback() const
|
|
{
|
|
return m_fnChangeCallback;
|
|
}
|
|
inline void SetMin(bool set, float min=0.0)
|
|
{
|
|
m_bHasMin = set;
|
|
m_fMinVal = min;
|
|
}
|
|
inline void SetMax(bool set, float max=0.0)
|
|
{
|
|
m_bHasMax = set;
|
|
m_fMaxVal = max;
|
|
}
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as a float
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR float ConVar::GetFloat( void ) const
|
|
{
|
|
return m_pParent->m_fValue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as an int
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR int ConVar::GetInt( void ) const
|
|
{
|
|
return m_pParent->m_nValue;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.
|
|
// Output : const char *
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR const char *ConVar::GetString( void ) const
|
|
{
|
|
if ( m_nFlags & FCVAR_NEVER_AS_STRING )
|
|
return "FCVAR_NEVER_AS_STRING";
|
|
|
|
return ( m_pParent->m_pszString ) ? m_pParent->m_pszString : "";
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to read/write convars that already exist (replaces the FindVar method)
|
|
//-----------------------------------------------------------------------------
|
|
class ConVarRef
|
|
{
|
|
public:
|
|
ConVarRef( const char *pName );
|
|
ConVarRef( const char *pName, bool bIgnoreMissing );
|
|
ConVarRef( IConVar *pConVar );
|
|
|
|
void Init( const char *pName, bool bIgnoreMissing );
|
|
bool IsValid() const;
|
|
bool IsFlagSet( int nFlags ) const;
|
|
IConVar *GetLinkedConVar();
|
|
|
|
// Get/Set value
|
|
float GetFloat( void ) const;
|
|
int GetInt( void ) const;
|
|
bool GetBool() const { return !!GetInt(); }
|
|
const char *GetString( void ) const;
|
|
|
|
void SetValue( const char *pValue );
|
|
void SetValue( float flValue );
|
|
void SetValue( int nValue );
|
|
void SetValue( bool bValue );
|
|
|
|
const char *GetName() const;
|
|
|
|
const char *GetDefault() const;
|
|
|
|
private:
|
|
// High-speed method to read convar data
|
|
IConVar *m_pConVar;
|
|
ConVar *m_pConVarState;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Did we find an existing convar of that name?
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR bool ConVarRef::IsFlagSet( int nFlags ) const
|
|
{
|
|
return ( m_pConVar->IsFlagSet( nFlags ) != 0 );
|
|
}
|
|
|
|
FORCEINLINE_CVAR IConVar *ConVarRef::GetLinkedConVar()
|
|
{
|
|
return m_pConVar;
|
|
}
|
|
|
|
FORCEINLINE_CVAR const char *ConVarRef::GetName() const
|
|
{
|
|
return m_pConVar->GetName();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as a float
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR float ConVarRef::GetFloat( void ) const
|
|
{
|
|
return m_pConVarState->m_fValue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as an int
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR int ConVarRef::GetInt( void ) const
|
|
{
|
|
return m_pConVarState->m_nValue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.
|
|
//-----------------------------------------------------------------------------
|
|
FORCEINLINE_CVAR const char *ConVarRef::GetString( void ) const
|
|
{
|
|
Assert( !IsFlagSet( FCVAR_NEVER_AS_STRING ) );
|
|
return m_pConVarState->m_pszString;
|
|
}
|
|
|
|
|
|
FORCEINLINE_CVAR void ConVarRef::SetValue( const char *pValue )
|
|
{
|
|
m_pConVar->SetValue( pValue );
|
|
}
|
|
|
|
FORCEINLINE_CVAR void ConVarRef::SetValue( float flValue )
|
|
{
|
|
m_pConVar->SetValue( flValue );
|
|
}
|
|
|
|
FORCEINLINE_CVAR void ConVarRef::SetValue( int nValue )
|
|
{
|
|
m_pConVar->SetValue( nValue );
|
|
}
|
|
|
|
FORCEINLINE_CVAR void ConVarRef::SetValue( bool bValue )
|
|
{
|
|
m_pConVar->SetValue( bValue ? 1 : 0 );
|
|
}
|
|
|
|
FORCEINLINE_CVAR const char *ConVarRef::GetDefault() const
|
|
{
|
|
return m_pConVarState->m_pszDefaultValue;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the framework to register ConCommands with the ICVar
|
|
//-----------------------------------------------------------------------------
|
|
void ConVar_Register( int nCVarFlag = 0, IConCommandBaseAccessor *pAccessor = NULL );
|
|
void ConVar_Unregister( );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Utility methods
|
|
//-----------------------------------------------------------------------------
|
|
void ConVar_PrintFlags( const ConCommandBase *var );
|
|
void ConVar_PrintDescription( const ConCommandBase *pVar );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Utility class to quickly allow ConCommands to call member methods
|
|
//-----------------------------------------------------------------------------
|
|
#if defined _MSC_VER
|
|
#pragma warning (disable : 4355 )
|
|
#endif
|
|
|
|
template< class T >
|
|
class CConCommandMemberAccessor : public ConCommand, public ICommandCallback, public ICommandCompletionCallback
|
|
{
|
|
typedef ConCommand BaseClass;
|
|
typedef void ( T::*FnMemberCommandCallback_t )( const CCommand &command );
|
|
typedef int ( T::*FnMemberCommandCompletionCallback_t )( const char *pPartial, CUtlVector< CUtlString > &commands );
|
|
|
|
public:
|
|
CConCommandMemberAccessor( T* pOwner, const char *pName, FnMemberCommandCallback_t callback, const char *pHelpString = 0,
|
|
int flags = 0, FnMemberCommandCompletionCallback_t completionFunc = 0 ) :
|
|
BaseClass( pName, this, pHelpString, flags, ( completionFunc != 0 ) ? this : NULL )
|
|
{
|
|
m_pOwner = pOwner;
|
|
m_Func = callback;
|
|
m_CompletionFunc = completionFunc;
|
|
}
|
|
|
|
~CConCommandMemberAccessor()
|
|
{
|
|
Shutdown();
|
|
}
|
|
|
|
void SetOwner( T* pOwner )
|
|
{
|
|
m_pOwner = pOwner;
|
|
}
|
|
|
|
virtual void CommandCallback( const CCommand &command )
|
|
{
|
|
Assert( m_pOwner && m_Func );
|
|
(m_pOwner->*m_Func)( command );
|
|
}
|
|
|
|
virtual int CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands )
|
|
{
|
|
Assert( m_pOwner && m_CompletionFunc );
|
|
return (m_pOwner->*m_CompletionFunc)( pPartial, commands );
|
|
}
|
|
|
|
private:
|
|
T* m_pOwner;
|
|
FnMemberCommandCallback_t m_Func;
|
|
FnMemberCommandCompletionCallback_t m_CompletionFunc;
|
|
};
|
|
|
|
#if defined _MSC_VER
|
|
#pragma warning ( default : 4355 )
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Utility macros to quicky generate a simple console command
|
|
//-----------------------------------------------------------------------------
|
|
#define CON_COMMAND( name, description ) \
|
|
static void name( const CCommand &args ); \
|
|
static ConCommand name##_command( #name, name, description ); \
|
|
static void name( const CCommand &args )
|
|
|
|
#define CON_COMMAND_F( name, description, flags ) \
|
|
static void name( const CCommand &args ); \
|
|
static ConCommand name##_command( #name, name, description, flags ); \
|
|
static void name( const CCommand &args )
|
|
|
|
#define CON_COMMAND_F_COMPLETION( name, description, flags, completion ) \
|
|
static void name( const CCommand &args ); \
|
|
static ConCommand name##_command( #name, name, description, flags, completion ); \
|
|
static void name( const CCommand &args )
|
|
|
|
#define CON_COMMAND_EXTERN( name, _funcname, description ) \
|
|
void _funcname( const CCommand &args ); \
|
|
static ConCommand name##_command( #name, _funcname, description ); \
|
|
void _funcname( const CCommand &args )
|
|
|
|
#define CON_COMMAND_EXTERN_F( name, _funcname, description, flags ) \
|
|
void _funcname( const CCommand &args ); \
|
|
static ConCommand name##_command( #name, _funcname, description, flags ); \
|
|
void _funcname( const CCommand &args )
|
|
|
|
#define CON_COMMAND_MEMBER_F( _thisclass, name, _funcname, description, flags ) \
|
|
void _funcname( const CCommand &args ); \
|
|
friend class CCommandMemberInitializer_##_funcname; \
|
|
class CCommandMemberInitializer_##_funcname \
|
|
{ \
|
|
public: \
|
|
CCommandMemberInitializer_##_funcname() : m_ConCommandAccessor( NULL, name, &_thisclass::_funcname, description, flags ) \
|
|
{ \
|
|
m_ConCommandAccessor.SetOwner( GET_OUTER( _thisclass, m_##_funcname##_register ) ); \
|
|
} \
|
|
private: \
|
|
CConCommandMemberAccessor< _thisclass > m_ConCommandAccessor; \
|
|
}; \
|
|
\
|
|
CCommandMemberInitializer_##_funcname m_##_funcname##_register; \
|
|
|
|
|
|
#endif // CONVAR_H
|