sourcemm/convar.cpp
author David Anderson <dvander@alliedmods.net>
Wed Aug 09 02:05:57 2006 +0000 (2006-08-09)
changeset 232 a86d52ff721c
parent 7 8ef11f6189e4
permissions -rw-r--r--
Merged in changes from the latest SDK
dvander@7
     1
//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
dvander@7
     2
//
dvander@7
     3
// Purpose: 
dvander@7
     4
//
dvander@7
     5
// $NoKeywords: $
dvander@7
     6
//
dvander@7
     7
//=============================================================================//
dvander@7
     8
dvander@232
     9
#ifdef _XBOX
dvander@232
    10
#include "xbox/xbox_platform.h"
dvander@232
    11
#include "xbox/xbox_win32stubs.h"
dvander@232
    12
#include "xbox/xbox_core.h"
dvander@232
    13
#endif
dvander@7
    14
#include <stdio.h>
dvander@7
    15
#include <stdlib.h>
dvander@7
    16
#include <string.h>
dvander@7
    17
#include "basetypes.h"
dvander@7
    18
#include "convar.h"
dvander@7
    19
#include "vstdlib/strtools.h"
dvander@232
    20
#include "icvar.h"
dvander@7
    21
#include "tier0/dbg.h"
dvander@232
    22
#ifdef _XBOX
dvander@232
    23
#include "vstdlib/ICommandLine.h"
dvander@232
    24
#endif
dvander@7
    25
#include "tier0/memdbgon.h"
dvander@7
    26
dvander@7
    27
ConCommandBase			*ConCommandBase::s_pConCommandBases = NULL;
dvander@7
    28
IConCommandBaseAccessor	*ConCommandBase::s_pAccessor = NULL;
dvander@7
    29
dvander@232
    30
#ifdef _XBOX
dvander@232
    31
static char const* GetCommandLineValue( char const *pVariableName )
dvander@232
    32
{
dvander@232
    33
	int nLen = Q_strlen(pVariableName);
dvander@232
    34
	char *pSearch = (char*)stackalloc(nLen + 2);
dvander@232
    35
	pSearch[0] = '+';
dvander@232
    36
	memcpy(&pSearch[1], pVariableName, nLen + 1);
dvander@232
    37
	return CommandLine()->ParmValue(pSearch);
dvander@232
    38
}
dvander@232
    39
#endif
dvander@232
    40
dvander@232
    41
#if defined( _XBOX ) && !defined( _RETAIL )
dvander@232
    42
void ConCommandBaseMgr::PublishCommands( bool bForce )
dvander@232
    43
{
dvander@232
    44
	ConCommandBase	*pCur;
dvander@232
    45
	const char		*commands[2048];
dvander@232
    46
	const char		*helptext[2048];
dvander@232
    47
	int				numCommands = 0;
dvander@232
    48
dvander@232
    49
	if ( bForce )
dvander@232
    50
	{
dvander@232
    51
		for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
dvander@232
    52
		{
dvander@232
    53
			pCur->m_bRegistered = false;
dvander@232
    54
		}
dvander@232
    55
	}
dvander@232
    56
dvander@232
    57
	// iterate and publish commands to the remote console
dvander@232
    58
	for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
dvander@232
    59
	{
dvander@232
    60
		if ( !pCur->m_bRegistered )
dvander@232
    61
		{
dvander@232
    62
			// add unregistered commands to list
dvander@232
    63
			if ( numCommands < sizeof(commands)/sizeof(commands[0]) )
dvander@232
    64
			{
dvander@232
    65
				commands[numCommands] = pCur->m_pszName;
dvander@232
    66
				helptext[numCommands] = pCur->m_pszHelpString;
dvander@232
    67
				numCommands++;
dvander@232
    68
			}
dvander@232
    69
dvander@232
    70
			// mark as registered
dvander@232
    71
			pCur->m_bRegistered = true;
dvander@232
    72
		}
dvander@232
    73
	}
dvander@232
    74
	if ( numCommands )
dvander@232
    75
	{
dvander@232
    76
		XBX_rAddCommands( numCommands, commands, helptext );
dvander@232
    77
	}
dvander@232
    78
}
dvander@232
    79
#endif
dvander@232
    80
dvander@232
    81
#ifdef _XBOX
dvander@232
    82
