sourcemm/convar.cpp
author Scott Ehlert <ds@alliedmods.net>
Mon Apr 17 19:42:55 2006 +0000 (2006-04-17)
changeset 187 d81c2fc9a708
parent 7 8ef11f6189e4
child 232 a86d52ff721c
permissions -rw-r--r--
Fixed a warning in stub and sample :|
     1 //========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
     2 //
     3 // Purpose: 
     4 //
     5 // $NoKeywords: $
     6 //
     7 //=============================================================================//
     8 
     9 #include <stdio.h>
    10 #include <stdlib.h>
    11 #include <string.h>
    12 #include "basetypes.h"
    13 #include "convar.h"
    14 #include "vstdlib/strtools.h"
    15 #include "tier0/dbg.h"
    16 #include "tier0/memdbgon.h"
    17 
    18 
    19 ConCommandBase			*ConCommandBase::s_pConCommandBases = NULL;
    20 IConCommandBaseAccessor	*ConCommandBase::s_pAccessor = NULL;
    21 
    22 // ----------------------------------------------------------------------------- //
    23 // ConCommandBaseMgr.
    24 // ----------------------------------------------------------------------------- //
    25 void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
    26 {
    27 	ConCommandBase *pCur, *pNext;
    28 
    29 	ConCommandBase::s_pAccessor = pAccessor;
    30 
    31 	pCur = ConCommandBase::s_pConCommandBases;
    32 	while ( pCur )
    33 	{
    34 		pNext = pCur->m_pNext;
    35 		pCur->Init();
    36 		pCur = pNext;
    37 	}
    38 }
    39 
    40 //-----------------------------------------------------------------------------
    41 // Purpose: Default constructor
    42 //-----------------------------------------------------------------------------
    43 ConCommandBase::ConCommandBase( void )
    44 {
    45 	m_bRegistered			= false;
    46 	m_pszName				= NULL;
    47 	m_pszHelpString			= NULL;
    48 
    49 	m_nFlags				= 0;
    50 	m_pNext					= NULL;
    51 }
    52 
    53 //-----------------------------------------------------------------------------
    54 // Purpose: The base console invoked command/cvar interface
    55 // Input  : *pName - name of variable/command
    56 //			*pHelpString - help text
    57 //			flags - flags
    58 //-----------------------------------------------------------------------------
    59 ConCommandBase::ConCommandBase( char const *pName, char const *pHelpString /*=0*/, int flags /*= 0*/ )
    60 {
    61 	Create( pName, pHelpString, flags );
    62 }
    63 
    64 //-----------------------------------------------------------------------------
    65 // Purpose: 
    66 //-----------------------------------------------------------------------------
    67 ConCommandBase::~ConCommandBase( void )
    68 {
    69 }
    70 
    71 //-----------------------------------------------------------------------------
    72 // Purpose: 
    73 // Output : Returns true on success, false on failure.
    74 //-----------------------------------------------------------------------------
    75 bool ConCommandBase::IsCommand( void ) const
    76 { 
    77 //	Assert( 0 ); This can't assert. . causes a recursive assert in Sys_Printf, etc.
    78 	return true;
    79 }
    80 	
    81 //-----------------------------------------------------------------------------
    82 // Purpose: 
    83 // Input  : *pName - 
    84 //			callback - 
    85 //			*pHelpString - 
    86 //			flags - 
    87 //-----------------------------------------------------------------------------
    88 void ConCommandBase::Create( char const *pName, char const *pHelpString /*= 0*/, int flags /*= 0*/ )
    89 {
    90 	static char *empty_string = "";
    91 
    92 	m_bRegistered		= false;
    93 
    94 	// Name should be static data
    95 	Assert( pName );
    96 	m_pszName			= pName;
    97 	m_pszHelpString		= pHelpString ? pHelpString : empty_string;
    98 
    99 	m_nFlags = flags;
   100 
   101 	if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
   102 	{
   103 		m_pNext		= s_pConCommandBases;
   104 		s_pConCommandBases	= this;
   105 	}
   106 	else
   107 	{
   108 		// It's unregistered
   109 		m_pNext		= NULL;
   110 	}
   111 
   112 	// If s_pAccessor is already set (this ConVar is not a global variable),
   113 	//  register it.
   114 	if ( s_pAccessor )
   115 	{
   116 		Init();
   117 	}
   118 }
   119 
   120 //-----------------------------------------------------------------------------
   121 // Purpose: Used internally by OneTimeInit to initialize.
   122 //-----------------------------------------------------------------------------
   123 void ConCommandBase::Init()
   124 {
   125 	if ( !s_pAccessor )
   126 		return;
   127 	
   128 	if ( m_bRegistered )
   129 		return;
   130 
   131 	s_pAccessor->RegisterConCommandBase( this );
   132 
   133 	m_bRegistered = true;
   134 }
   135 
   136 //-----------------------------------------------------------------------------
   137 // Purpose: 
   138 // Input  : *name - 
   139 // Output : ConCommandBase
   140 //-----------------------------------------------------------------------------
   141 ConCommandBase const *ConCommandBase::FindCommand( char const *name )
   142 {
   143 	ConCommandBase const *cmd = GetCommands();
   144 	for ( ; cmd; cmd = cmd->GetNext() )
   145 	{
   146 		if ( !stricmp( name, cmd->GetName() ) )
   147 			return cmd;
   148 	}
   149 	return NULL;
   150 }
   151 
   152 //-----------------------------------------------------------------------------
   153 // Purpose: 
   154 // Output : ConCommandBase
   155 //-----------------------------------------------------------------------------
   156 const ConCommandBase *ConCommandBase::GetCommands( void )
   157 {
   158 	return s_pConCommandBases;
   159 }
   160 
   161 //-----------------------------------------------------------------------------
   162 // Purpose: 
   163 // Input  : *var - 
   164 // Output : static
   165 //-----------------------------------------------------------------------------
   166 void ConCommandBase::AddToList( ConCommandBase *var )
   167 {
   168 	// This routine is only valid on root ConCommandBases
   169 	var->m_pNext = s_pConCommandBases;
   170 	s_pConCommandBases = var;
   171 }
   172 
   173 //-----------------------------------------------------------------------------
   174 // Purpose: Return name of the command/var
   175 // Output : char const
   176 //-----------------------------------------------------------------------------
   177 char const *ConCommandBase::GetName( void ) const
   178 {
   179 	return m_pszName;
   180 }
   181 
   182 //-----------------------------------------------------------------------------
   183 // Purpose: 
   184 // Input  : flag - 
   185 //-----------------------------------------------------------------------------
   186 void ConCommandBase::RemoveFlaggedCommands( int flag )
   187 {
   188 	ConCommandBase	*pNewList;
   189 	ConCommandBase  *pCommand, *pNext;
   190 
   191 	pNewList = NULL;
   192 
   193 	pCommand = s_pConCommandBases;
   194 	while ( pCommand )
   195 	{
   196 		pNext = pCommand->m_pNext;
   197 		if ( !( pCommand->m_nFlags & flag ) )
   198 		{
   199 			pCommand->m_pNext = pNewList;
   200 			pNewList = pCommand;
   201 		}
   202 		else
   203 		{
   204 			// Unlink
   205 			pCommand->m_pNext = NULL;
   206 		}
   207 
   208 		pCommand = pNext;
   209 	}
   210 	
   211 	s_pConCommandBases = pNewList;
   212 }
   213 
   214 void ConCommandBase::RevertFlaggedCvars( int flag )
   215 {
   216 	for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
   217 	{
   218 		if ( var->IsCommand() )
   219 			continue;
   220 
   221 		ConVar *cvar = ( ConVar * )var;
   222 
   223 		if ( !cvar->IsBitSet( flag ) )
   224 			continue;
   225 
   226 		// It's == to the default value, don't count
   227 		if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
   228 			continue;
   229 
   230 		cvar->Revert();
   231 
   232 		// DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
   233 	}
   234 }
   235 
   236 //-----------------------------------------------------------------------------
   237 // Purpose: 
   238 // Input  : flag - 
   239 // Output : Returns true on success, false on failure.
   240 //-----------------------------------------------------------------------------
   241 bool ConCommandBase::IsBitSet( int flag ) const
   242 {
   243 	return ( flag & m_nFlags ) ? true : false;
   244 }
   245 
   246 //-----------------------------------------------------------------------------
   247 // Purpose: 
   248 // Input  : flags - 
   249 //-----------------------------------------------------------------------------
   250 void ConCommandBase::AddFlags( int flags )
   251 {
   252 	m_nFlags |= flags;
   253 }
   254 
   255 //-----------------------------------------------------------------------------
   256 // Purpose: 
   257 // Output : const ConCommandBase
   258 //-----------------------------------------------------------------------------
   259 const ConCommandBase *ConCommandBase::GetNext( void ) const
   260 {
   261 	return m_pNext;
   262 }
   263 
   264 //-----------------------------------------------------------------------------
   265 // Purpose: 
   266 // Input  : *next - 
   267 //-----------------------------------------------------------------------------
   268 void ConCommandBase::SetNext( ConCommandBase *next )
   269 {
   270 	m_pNext = next;
   271 }
   272 
   273 //-----------------------------------------------------------------------------
   274 // Purpose: Copies string using local new/delete operators
   275 // Input  : *from - 
   276 // Output : char
   277 //-----------------------------------------------------------------------------
   278 char *ConCommandBase::CopyString( char const *from )
   279 {
   280 	int		len;
   281 	char	*to;
   282 
   283 	len = strlen( from );
   284 	if ( len <= 0 )
   285 	{
   286 		to = new char[1];
   287 		to[0] = 0;
   288 	}
   289 	else
   290 	{
   291 		to = new char[len+1];
   292 		Q_strncpy( to, from, len+1 );
   293 	}
   294 	return to;
   295 }
   296 
   297 //-----------------------------------------------------------------------------
   298 // Purpose: 
   299 // Output : char const
   300 //-----------------------------------------------------------------------------
   301 char const *ConCommandBase::GetHelpText( void ) const
   302 {
   303 	return m_pszHelpString;
   304 }
   305 
   306 //-----------------------------------------------------------------------------
   307 // Purpose: Has this cvar been registered
   308 // Output : Returns true on success, false on failure.
   309 //-----------------------------------------------------------------------------
   310 bool ConCommandBase::IsRegistered( void ) const
   311 {
   312 	return m_bRegistered;
   313 }
   314 
   315 //-----------------------------------------------------------------------------
   316 // Purpose: Constructs a console command
   317 // Input  : *pName - name of command
   318 //			callback - function to call upon execution
   319 //			*pHelpString - help text for command
   320 //			flags - command flags, if any
   321 //-----------------------------------------------------------------------------
   322 ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
   323 {
   324 	Create( pName, callback, pHelpString, flags, completionFunc );
   325 }
   326 
   327 //-----------------------------------------------------------------------------
   328 // Purpose: 
   329 //-----------------------------------------------------------------------------
   330 ConCommand::~ConCommand( void )
   331 {
   332 
   333 }
   334 
   335 //-----------------------------------------------------------------------------
   336 // Purpose: 
   337 // Output : Returns true on success, false on failure.
   338 //-----------------------------------------------------------------------------
   339 bool ConCommand::IsCommand( void ) const
   340 { 
   341 	return true;
   342 }
   343 
   344 //-----------------------------------------------------------------------------
   345 // Purpose: Invoke the function if there is one
   346 //-----------------------------------------------------------------------------
   347 void ConCommand::Dispatch( void )
   348 {
   349 	if ( m_fnCommandCallback )
   350 	{
   351 		( *m_fnCommandCallback )();
   352 	}
   353 	else
   354 	{
   355 		// Command without callback!!!
   356 		Assert( 0 );
   357 	}
   358 }
   359 
   360 //-----------------------------------------------------------------------------
   361 // Purpose: 
   362 // Input  : *partial - 
   363 //			context - 
   364 //			longest - 
   365 //			maxcommands - 
   366 //			**commands - 
   367 // Output : int
   368 //-----------------------------------------------------------------------------
   369 int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
   370 {
   371 	return 0;
   372 }
   373 
   374 //-----------------------------------------------------------------------------
   375 // Purpose: Create the named command
   376 // Input  : *pName - 
   377 //			callback - 
   378 //			*pHelpString - 
   379 //			flags - 
   380 //-----------------------------------------------------------------------------
   381 void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
   382 {
   383 	// Set the callback
   384 	m_fnCommandCallback = callback;
   385 
   386 	m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
   387 	m_bHasCompletionCallback = completionFunc != 0 ? true : false;
   388 
   389 	// Setup the rest
   390 	BaseClass::Create( pName, pHelpString, flags );
   391 }
   392 
   393 //-----------------------------------------------------------------------------
   394 // Purpose: 
   395 // Input  : *partial - 
   396 //			context - 
   397 //			longest - 
   398 //			maxcommands - 
   399 //			**commands - 
   400 //-----------------------------------------------------------------------------
   401 int	ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
   402 {
   403 	Assert( m_fnCompletionCallback );
   404 	if ( !m_fnCompletionCallback )
   405 		return 0;
   406 
   407 	return ( m_fnCompletionCallback )( partial, commands );
   408 }
   409 
   410 //-----------------------------------------------------------------------------
   411 // Purpose: 
   412 // Output : Returns true on success, false on failure.
   413 //-----------------------------------------------------------------------------
   414 bool ConCommand::CanAutoComplete( void )
   415 {
   416 	return m_bHasCompletionCallback;
   417 }
   418 
   419 // ----------------------------------------------------------------------------- //
   420 // ConVar.
   421 // ----------------------------------------------------------------------------- //
   422 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
   423 {
   424 	Create( pName, pDefaultValue, flags );
   425 }
   426 
   427 // ----------------------------------------------------------------------------- //
   428 // ConVar.
   429 // ----------------------------------------------------------------------------- //
   430 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
   431 {
   432 	Create( pName, pDefaultValue, flags, pHelpString );
   433 }
   434 
   435 // ----------------------------------------------------------------------------- //
   436 // ConVar.
   437 // ----------------------------------------------------------------------------- //
   438 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
   439 {
   440 	Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
   441 }
   442 
   443 // ----------------------------------------------------------------------------- //
   444 // ConVar.
   445 // ----------------------------------------------------------------------------- //
   446 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
   447 {
   448 	Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
   449 }
   450 
   451 // ----------------------------------------------------------------------------- //
   452 // ConVar.
   453 // ----------------------------------------------------------------------------- //
   454 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
   455 {
   456 	Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
   457 }
   458 
   459 //-----------------------------------------------------------------------------
   460 // Purpose: Free dynamic memory
   461 //-----------------------------------------------------------------------------
   462 ConVar::~ConVar( void )
   463 {
   464 	if ( m_pszString )
   465 	{
   466 		delete[] m_pszString;
   467 		m_pszString = NULL;
   468 	}
   469 }
   470 
   471 
   472 //-----------------------------------------------------------------------------
   473 // Install a change callback (there shouldn't already be one....)
   474 //-----------------------------------------------------------------------------
   475 
   476 void ConVar::InstallChangeCallback( FnChangeCallback callback )
   477 {
   478 	Assert( !m_fnChangeCallback || !callback );
   479 	m_fnChangeCallback = callback;
   480 
   481 	if (m_fnChangeCallback)
   482 	{
   483 		// Call it immediately to set the initial value...
   484 		m_fnChangeCallback( this, m_pszString );
   485 	}
   486 }
   487 
   488 bool ConVar::IsBitSet( int flag ) const
   489 {
   490 	return ( flag & m_pParent->m_nFlags ) ? true : false;
   491 }
   492 
   493 char const *ConVar::GetHelpText( void ) const
   494 {
   495 	return m_pParent->m_pszHelpString;
   496 }
   497 
   498 void ConVar::AddFlags( int flags )
   499 {
   500 	m_pParent->m_nFlags |= flags;
   501 }
   502 
   503 bool ConVar::IsRegistered( void ) const
   504 {
   505 	return m_pParent->m_bRegistered;
   506 }
   507 
   508 char const *ConVar::GetName( void ) const
   509 {
   510 	return m_pParent->m_pszName;
   511 }
   512 
   513 //-----------------------------------------------------------------------------
   514 // Purpose: 
   515 // Output : Returns true on success, false on failure.
   516 //-----------------------------------------------------------------------------
   517 bool ConVar::IsCommand( void ) const
   518 { 
   519 	return false;
   520 }
   521 
   522 //-----------------------------------------------------------------------------
   523 // Purpose: 
   524 // Input  : 
   525 //-----------------------------------------------------------------------------
   526 void ConVar::Init()
   527 {
   528 	BaseClass::Init();
   529 }
   530 
   531 //-----------------------------------------------------------------------------
   532 // Purpose: 
   533 // Input  : *value - 
   534 //-----------------------------------------------------------------------------
   535 void ConVar::InternalSetValue( char const *value )
   536 {
   537 	float fNewValue;
   538 	char  tempVal[ 32 ];
   539 	char  *val;
   540 
   541 	Assert(m_pParent == this); // Only valid for root convars.
   542 
   543 	val = (char *)value;
   544 	fNewValue = ( float )atof( value );
   545 
   546 	if ( ClampValue( fNewValue ) )
   547 	{
   548 		Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
   549 		val = tempVal;
   550 	}
   551 	
   552 	// Redetermine value
   553 	m_fValue		= fNewValue;
   554 	m_nValue		= ( int )( m_fValue );
   555 
   556 	if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
   557 		ChangeStringValue( val );
   558 }
   559 
   560 //-----------------------------------------------------------------------------
   561 // Purpose: 
   562 // Input  : *tempVal - 
   563 //-----------------------------------------------------------------------------
   564 void ConVar::ChangeStringValue( char const *tempVal )
   565 {
   566 	Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
   567 
   568 	char* pszOldValue = (char*)stackalloc( m_StringLength );
   569 
   570 	if ( m_fnChangeCallback )
   571 	{
   572 		memcpy( pszOldValue, m_pszString, m_StringLength );
   573 	}
   574 	
   575 	int len = Q_strlen(tempVal) + 1;
   576 
   577 	if ( len > m_StringLength)
   578 	{
   579 		if (m_pszString)
   580 			delete[] m_pszString;
   581 
   582 		m_pszString	= new char[len];
   583 		m_StringLength = len;
   584 	}
   585 
   586 	memcpy( m_pszString, tempVal, len );
   587 
   588 	// Invoke any necessary callback function
   589 	if ( m_fnChangeCallback )
   590 	{
   591 		m_fnChangeCallback( this, pszOldValue );
   592 	}
   593 
   594 	stackfree( pszOldValue );
   595 }
   596 
   597 //-----------------------------------------------------------------------------
   598 // Purpose: Check whether to clamp and then perform clamp
   599 // Input  : value - 
   600 // Output : Returns true if value changed
   601 //-----------------------------------------------------------------------------
   602 bool ConVar::ClampValue( float& value )
   603 {
   604 	if ( m_bHasMin && ( value < m_fMinVal ) )
   605 	{
   606 		value = m_fMinVal;
   607 		return true;
   608 	}
   609 	
   610 	if ( m_bHasMax && ( value > m_fMaxVal ) )
   611 	{
   612 		value = m_fMaxVal;
   613 		return true;
   614 	}
   615 
   616 	return false;
   617 }
   618 
   619 //-----------------------------------------------------------------------------
   620 // Purpose: 
   621 // Input  : *value - 
   622 //-----------------------------------------------------------------------------
   623 void ConVar::InternalSetFloatValue( float fNewValue )
   624 {
   625 	if ( fNewValue == m_fValue )
   626 		return;
   627 
   628 	Assert( m_pParent == this ); // Only valid for root convars.
   629 
   630 	// Check bounds
   631 	ClampValue( fNewValue );
   632 
   633 	// Redetermine value
   634 	m_fValue		= fNewValue;
   635 	m_nValue		= ( int )m_fValue;
   636 
   637 	if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
   638 	{
   639 		char tempVal[ 32 ];
   640 		Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
   641 		ChangeStringValue( tempVal );
   642 	}
   643 	else
   644 	{
   645 		Assert( !m_fnChangeCallback );
   646 	}
   647 }
   648 
   649 //-----------------------------------------------------------------------------
   650 // Purpose: 
   651 // Input  : *value - 
   652 //-----------------------------------------------------------------------------
   653 void ConVar::InternalSetIntValue( int nValue )
   654 {
   655 	if ( nValue == m_nValue )
   656 		return;
   657 
   658 	Assert( m_pParent == this ); // Only valid for root convars.
   659 
   660 	float fValue = (float)nValue;
   661 	if ( ClampValue( fValue ) )
   662 	{
   663 		nValue = ( int )( fValue );
   664 	}
   665 
   666 	// Redetermine value
   667 	m_fValue		= fValue;
   668 	m_nValue		= nValue;
   669 
   670 	if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
   671 	{
   672 		char tempVal[ 32 ];
   673 		Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
   674 		ChangeStringValue( tempVal );
   675 	}
   676 	else
   677 	{
   678 		Assert( !m_fnChangeCallback );
   679 	}
   680 }
   681 
   682 //-----------------------------------------------------------------------------
   683 // Purpose: Private creation
   684 //-----------------------------------------------------------------------------
   685 void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
   686 	char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
   687 	bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
   688 {
   689 	static char *empty_string = "";
   690 
   691 	m_pParent = this;
   692 
   693 	// Name should be static data
   694 	m_pszDefaultValue	= pDefaultValue ? pDefaultValue : empty_string;
   695 	Assert( pDefaultValue );
   696 
   697 	m_StringLength = strlen( m_pszDefaultValue ) + 1;
   698 	m_pszString = new char[m_StringLength];
   699 	memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
   700 	
   701 	m_bHasMin = bMin;
   702 	m_fMinVal = fMin;
   703 	m_bHasMax = bMax;
   704 	m_fMaxVal = fMax;
   705 	
   706 	m_fnChangeCallback = callback;
   707 
   708 	m_fValue = ( float )atof( m_pszString );
   709 
   710 	// Bounds Check, should never happen, if it does, no big deal
   711 	if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
   712 	{
   713 		Assert( 0 );
   714 	}
   715 
   716 	if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
   717 	{
   718 		Assert( 0 );
   719 	}
   720 
   721 	m_nValue = ( int )m_fValue;
   722 
   723 	BaseClass::Create( pName, pHelpString, flags );
   724 }
   725 
   726 //-----------------------------------------------------------------------------
   727 // Purpose: 
   728 // Input  : *value - 
   729 //-----------------------------------------------------------------------------
   730 void ConVar::SetValue(char const *value)
   731 {
   732 	ConVar *var = ( ConVar * )m_pParent;
   733 	var->InternalSetValue( value );
   734 }
   735 
   736 //-----------------------------------------------------------------------------
   737 // Purpose: 
   738 // Input  : value - 
   739 //-----------------------------------------------------------------------------
   740 void ConVar::SetValue( float value )
   741 {
   742 	ConVar *var = ( ConVar * )m_pParent;
   743 	var->InternalSetFloatValue( value );
   744 }
   745 
   746 //-----------------------------------------------------------------------------
   747 // Purpose: 
   748 // Input  : value - 
   749 //-----------------------------------------------------------------------------
   750 void ConVar::SetValue( int value )
   751 {
   752 	ConVar *var = ( ConVar * )m_pParent;
   753 	var->InternalSetIntValue( value );
   754 }
   755 
   756 //-----------------------------------------------------------------------------
   757 // Purpose: Reset to default value
   758 //-----------------------------------------------------------------------------
   759 void ConVar::Revert( void )
   760 {
   761 	// Force default value again
   762 	ConVar *var = ( ConVar * )m_pParent;
   763 	var->SetValue( var->m_pszDefaultValue );
   764 }
   765 
   766 //-----------------------------------------------------------------------------
   767 // Purpose: 
   768 //-----------------------------------------------------------------------------
   769 void ConVar::RevertAll( void )
   770 {
   771 	ConCommandBase *p = s_pConCommandBases;
   772 	while ( p  )
   773 	{
   774 		if ( !p->IsCommand() )
   775 		{
   776 			ConVar *var = ( ConVar * )p;
   777 			var->Revert();
   778 		}
   779 		p = p->m_pNext;
   780 	}
   781 }
   782 
   783 //-----------------------------------------------------------------------------
   784 // Purpose: 
   785 // Input  : minVal - 
   786 // Output : true if there is a min set
   787 //-----------------------------------------------------------------------------
   788 bool ConVar::GetMin( float& minVal ) const
   789 {
   790 	minVal = m_pParent->m_fMinVal;
   791 	return m_pParent->m_bHasMin;
   792 }
   793 
   794 //-----------------------------------------------------------------------------
   795 // Purpose: 
   796 // Input  : maxVal - 
   797 //-----------------------------------------------------------------------------
   798 bool ConVar::GetMax( float& maxVal ) const
   799 {
   800 	maxVal = m_pParent->m_fMaxVal;
   801 	return m_pParent->m_bHasMax;
   802 }
   803 
   804 //-----------------------------------------------------------------------------
   805 // Purpose: 
   806 // Output : char const
   807 //-----------------------------------------------------------------------------
   808 char const *ConVar::GetDefault( void ) const
   809 {
   810 	return m_pParent->m_pszDefaultValue;
   811 }
   812