bool ConCommandBaseMgr::Fixup(ConCommandBase* pConCommand)
dvander@232
    83
{
dvander@232
    84
	ConCommandBase	*pCur;
dvander@232
    85
	ConCommandBase	*pPrev2;
dvander@232
    86
	ConCommandBase	*pCur2;
dvander@232
    87
	ConCommandBase	*pNext2;
dvander@232
    88
	const char		*name;
dvander@232
    89
	static int		initCount = 0;
dvander@232
    90
dvander@232
    91
	// xboxissue - cvars and its class hierarchy could not be made to instance per subsystem
dvander@232
    92
	// without massive mangling and re-arranging, instead...
dvander@232
    93
	// there is only a single chain and therefore single /init/fixup
dvander@232
    94
	// missing: need to identify which subsystem
dvander@232
    95
	// could pass as part of declaration in constructor, but how to hide parameter for pc
dvander@232
    96
	// the accessors (aka callbacks to subsystems) to register with engine 
dvander@232
    97
	// cannot be invoked as their unlink logic expect private lists
dvander@232
    98
	// so this just mimics the expected end result
dvander@232
    99
	// must handle early and late constructors
dvander@232
   100
	// late constructors are usually function scoped static
dvander@232
   101
	if (!pConCommand)
dvander@232
   102
	{
dvander@232
   103
		// the caller is one-time-init 
dvander@232
   104
		if (++initCount > 1)
dvander@232
   105
		{
dvander@232
   106
			// the list has already been fixed
dvander@232
   107
			return true;
dvander@232
   108
		}
dvander@232
   109
	}
dvander@232
   110
	else
dvander@232
   111
	{
dvander@232
   112
		// the caller is a console command constructor
dvander@232
   113
		if (!initCount)
dvander@232
   114
		{
dvander@232
   115
			// the list has not been fixed yet 
dvander@232
   116
			// no special behavior
dvander@232
   117
			return false;
dvander@232
   118
		}
dvander@232
   119
		else
dvander@232
   120
		{
dvander@232
   121
			// the list has already been fixed
dvander@232
   122
			// the console command is a late constructor
dvander@232
   123
			// add in to fixed list 
dvander@232
   124
			bool hasParent = false;
dvander@232
   125
			if (!pConCommand->IsCommand())
dvander@232
   126
			{
dvander@232
   127
				pCur  = ConCommandBase::s_pConCommandBases;
dvander@232
   128
				while (pCur)
dvander@232
   129
				{
dvander@232
   130
					if (pCur->IsCommand() && !stricmp(pCur->m_pszName, pConCommand->m_pszName))
dvander@232
   131
					{
dvander@232
   132
						// set its parent
dvander@232
   133
						((ConVar*)pConCommand)->m_pParent = ((ConVar*)pCur)->m_pParent;
dvander@232
   134
						hasParent = true;
dvander@232
   135
						break;
dvander@232
   136
					}
dvander@232
   137
					pCur = pCur->m_pNext;
dvander@232
   138
				}
dvander@232
   139
			}
dvander@232
   140
			if (!hasParent)
dvander@232
   141
			{
dvander@232
   142
				// add to head of list
dvander@232
   143
				pConCommand->m_pNext = ConCommandBase::s_pConCommandBases;
dvander@232
   144
				ConCommandBase::s_pConCommandBases = pConCommand;
dvander@232
   145
			}
dvander@232
   146
			else
dvander@232
   147
				return true;
dvander@232
   148
		}
dvander@232
   149
	}
dvander@232
   150
dvander@232
   151
	if (initCount == 1)
dvander@232
   152
	{
dvander@232
   153
		// iterate the cvars and set their possible proxy parents
dvander@232
   154
		// skip over registered (fixed) entries
dvander@232
   155
		pCur = ConCommandBase::s_pConCommandBases;
dvander@232
   156
		while (pCur)
dvander@232
   157
		{
dvander@232
   158
			if (!pCur->IsCommand() && !pCur->m_bRegistered)
dvander@232
   159
			{
dvander@232
   160
				// iterate from the next node until end of list
dvander@232
   161
				name   = pCur->m_pszName; 
dvander@232
   162
				pPrev2 = pCur;		
dvander@232
   163
				pCur2  = pCur->m_pNext;
dvander@232
   164
				while (pCur2)
dvander@232
   165
				{
dvander@232
   166
					pNext2 = pCur2->m_pNext;
dvander@232
   167
					if (!pCur2->IsCommand() && !stricmp(pCur2->m_pszName, name))
dvander@232
   168
					{
dvander@232
   169
						// found duplicate
dvander@232
   170
						// unlink and fixup
dvander@232
   171
						pCur2->m_pNext  = NULL;
dvander@232
   172
						pPrev2->m_pNext = pNext2;
dvander@232
   173
dvander@232
   174
						// set its parent
dvander@232
   175
						((ConVar*)pCur2)->m_pParent = ((ConVar*)pCur)->m_pParent;
dvander@232
   176
					}
dvander@232
   177
					else
dvander@232
   178
					{
dvander@232
   179
						// no unlink, advance to next node
dvander@232
   180
						pPrev2 = pCur2;
dvander@232
   181
					}
dvander@232
   182
dvander@232
   183
					pCur2 = pNext2;
dvander@232
   184
				}
dvander@232
   185
dvander@232
   186
				char const *pValue = GetCommandLineValue(name);
dvander@232
   187
				if (pValue)
dvander@232
   188
					((ConVar*)pCur)->SetValue(pValue);
dvander@232
   189
			}
dvander@232
   190
			pCur = pCur->m_pNext;
dvander@232
   191
		}
dvander@232
   192
	}
dvander@232
   193
dvander@232
   194
#if !defined( _RETAIL )
dvander@232
   195
	XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Start" );
dvander@232
   196
dvander@232
   197
	PublishCommands( false );
dvander@232
   198
dvander@232
   199
	XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Done" );
dvander@232
   200
#endif
dvander@232
   201
dvander@232
   202
	// fixup has been performed
dvander@232
   203
	return true;
dvander@232
   204
}
dvander@232
   205
#endif
dvander@232
   206
dvander@7
   207
// ----------------------------------------------------------------------------- //
dvander@7
   208
// ConCommandBaseMgr.
dvander@7
   209
// ----------------------------------------------------------------------------- //
dvander@7
   210
void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
dvander@7
   211
{
dvander@232
   212
#ifdef _XBOX
dvander@232
   213
	// fixup the list
dvander@232
   214
	ConCommandBaseMgr::Fixup(NULL);
dvander@232
   215
#else
dvander@7
   216
	ConCommandBase *pCur, *pNext;
dvander@7
   217
dvander@7
   218
	ConCommandBase::s_pAccessor = pAccessor;
dvander@7
   219
	pCur = ConCommandBase::s_pConCommandBases;
dvander@7
   220
	while ( pCur )
dvander@7
   221
	{
dvander@7
   222
		pNext = pCur->m_pNext;
dvander@7
   223
		pCur->Init();
dvander@7
   224
		pCur = pNext;
dvander@7
   225
	}
dvander@232
   226
#endif
dvander@7
   227
}
dvander@7
   228
dvander@7
   229
//-----------------------------------------------------------------------------
dvander@7
   230
// Purpose: Default constructor
dvander@7
   231
//-----------------------------------------------------------------------------
dvander@7
   232
ConCommandBase::ConCommandBase( void )
dvander@7
   233
{
dvander@232
   234
	m_bRegistered   = false;
dvander@232
   235
	m_pszName       = NULL;
dvander@232
   236
	m_pszHelpString = NULL;
dvander@7
   237
dvander@232
   238
	m_nFlags = 0;
dvander@232
   239
	m_pNext  = NULL;
dvander@7
   240
}
dvander@7
   241
dvander@7
   242
//-----------------------------------------------------------------------------
dvander@7
   243
// Purpose: The base console invoked command/cvar interface
dvander@7
   244
// Input  : *pName - name of variable/command
dvander@7
   245
//			*pHelpString - help text
dvander@7
   246
//			flags - flags
dvander@7
   247
//-----------------------------------------------------------------------------
dvander@7
   248
ConCommandBase::ConCommandBase( char const *pName, char const *pHelpString /*=0*/, int flags /*= 0*/ )
dvander@7
   249
{
dvander@7
   250
	Create( pName, pHelpString, flags );
dvander@7
   251
}
dvander@7
   252
dvander@7
   253
//-----------------------------------------------------------------------------
dvander@7
   254
// Purpose: 
dvander@7
   255
//-----------------------------------------------------------------------------
dvander@7
   256
ConCommandBase::~ConCommandBase( void )
dvander@7
   257
{
dvander@7
   258
}
dvander@7
   259
dvander@7
   260
//-----------------------------------------------------------------------------
dvander@7
   261
// Purpose: 
dvander@7
   262
// Output : Returns true on success, false on failure.
dvander@7
   263
//-----------------------------------------------------------------------------
dvander@7
   264
bool ConCommandBase::IsCommand( void ) const
dvander@7
   265
{ 
dvander@7
   266
//	Assert( 0 ); This can't assert. . causes a recursive assert in Sys_Printf, etc.
dvander@7
   267
	return true;
dvander@7
   268
}
dvander@7
   269
	
dvander@7
   270
//-----------------------------------------------------------------------------
dvander@7
   271
// Purpose: 
dvander@7
   272
// Input  : *pName - 
dvander@7
   273
//			callback - 
dvander@7
   274
//			*pHelpString - 
dvander@7
   275
//			flags - 
dvander@7
   276
//-----------------------------------------------------------------------------
dvander@7
   277
void ConCommandBase::Create( char const *pName, char const *pHelpString /*= 0*/, int flags /*= 0*/ )
dvander@7
   278
{
dvander@7
   279
	static char *empty_string = "";
dvander@7
   280
dvander@232
   281
	m_bRegistered = false;
dvander@7
   282
dvander@7
   283
	// Name should be static data
dvander@7
   284
	Assert( pName );
dvander@232
   285
	m_pszName = pName;
dvander@232
   286
	m_pszHelpString = pHelpString ? pHelpString : empty_string;
dvander@7
   287
dvander@7
   288
	m_nFlags = flags;
dvander@7
   289
dvander@232
   290
#ifdef _XBOX
dvander@232
   291
	if (ConCommandBaseMgr::Fixup(this))
dvander@232
   292
		return;
dvander@232
   293
#endif
dvander@232
   294
dvander@7
   295
	if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
dvander@7
   296
	{
dvander@232
   297
#ifndef _XBOX
dvander@232
   298
		m_pNext = s_pConCommandBases;
dvander@232
   299
		s_pConCommandBases = this;
dvander@232
   300
#else
dvander@232
   301
		// xboxissue - engine cvars should be at head of list to
dvander@232
   302
		// ensure they are set as the cvar master/parent during fixup
dvander@232
   303
		if (!s_pConCommandBases || !(flags & FCVAR_NON_ENGINE))
dvander@232
   304
		{
dvander@232
   305
			// engine cvars, place at head of list
dvander@232
   306
			m_pNext = s_pConCommandBases;
dvander@232
   307
			s_pConCommandBases = this;
dvander@232
   308
		}
dvander@232
   309
		else
dvander@232
   310
		{
dvander@232
   311
			// non-engine cvars, place at end of list
dvander@232
   312
			ConCommandBase *cur = s_pConCommandBases;
dvander@232
   313
			while (1)
dvander@232
   314
			{
dvander@232
   315
				if (!cur->m_pNext)
dvander@232
   316
				{
dvander@232
   317
					cur->m_pNext = this;
dvander@232
   318
					m_pNext      = NULL;
dvander@232
   319
					break;
dvander@232
   320
				}
dvander@232
   321
				cur = cur->m_pNext;
dvander@232
   322
			}
dvander@232
   323
		}
dvander@232
   324
#endif
dvander@7
   325
	}
dvander@7
   326
	else
dvander@7
   327
	{
dvander@7
   328
		// It's unregistered
dvander@232
   329
		m_pNext = NULL;
dvander@7
   330
	}
dvander@7
   331
dvander@7
   332
	// If s_pAccessor is already set (this ConVar is not a global variable),
dvander@7
   333
	//  register it.
dvander@7
   334
	if ( s_pAccessor )
dvander@7
   335
	{
dvander@7
   336
		Init();
dvander@7
   337
	}
dvander@7
   338
}
dvander@7
   339
dvander@7
   340
//-----------------------------------------------------------------------------
dvander@7
   341
// Purpose: Used internally by OneTimeInit to initialize.
dvander@7
   342
//-----------------------------------------------------------------------------
dvander@7
   343
void ConCommandBase::Init()
dvander@7
   344
{
dvander@7
   345
	if ( !s_pAccessor )
dvander@7
   346
		return;
dvander@7
   347
	
dvander@7
   348
	if ( m_bRegistered )
dvander@7
   349
		return;
dvander@7
   350
dvander@7
   351
	s_pAccessor->RegisterConCommandBase( this );
dvander@7
   352
dvander@7
   353
	m_bRegistered = true;
dvander@7
   354
}
dvander@7
   355
dvander@7
   356
//-----------------------------------------------------------------------------
dvander@7
   357
// Purpose: 
dvander@7
   358
// Input  : *name - 
dvander@7
   359
// Output : ConCommandBase
dvander@7
   360
//-----------------------------------------------------------------------------
dvander@7
   361
ConCommandBase const *ConCommandBase::FindCommand( char const *name )
dvander@7
   362
{
dvander@7
   363
	ConCommandBase const *cmd = GetCommands();
dvander@7
   364
	for ( ; cmd; cmd = cmd->GetNext() )
dvander@7
   365
	{
dvander@7
   366
		if ( !stricmp( name, cmd->GetName() ) )
dvander@7
   367
			return cmd;
dvander@7
   368
	}
dvander@7
   369
	return NULL;
dvander@7
   370
}
dvander@7
   371
dvander@7
   372
//-----------------------------------------------------------------------------
dvander@7
   373
// Purpose: 
dvander@7
   374
// Output : ConCommandBase
dvander@7
   375
//-----------------------------------------------------------------------------
dvander@7
   376
const ConCommandBase *ConCommandBase::GetCommands( void )
dvander@7
   377
{
dvander@7
   378
	return s_pConCommandBases;
dvander@7
   379
}
dvander@7
   380
dvander@7
   381
//-----------------------------------------------------------------------------
dvander@7
   382
// Purpose: 
dvander@7
   383
// Input  : *var - 
dvander@7
   384
// Output : static
dvander@7
   385
//-----------------------------------------------------------------------------
dvander@7
   386
void ConCommandBase::AddToList( ConCommandBase *var )
dvander@7
   387
{
dvander@7
   388
	// This routine is only valid on root ConCommandBases
dvander@7
   389
	var->m_pNext = s_pConCommandBases;
dvander@7
   390
	s_pConCommandBases = var;
dvander@7
   391
}
dvander@7
   392
dvander@7
   393
//-----------------------------------------------------------------------------
dvander@7
   394
// Purpose: Return name of the command/var
dvander@7
   395
// Output : char const
dvander@7
   396
//-----------------------------------------------------------------------------
dvander@7
   397
char const *ConCommandBase::GetName( void ) const
dvander@7
   398
{
dvander@7
   399
	return m_pszName;
dvander@7
   400
}
dvander@7
   401
dvander@7
   402
//-----------------------------------------------------------------------------
dvander@7
   403
// Purpose: 
dvander@7
   404
// Input  : flag - 
dvander@7
   405
//-----------------------------------------------------------------------------
dvander@7
   406
void ConCommandBase::RemoveFlaggedCommands( int flag )
dvander@7
   407
{
dvander@7
   408
	ConCommandBase	*pNewList;
dvander@7
   409
	ConCommandBase  *pCommand, *pNext;
dvander@7
   410
dvander@7
   411
	pNewList = NULL;
dvander@7
   412
dvander@7
   413
	pCommand = s_pConCommandBases;
dvander@7
   414
	while ( pCommand )
dvander@7
   415
	{
dvander@7
   416
		pNext = pCommand->m_pNext;
dvander@7
   417
		if ( !( pCommand->m_nFlags & flag ) )
dvander@7
   418
		{
dvander@7
   419
			pCommand->m_pNext = pNewList;
dvander@7
   420
			pNewList = pCommand;
dvander@7
   421
		}
dvander@7
   422
		else
dvander@7
   423
		{
dvander@7
   424
			// Unlink
dvander@7
   425
			pCommand->m_pNext = NULL;
dvander@7
   426
		}
dvander@7
   427
dvander@7
   428
		pCommand = pNext;
dvander@7
   429
	}
dvander@7
   430
	
dvander@7
   431
	s_pConCommandBases = pNewList;
dvander@7
   432
}
dvander@7
   433
dvander@7
   434
void ConCommandBase::RevertFlaggedCvars( int flag )
dvander@7
   435
{
dvander@7
   436
	for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
dvander@7
   437
	{
dvander@7
   438
		if ( var->IsCommand() )
dvander@7
   439
			continue;
dvander@7
   440
dvander@7
   441
		ConVar *cvar = ( ConVar * )var;
dvander@7
   442
dvander@7
   443
		if ( !cvar->IsBitSet( flag ) )
dvander@7
   444
			continue;
dvander@7
   445
dvander@7
   446
		// It's == to the default value, don't count
dvander@7
   447
		if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
dvander@7
   448
			continue;
dvander@7
   449
dvander@7
   450
		cvar->Revert();
dvander@7
   451
dvander@7
   452
		// DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
dvander@7
   453
	}
dvander@7
   454
}
dvander@7
   455
dvander@7
   456
//-----------------------------------------------------------------------------
dvander@7
   457
// Purpose: 
dvander@7
   458
// Input  : flag - 
dvander@7
   459
// Output : Returns true on success, false on failure.
dvander@7
   460
//-----------------------------------------------------------------------------
dvander@7
   461
bool ConCommandBase::IsBitSet( int flag ) const
dvander@7
   462
{
dvander@7
   463
	return ( flag & m_nFlags ) ? true : false;
dvander@7
   464
}
dvander@7
   465
dvander@7
   466
//-----------------------------------------------------------------------------
dvander@7
   467
// Purpose: 
dvander@7
   468
// Input  : flags - 
dvander@7
   469
//-----------------------------------------------------------------------------
dvander@7
   470
void ConCommandBase::AddFlags( int flags )
dvander@7
   471
{
dvander@7
   472
	m_nFlags |= flags;
dvander@7
   473
}
dvander@7
   474
dvander@7
   475
//-----------------------------------------------------------------------------
dvander@7
   476
// Purpose: 
dvander@7
   477
// Output : const ConCommandBase
dvander@7
   478
//-----------------------------------------------------------------------------
dvander@7
   479
const ConCommandBase *ConCommandBase::GetNext( void ) const
dvander@7
   480
{
dvander@7
   481
	return m_pNext;
dvander@7
   482
}
dvander@7
   483
dvander@7
   484
//-----------------------------------------------------------------------------
dvander@7
   485
// Purpose: 
dvander@7
   486
// Input  : *next - 
dvander@7
   487
//-----------------------------------------------------------------------------
dvander@7
   488
void ConCommandBase::SetNext( ConCommandBase *next )
dvander@7
   489
{
dvander@7
   490
	m_pNext = next;
dvander@7
   491
}
dvander@7
   492
dvander@7
   493
//-----------------------------------------------------------------------------
dvander@7
   494
// Purpose: Copies string using local new/delete operators
dvander@7
   495
// Input  : *from - 
dvander@7
   496
// Output : char
dvander@7
   497
//-----------------------------------------------------------------------------
dvander@7
   498
char *ConCommandBase::CopyString( char const *from )
dvander@7
   499
{
dvander@7
   500
	int		len;
dvander@7
   501
	char	*to;
dvander@7
   502
dvander@7
   503
	len = strlen( from );
dvander@7
   504
	if ( len <= 0 )
dvander@7
   505
	{
dvander@7
   506
		to = new char[1];
dvander@7
   507
		to[0] = 0;
dvander@7
   508
	}
dvander@7
   509
	else
dvander@7
   510
	{
dvander@7
   511
		to = new char[len+1];
dvander@7
   512
		Q_strncpy( to, from, len+1 );
dvander@7
   513
	}
dvander@7
   514
	return to;
dvander@7
   515
}
dvander@7
   516
dvander@7
   517
//-----------------------------------------------------------------------------
dvander@7
   518
// Purpose: 
dvander@7
   519
// Output : char const
dvander@7
   520
//-----------------------------------------------------------------------------
dvander@7
   521
char const *ConCommandBase::GetHelpText( void ) const
dvander@7
   522
{
dvander@7
   523
	return m_pszHelpString;
dvander@7
   524
}
dvander@7
   525
dvander@7
   526
//-----------------------------------------------------------------------------
dvander@7
   527
// Purpose: Has this cvar been registered
dvander@7
   528
// Output : Returns true on success, false on failure.
dvander@7
   529
//-----------------------------------------------------------------------------
dvander@7
   530
bool ConCommandBase::IsRegistered( void ) const
dvander@7
   531
{
dvander@7
   532
	return m_bRegistered;
dvander@7
   533
}
dvander@7
   534
dvander@7
   535
//-----------------------------------------------------------------------------
dvander@7
   536
// Purpose: Constructs a console command
dvander@7
   537
// Input  : *pName - name of command
dvander@7
   538
//			callback - function to call upon execution
dvander@7
   539
//			*pHelpString - help text for command
dvander@7
   540
//			flags - command flags, if any
dvander@7
   541
//-----------------------------------------------------------------------------
dvander@7
   542
ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
dvander@7
   543
{
dvander@7
   544
	Create( pName, callback, pHelpString, flags, completionFunc );
dvander@7
   545
}
dvander@7
   546
dvander@7
   547
//-----------------------------------------------------------------------------
dvander@7
   548
// Purpose: 
dvander@7
   549
//-----------------------------------------------------------------------------
dvander@7
   550
ConCommand::~ConCommand( void )
dvander@7
   551
{
dvander@7
   552
}
dvander@7
   553
dvander@7
   554
//-----------------------------------------------------------------------------
dvander@7
   555
// Purpose: 
dvander@7
   556
// Output : Returns true on success, false on failure.
dvander@7
   557
//-----------------------------------------------------------------------------
dvander@7
   558
bool ConCommand::IsCommand( void ) const
dvander@7
   559
{ 
dvander@7
   560
	return true;
dvander@7
   561
}
dvander@7
   562
dvander@7
   563
//-----------------------------------------------------------------------------
dvander@7
   564
// Purpose: Invoke the function if there is one
dvander@7
   565
//-----------------------------------------------------------------------------
dvander@7
   566
void ConCommand::Dispatch( void )
dvander@7
   567
{
dvander@7
   568
	if ( m_fnCommandCallback )
dvander@7
   569
	{
dvander@7
   570
		( *m_fnCommandCallback )();
dvander@7
   571
	}
dvander@7
   572
	else
dvander@7
   573
	{
dvander@7
   574
		// Command without callback!!!
dvander@7
   575
		Assert( 0 );
dvander@7
   576
	}
dvander@7
   577
}
dvander@7
   578
dvander@7
   579
//-----------------------------------------------------------------------------
dvander@7
   580
// Purpose: 
dvander@7
   581
// Input  : *partial - 
dvander@7
   582
//			context - 
dvander@7
   583
//			longest - 
dvander@7
   584
//			maxcommands - 
dvander@7
   585
//			**commands - 
dvander@7
   586
// Output : int
dvander@7
   587
//-----------------------------------------------------------------------------
dvander@7
   588
int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
dvander@7
   589
{
dvander@7
   590
	return 0;
dvander@7
   591
}
dvander@7
   592
dvander@7
   593
//-----------------------------------------------------------------------------
dvander@7
   594
// Purpose: Create the named command
dvander@7
   595
// Input  : *pName - 
dvander@7
   596
//			callback - 
dvander@7
   597
//			*pHelpString - 
dvander@7
   598
//			flags - 
dvander@7
   599
//-----------------------------------------------------------------------------
dvander@7
   600
void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
dvander@7
   601
{
dvander@7
   602
	// Set the callback
dvander@7
   603
	m_fnCommandCallback = callback;
dvander@7
   604
dvander@7
   605
	m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
dvander@7
   606
	m_bHasCompletionCallback = completionFunc != 0 ? true : false;
dvander@7
   607
dvander@7
   608
	// Setup the rest
dvander@7
   609
	BaseClass::Create( pName, pHelpString, flags );
dvander@7
   610
}
dvander@7
   611
dvander@7
   612
//-----------------------------------------------------------------------------
dvander@7
   613
// Purpose: 
dvander@7
   614
// Input  : *partial - 
dvander@7
   615
//			context - 
dvander@7
   616
//			longest - 
dvander@7
   617
//			maxcommands - 
dvander@7
   618
//			**commands - 
dvander@7
   619
//-----------------------------------------------------------------------------
dvander@7
   620
int	ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
dvander@7
   621
{
dvander@7
   622
	Assert( m_fnCompletionCallback );
dvander@7
   623
	if ( !m_fnCompletionCallback )
dvander@7
   624
		return 0;
dvander@7
   625
dvander@7
   626
	return ( m_fnCompletionCallback )( partial, commands );
dvander@7
   627
}
dvander@7
   628
dvander@7
   629
//-----------------------------------------------------------------------------
dvander@7
   630
// Purpose: 
dvander@7
   631
// Output : Returns true on success, false on failure.
dvander@7
   632
//-----------------------------------------------------------------------------
dvander@7
   633
bool ConCommand::CanAutoComplete( void )
dvander@7
   634
{
dvander@7
   635
	return m_bHasCompletionCallback;
dvander@7
   636
}
dvander@7
   637
dvander@7
   638
// ----------------------------------------------------------------------------- //
dvander@7
   639
// ConVar.
dvander@7
   640
// ----------------------------------------------------------------------------- //
dvander@7
   641
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
dvander@7
   642
{
dvander@7
   643
	Create( pName, pDefaultValue, flags );
dvander@7
   644
}
dvander@7
   645
dvander@7
   646
// ----------------------------------------------------------------------------- //
dvander@7
   647
// ConVar.
dvander@7
   648
// ----------------------------------------------------------------------------- //
dvander@7
   649
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
dvander@7
   650
{
dvander@7
   651
	Create( pName, pDefaultValue, flags, pHelpString );
dvander@7
   652
}
dvander@7
   653
dvander@7
   654
// ----------------------------------------------------------------------------- //
dvander@7
   655
// ConVar.
dvander@7
   656
// ----------------------------------------------------------------------------- //
dvander@7
   657
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
dvander@7
   658
{
dvander@7
   659
	Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
dvander@7
   660
}
dvander@7
   661
dvander@7
   662
// ----------------------------------------------------------------------------- //
dvander@7
   663
// ConVar.
dvander@7
   664
// ----------------------------------------------------------------------------- //
dvander@7
   665
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
dvander@7
   666
{
dvander@7
   667
	Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
dvander@7
   668
}
dvander@7
   669
dvander@7
   670
// ----------------------------------------------------------------------------- //
dvander@7
   671
// ConVar.
dvander@7
   672
// ----------------------------------------------------------------------------- //
dvander@7
   673
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
dvander@7
   674
{
dvander@7
   675
	Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
dvander@7
   676
}
dvander@7
   677
dvander@7
   678
//-----------------------------------------------------------------------------
dvander@7
   679
// Purpose: Free dynamic memory
dvander@7
   680
//-----------------------------------------------------------------------------
dvander@7
   681
ConVar::~ConVar( void )
dvander@7
   682
{
dvander@7
   683
	if ( m_pszString )
dvander@7
   684
	{
dvander@7
   685
		delete[] m_pszString;
dvander@7
   686
		m_pszString = NULL;
dvander@7
   687
	}
dvander@7
   688
}
dvander@7
   689
dvander@7
   690
dvander@7
   691
//-----------------------------------------------------------------------------
dvander@7
   692
// Install a change callback (there shouldn't already be one....)
dvander@7
   693
//-----------------------------------------------------------------------------
dvander@7
   694
dvander@7
   695
void ConVar::InstallChangeCallback( FnChangeCallback callback )
dvander@7
   696
{
dvander@7
   697
	Assert( !m_fnChangeCallback || !callback );
dvander@7
   698
	m_fnChangeCallback = callback;
dvander@7
   699
dvander@7
   700
	if (m_fnChangeCallback)
dvander@7
   701
	{
dvander@7
   702
		// Call it immediately to set the initial value...
dvander@7
   703
		m_fnChangeCallback( this, m_pszString );
dvander@7
   704
	}
dvander@7
   705
}
dvander@7
   706
dvander@7
   707
bool ConVar::IsBitSet( int flag ) const
dvander@7
   708
{
dvander@7
   709
	return ( flag & m_pParent->m_nFlags ) ? true : false;
dvander@7
   710
}
dvander@7
   711
dvander@7
   712
char const *ConVar::GetHelpText( void ) const
dvander@7
   713
{
dvander@7
   714
	return m_pParent->m_pszHelpString;
dvander@7
   715
}
dvander@7
   716
dvander@7
   717
void ConVar::AddFlags( int flags )
dvander@7
   718
{
dvander@7
   719
	m_pParent->m_nFlags |= flags;
dvander@7
   720
}
dvander@7
   721
dvander@7
   722
bool ConVar::IsRegistered( void ) const
dvander@7
   723
{
dvander@7
   724
	return m_pParent->m_bRegistered;
dvander@7
   725
}
dvander@7
   726
dvander@7
   727
char const *ConVar::GetName( void ) const
dvander@7
   728
{
dvander@7
   729
	return m_pParent->m_pszName;
dvander@7
   730
}
dvander@7
   731
dvander@7
   732
//-----------------------------------------------------------------------------
dvander@7
   733
// Purpose: 
dvander@7
   734
// Output : Returns true on success, false on failure.
dvander@7
   735
//-----------------------------------------------------------------------------
dvander@7
   736
bool ConVar::IsCommand( void ) const
dvander@7
   737
{ 
dvander@7
   738
	return false;
dvander@7
   739
}
dvander@7
   740
dvander@7
   741
//-----------------------------------------------------------------------------
dvander@7
   742
// Purpose: 
dvander@7
   743
// Input  : 
dvander@7
   744
//-----------------------------------------------------------------------------
dvander@7
   745
void ConVar::Init()
dvander@7
   746
{
dvander@7
   747
	BaseClass::Init();
dvander@7
   748
}
dvander@7
   749
dvander@7
   750
//-----------------------------------------------------------------------------
dvander@7
   751
// Purpose: 
dvander@7
   752
// Input  : *value - 
dvander@7
   753
//-----------------------------------------------------------------------------
dvander@7
   754
void ConVar::InternalSetValue( char const *value )
dvander@7
   755
{
dvander@7
   756
	float fNewValue;
dvander@7
   757
	char  tempVal[ 32 ];
dvander@7
   758
	char  *val;
dvander@7
   759
dvander@7
   760
	Assert(m_pParent == this); // Only valid for root convars.
dvander@7
   761
dvander@7
   762
	val = (char *)value;
dvander@7
   763
	fNewValue = ( float )atof( value );
dvander@7
   764
dvander@7
   765
	if ( ClampValue( fNewValue ) )
dvander@7
   766
	{
dvander@7
   767
		Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
dvander@7
   768
		val = tempVal;
dvander@7
   769
	}
dvander@7
   770
	
dvander@7
   771
	// Redetermine value
dvander@7
   772
	m_fValue		= fNewValue;
dvander@7
   773
	m_nValue		= ( int )( m_fValue );
dvander@7
   774
dvander@7
   775
	if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
dvander@7
   776
		ChangeStringValue( val );
dvander@7
   777
}
dvander@7
   778
dvander@7
   779
//-----------------------------------------------------------------------------
dvander@7
   780
// Purpose: 
dvander@7
   781
// Input  : *tempVal - 
dvander@7
   782
//-----------------------------------------------------------------------------
dvander@7
   783
void ConVar::ChangeStringValue( char const *tempVal )
dvander@7
   784
{
dvander@7
   785
	Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
dvander@7
   786
dvander@232
   787
 	char* pszOldValue = (char*)stackalloc( m_StringLength );
dvander@232
   788
	memcpy( pszOldValue, m_pszString, m_StringLength );
dvander@7
   789
	
dvander@7
   790
	int len = Q_strlen(tempVal) + 1;
dvander@7
   791
dvander@7
   792
	if ( len > m_StringLength)
dvander@7
   793
	{
dvander@7
   794
		if (m_pszString)
dvander@7
   795
			delete[] m_pszString;
dvander@7
   796
dvander@7
   797
		m_pszString	= new char[len];
dvander@7
   798
		m_StringLength = len;
dvander@7
   799
	}
dvander@7
   800
dvander@7
   801
	memcpy( m_pszString, tempVal, len );
dvander@7
   802
dvander@7
   803
	// Invoke any necessary callback function
dvander@7
   804
	if ( m_fnChangeCallback )
dvander@7
   805
	{
dvander@7
   806
		m_fnChangeCallback( this, pszOldValue );
dvander@7
   807
	}
dvander@7
   808
dvander@232
   809
	GetCVarIF()->CallGlobalChangeCallback( this, pszOldValue );
dvander@232
   810
dvander@7
   811
	stackfree( pszOldValue );
dvander@7
   812
}
dvander@7
   813
dvander@7
   814
//-----------------------------------------------------------------------------
dvander@7
   815
// Purpose: Check whether to clamp and then perform clamp
dvander@7
   816
// Input  : value - 
dvander@7
   817
// Output : Returns true if value changed
dvander@7
   818
//-----------------------------------------------------------------------------
dvander@7
   819
bool ConVar::ClampValue( float& value )
dvander@7
   820
{
dvander@7
   821
	if ( m_bHasMin && ( value < m_fMinVal ) )
dvander@7
   822
	{
dvander@7
   823
		value = m_fMinVal;
dvander@7
   824
		return true;
dvander@7
   825
	}
dvander@7
   826
	
dvander@7
   827
	if ( m_bHasMax && ( value > m_fMaxVal ) )
dvander@7
   828
	{
dvander@7
   829
		value = m_fMaxVal;
dvander@7
   830
		return true;
dvander@7
   831
	}
dvander@7
   832
dvander@7
   833
	return false;
dvander@7
   834
}
dvander@7
   835
dvander@7
   836
//-----------------------------------------------------------------------------
dvander@7
   837
// Purpose: 
dvander@7
   838
// Input  : *value - 
dvander@7
   839
//-----------------------------------------------------------------------------
dvander@7
   840
void ConVar::InternalSetFloatValue( float fNewValue )
dvander@7
   841
{
dvander@7
   842
	if ( fNewValue == m_fValue )
dvander@7
   843
		return;
dvander@7
   844
dvander@7
   845
	Assert( m_pParent == this ); // Only valid for root convars.
dvander@7
   846
dvander@7
   847
	// Check bounds
dvander@7
   848
	ClampValue( fNewValue );
dvander@7
   849
dvander@7
   850
	// Redetermine value
dvander@7
   851
	m_fValue		= fNewValue;
dvander@7
   852
	m_nValue		= ( int )m_fValue;
dvander@7
   853
dvander@7
   854
	if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
dvander@7
   855
	{
dvander@7
   856
		char tempVal[ 32 ];
dvander@7
   857
		Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
dvander@7
   858
		ChangeStringValue( tempVal );
dvander@7
   859
	}
dvander@7
   860
	else
dvander@7
   861
	{
dvander@7
   862
		Assert( !m_fnChangeCallback );
dvander@7
   863
	}
dvander@7
   864
}
dvander@7
   865
dvander@7
   866
//-----------------------------------------------------------------------------
dvander@7
   867
// Purpose: 
dvander@7
   868
// Input  : *value - 
dvander@7
   869
//-----------------------------------------------------------------------------
dvander@7
   870
void ConVar::InternalSetIntValue( int nValue )
dvander@7
   871
{
dvander@7
   872
	if ( nValue == m_nValue )
dvander@7
   873
		return;
dvander@7
   874
dvander@7
   875
	Assert( m_pParent == this ); // Only valid for root convars.
dvander@7
   876
dvander@7
   877
	float fValue = (float)nValue;
dvander@7
   878
	if ( ClampValue( fValue ) )
dvander@7
   879
	{
dvander@7
   880
		nValue = ( int )( fValue );
dvander@7
   881
	}
dvander@7
   882
dvander@7
   883
	// Redetermine value
dvander@7
   884
	m_fValue		= fValue;
dvander@7
   885
	m_nValue		= nValue;
dvander@7
   886
dvander@7
   887
	if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
dvander@7
   888
	{
dvander@7
   889
		char tempVal[ 32 ];
dvander@7
   890
		Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
dvander@7
   891
		ChangeStringValue( tempVal );
dvander@7
   892
	}
dvander@7
   893
	else
dvander@7
   894
	{
dvander@7
   895
		Assert( !m_fnChangeCallback );
dvander@7
   896
	}
dvander@7
   897
}
dvander@7
   898
dvander@7
   899
//-----------------------------------------------------------------------------
dvander@7
   900
// Purpose: Private creation
dvander@7
   901
//-----------------------------------------------------------------------------
dvander@7
   902
void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
dvander@7
   903
	char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
dvander@7
   904
	bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
dvander@7
   905
{
dvander@7
   906
	static char *empty_string = "";
dvander@7
   907
dvander@7
   908
	m_pParent = this;
dvander@7
   909
dvander@7
   910
	// Name should be static data
dvander@7
   911
	m_pszDefaultValue	= pDefaultValue ? pDefaultValue : empty_string;
dvander@7
   912
	Assert( pDefaultValue );
dvander@7
   913
dvander@7
   914
	m_StringLength = strlen( m_pszDefaultValue ) + 1;
dvander@7
   915
	m_pszString = new char[m_StringLength];
dvander@7
   916
	memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
dvander@7
   917
	
dvander@7
   918
	m_bHasMin = bMin;
dvander@7
   919
	m_fMinVal = fMin;
dvander@7
   920
	m_bHasMax = bMax;
dvander@7
   921
	m_fMaxVal = fMax;
dvander@7
   922
	
dvander@7
   923
	m_fnChangeCallback = callback;
dvander@7
   924
dvander@7
   925
	m_fValue = ( float )atof( m_pszString );
dvander@7
   926
dvander@7
   927
	// Bounds Check, should never happen, if it does, no big deal
dvander@7
   928
	if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
dvander@7
   929
	{
dvander@7
   930
		Assert( 0 );
dvander@7
   931
	}
dvander@7
   932
dvander@7
   933
	if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
dvander@7
   934
	{
dvander@7
   935
		Assert( 0 );
dvander@7
   936
	}
dvander@7
   937
dvander@7
   938
	m_nValue = ( int )m_fValue;
dvander@7
   939
dvander@7
   940
	BaseClass::Create( pName, pHelpString, flags );
dvander@7
   941
}
dvander@7
   942
dvander@7
   943
//-----------------------------------------------------------------------------
dvander@7
   944
// Purpose: 
dvander@7
   945
// Input  : *value - 
dvander@7
   946
//-----------------------------------------------------------------------------
dvander@7
   947
void ConVar::SetValue(char const *value)
dvander@7
   948
{
dvander@7
   949
	ConVar *var = ( ConVar * )m_pParent;
dvander@7
   950
	var->InternalSetValue( value );
dvander@7
   951
}
dvander@7
   952
dvander@7
   953
//-----------------------------------------------------------------------------
dvander@7
   954
// Purpose: 
dvander@7
   955
// Input  : value - 
dvander@7
   956
//-----------------------------------------------------------------------------
dvander@7
   957
void ConVar::SetValue( float value )
dvander@7
   958
{
dvander@7
   959
	ConVar *var = ( ConVar * )m_pParent;
dvander@7
   960
	var->InternalSetFloatValue( value );
dvander@7
   961
}
dvander@7
   962
dvander@7
   963
//-----------------------------------------------------------------------------
dvander@7
   964
// Purpose: 
dvander@7
   965
// Input  : value - 
dvander@7
   966
//-----------------------------------------------------------------------------
dvander@7
   967
void ConVar::SetValue( int value )
dvander@7
   968
{
dvander@7
   969
	ConVar *var = ( ConVar * )m_pParent;
dvander@7
   970
	var->InternalSetIntValue( value );
dvander@7
   971
}
dvander@7
   972
dvander@7
   973
//-----------------------------------------------------------------------------
dvander@7
   974
// Purpose: Reset to default value
dvander@7
   975
//-----------------------------------------------------------------------------
dvander@7
   976
void ConVar::Revert( void )
dvander@7
   977
{
dvander@7
   978
	// Force default value again
dvander@7
   979
	ConVar *var = ( ConVar * )m_pParent;
dvander@7
   980
	var->SetValue( var->m_pszDefaultValue );
dvander@7
   981
}
dvander@7
   982
dvander@7
   983
//-----------------------------------------------------------------------------
dvander@7
   984
// Purpose: 
dvander@7
   985
//-----------------------------------------------------------------------------
dvander@7
   986
void ConVar::RevertAll( void )
dvander@7
   987
{
dvander@7
   988
	ConCommandBase *p = s_pConCommandBases;
dvander@7
   989
	while ( p  )
dvander@7
   990
	{
dvander@7
   991
		if ( !p->IsCommand() )
dvander@7
   992
		{
dvander@7
   993
			ConVar *var = ( ConVar * )p;
dvander@7
   994
			var->Revert();
dvander@7
   995
		}
dvander@7
   996
		p = p->m_pNext;
dvander@7
   997
	}
dvander@7
   998
}
dvander@7
   999
dvander@7
  1000
//-----------------------------------------------------------------------------
dvander@7
  1001
// Purpose: 
dvander@7
  1002
// Input  : minVal - 
dvander@7
  1003
// Output : true if there is a min set
dvander@7
  1004
//-----------------------------------------------------------------------------
dvander@7
  1005
bool ConVar::GetMin( float& minVal ) const
dvander@7
  1006
{
dvander@7
  1007
	minVal = m_pParent->m_fMinVal;
dvander@7
  1008
	return m_pParent->m_bHasMin;
dvander@7
  1009
}
dvander@7
  1010
dvander@7
  1011
//-----------------------------------------------------------------------------
dvander@7
  1012
// Purpose: 
dvander@7
  1013
// Input  : maxVal - 
dvander@7
  1014
//-----------------------------------------------------------------------------
dvander@7
  1015
bool ConVar::GetMax( float& maxVal ) const
dvander@7
  1016
{
dvander@7
  1017
	maxVal = m_pParent->m_fMaxVal;
dvander@7
  1018
	return m_pParent->m_bHasMax;
dvander@7
  1019
}
dvander@7
  1020
dvander@7
  1021
//-----------------------------------------------------------------------------
dvander@7
  1022
// Purpose: 
dvander@7
  1023
// Output : char const
dvander@7
  1024
//-----------------------------------------------------------------------------
dvander@7
  1025
char const *ConVar::GetDefault( void ) const
dvander@7
  1026
{
dvander@7
  1027
	return m_pParent->m_pszDefaultValue;
dvander@7
  1028
}
dvander@7
  1029