source-engine/vgui2/src/Scheme.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//


#include <stdio.h>
#include <math.h>

#include <vgui/VGUI.h>
#include <vgui/IScheme.h>
#include <KeyValues.h>
#include <vgui/ISurface.h>
#include <vgui/IPanel.h>
#include <vgui/ISystem.h>
#include <vstdlib/IKeyValuesSystem.h>
#include <vgui/IVGui.h>

#include "tier1/utlvector.h"
#include "tier1/utlrbtree.h"
#include "tier1/utldict.h"
#include "VGUI_Border.h"
#include "ScalableImageBorder.h"
#include "ImageBorder.h"
#include "vgui_internal.h"
#include "bitmap.h"
#include "filesystem.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

using namespace vgui;
#define FONT_ALIAS_NAME_LENGTH 64

//-----------------------------------------------------------------------------
// Purpose: Implementation of global scheme interface
//-----------------------------------------------------------------------------
class CScheme : public IScheme
{
public:
	CScheme();

	// gets a string from the default settings section
	virtual const char *GetResourceString(const char *stringName);

	// returns a pointer to an existing border
	virtual IBorder *GetBorder(const char *borderName);

	// returns a pointer to an existing font
	virtual HFont GetFont(const char *fontName, bool proportional);

	// m_pkvColors
	virtual Color GetColor( const char *colorName, Color defaultColor);


	void Shutdown( bool full );
	void LoadFromFile( VPANEL sizingPanel, const char *filename, const char *tag, KeyValues *inKeys );

	// Gets at the scheme's name
	const char *GetName() { return tag; }
	const char *GetFileName() { return fileName; }

	char const *GetFontName( const HFont& font );

	void ReloadFontGlyphs();

	VPANEL		GetSizingPanel() { return m_SizingPanel; }

	void SpewFonts();

	bool GetFontRange( const char *fontname, int &nMin, int &nMax );
	void SetFontRange( const char *fontname, int nMin, int nMax );
	
	// Get the number of borders
	virtual int GetBorderCount() const;

	// Get the border at the given index
	virtual IBorder *GetBorderAtIndex( int iIndex );

	// Get the number of fonts
	virtual int GetFontCount() const;

	// Get the font at the given index
	virtual HFont GetFontAtIndex( int iIndex );
	
	// Get color data
	virtual const KeyValues *GetColorData() const;

private:
	const char *LookupSchemeSetting(const char *pchSetting);
	const char *GetMungedFontName( const char *fontName, const char *scheme, bool proportional);
	void LoadFonts();
	void LoadBorders();
	HFont FindFontInAliasList( const char *fontName );
	int GetMinimumFontHeightForCurrentLanguage();

	char fileName[256];
	char tag[64];

	KeyValues *m_pData;
	KeyValues *m_pkvBaseSettings;
	KeyValues *m_pkvColors;
	int		   m_nColorCount;

	struct SchemeBorder_t
	{
		IBorder *border;
		int borderSymbol;
		bool bSharedBorder;
	};
	CUtlVector<SchemeBorder_t> m_BorderList;
	IBorder  *m_pBaseBorder;	// default border to use if others not found
	KeyValues *m_pkvBorders;
#pragma pack(1)
	struct fontalias_t
	{
		CUtlSymbol _trueFontName;
		unsigned short _font : 15;
		unsigned short m_bProportional : 1;
	};
#pragma pack()
	friend struct fontalias_t;

	CUtlDict< fontalias_t, int >	m_FontAliases;
	VPANEL m_SizingPanel;
	int			m_nScreenWide;
	int			m_nScreenTall;

	struct fontrange_t
	{
		int _min;
		int _max;
	};
	CUtlDict< fontrange_t, int >	m_FontRanges;
};


//-----------------------------------------------------------------------------
// Purpose: Implementation of global scheme interface
//-----------------------------------------------------------------------------
class CSchemeManager : public ISchemeManager
{
public:
	CSchemeManager();
	~CSchemeManager();

	// loads a scheme from a file
	// first scheme loaded becomes the default scheme, and all subsequent loaded scheme are derivitives of that
	// tag is friendly string representing the name of the loaded scheme
	virtual HScheme LoadSchemeFromFile(const char *fileName, const char *tag);
	// first scheme loaded becomes the default scheme, and all subsequent loaded scheme are derivitives of that
	virtual HScheme LoadSchemeFromFileEx( VPANEL sizingPanel, const char *fileName, const char *tag);

	// reloads the schemes from the file
	virtual void ReloadSchemes();
	virtual void ReloadFonts();

	// returns a handle to the default (first loaded) scheme
	virtual HScheme GetDefaultScheme();

	// returns a handle to the scheme identified by "tag"
	virtual HScheme GetScheme(const char *tag);

	// returns a pointer to an image
	virtual IImage *GetImage(const char *imageName, bool hardwareFiltered);
	virtual HTexture GetImageID(const char *imageName, bool hardwareFiltered);

	virtual IScheme *GetIScheme( HScheme scheme );

	virtual void Shutdown( bool full );

	// gets the proportional coordinates for doing screen-size independant panel layouts
	// use these for font, image and panel size scaling (they all use the pixel height of the display for scaling)
	virtual int GetProportionalScaledValue(int normalizedValue);
	virtual int GetProportionalNormalizedValue(int scaledValue);

	// gets the proportional coordinates for doing screen-size independant panel layouts
	// use these for font, image and panel size scaling (they all use the pixel height of the display for scaling)
	virtual int GetProportionalScaledValueEx( HScheme scheme, int normalizedValue );
	virtual int GetProportionalNormalizedValueEx( HScheme scheme, int scaledValue );

	virtual bool DeleteImage( const char *pImageName );

	// gets the proportional coordinates for doing screen-size independant panel layouts
	// use these for font, image and panel size scaling (they all use the pixel height of the display for scaling)
	int GetProportionalScaledValueEx( CScheme *pScheme, int normalizedValue );
	int GetProportionalNormalizedValueEx( CScheme *pScheme, int scaledValue );

	void SpewFonts();

private:

	int GetProportionalScaledValue_( int rootWide, int rootTall, int normalizedValue );
	int GetProportionalNormalizedValue_( int rootWide, int rootTall, int scaledValue );

	// Search for already-loaded schemes
	HScheme FindLoadedScheme(const char *fileName);

	CUtlVector<CScheme *> m_Schemes;

	static const char *s_pszSearchString;
	struct CachedBitmapHandle_t
	{
		Bitmap *pBitmap;
	};
	static bool BitmapHandleSearchFunc(const CachedBitmapHandle_t &, const CachedBitmapHandle_t &);
	CUtlRBTree<CachedBitmapHandle_t, int> m_Bitmaps;
};

const char *CSchemeManager::s_pszSearchString = NULL;

//-----------------------------------------------------------------------------
// Purpose: search function for stored bitmaps
//-----------------------------------------------------------------------------
bool CSchemeManager::BitmapHandleSearchFunc(const CachedBitmapHandle_t &lhs, const CachedBitmapHandle_t &rhs)
{
	// a NULL bitmap indicates to use the search string instead
	if (lhs.pBitmap && rhs.pBitmap)
	{
		return stricmp(lhs.pBitmap->GetName(), rhs.pBitmap->GetName()) > 0;
	}
	else if (lhs.pBitmap)
	{
		return stricmp(lhs.pBitmap->GetName(), s_pszSearchString) > 0;
	}
	return stricmp(s_pszSearchString, rhs.pBitmap->GetName()) > 0;
}



CSchemeManager g_Scheme;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CSchemeManager, ISchemeManager, VGUI_SCHEME_INTERFACE_VERSION, g_Scheme);


namespace vgui
{
vgui::ISchemeManager *g_pScheme = &g_Scheme;
} // namespace vgui

CON_COMMAND( vgui_spew_fonts, "" )
{
	g_Scheme.SpewFonts();
}
 
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CSchemeManager::CSchemeManager()
{
	// 0th element is null, since that would be an invalid handle
	CScheme *nullScheme = new CScheme();
	m_Schemes.AddToTail(nullScheme);
	m_Bitmaps.SetLessFunc(&BitmapHandleSearchFunc);
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CSchemeManager::~CSchemeManager()
{
	int i;
	for ( i = 0; i < m_Schemes.Count(); i++ )
	{
		delete m_Schemes[i];
	}
	m_Schemes.RemoveAll();

	for ( i = 0; i < m_Bitmaps.MaxElement(); i++ )
	{
		if (m_Bitmaps.IsValidIndex(i))
		{
			delete m_Bitmaps[i].pBitmap;
		}
	}
	m_Bitmaps.RemoveAll();

	Shutdown( false );
}

//-----------------------------------------------------------------------------
// Purpose: Reload the fonts in all schemes
//-----------------------------------------------------------------------------
void CSchemeManager::ReloadFonts()
{
	for (int i = 1; i < m_Schemes.Count(); i++)
	{
		m_Schemes[i]->ReloadFontGlyphs();
	}
}

//-----------------------------------------------------------------------------
// Converts the handle into an interface
//-----------------------------------------------------------------------------
IScheme *CSchemeManager::GetIScheme( HScheme scheme )
{
	if ( scheme >= (unsigned long)m_Schemes.Count() )
	{
		AssertOnce( !"Invalid scheme requested." );
		return NULL;
	}
	else
	{
		return m_Schemes[scheme];
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CSchemeManager::Shutdown( bool full )
{
	// Full shutdown kills the null scheme
	for( int i = full ? 0 : 1; i < m_Schemes.Count(); i++ )
	{
		m_Schemes[i]->Shutdown( full );
	}

	if ( full )
	{
		m_Schemes.RemoveAll();
	}
}

//-----------------------------------------------------------------------------
// Purpose: loads a scheme from disk
//-----------------------------------------------------------------------------
HScheme CSchemeManager::FindLoadedScheme(const char *fileName)
{
	// Find the scheme in the list of already loaded schemes
	for (int i = 1; i < m_Schemes.Count(); i++)
	{
		char const *schemeFileName = m_Schemes[i]->GetFileName();
		if (!stricmp(schemeFileName, fileName))
			return i;
	}

	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CScheme::CScheme()
{
	fileName[ 0 ] = 0;
	tag[ 0 ] = 0;

	m_pData = NULL;
	m_pkvBaseSettings = NULL;
	m_pkvColors = NULL;
	m_nColorCount = 0;

	m_pBaseBorder = NULL;	// default border to use if others not found
	m_pkvBorders = NULL;
	m_SizingPanel = 0;
	m_nScreenWide = -1;
	m_nScreenTall = -1;
}

// first scheme loaded becomes the default scheme, and all subsequent loaded scheme are derivitives of that
HScheme  CSchemeManager::LoadSchemeFromFileEx( VPANEL sizingPanel, const char *fileName, const char *tag)
{
	// Look to see if we've already got this scheme...
	HScheme hScheme = FindLoadedScheme(fileName);
	if (hScheme != 0)
	{
		CScheme *pScheme = static_cast< CScheme * >( GetIScheme( hScheme ) );
		if ( IsPC() && pScheme )
		{
			pScheme->ReloadFontGlyphs();
		}
		return hScheme;
	}

	KeyValues *data;
	data = new KeyValues("Scheme");

	data->UsesEscapeSequences( true );	// VGUI uses this
	
	// Look first in game directory
	bool result = data->LoadFromFile( g_pFullFileSystem, fileName, "GAME" );
	if ( !result )
	{
		// look in any directory
		result = data->LoadFromFile( g_pFullFileSystem, fileName, NULL );
	}

	if (!result)
	{
		data->deleteThis();
		return 0;
	}
	
	if ( IsX360() )
	{
		data->ProcessResolutionKeys( g_pSurface->GetResolutionKey() );
	}
	if ( IsPC() )
	{
		ConVarRef cl_hud_minmode( "cl_hud_minmode", true );
		if ( cl_hud_minmode.IsValid() && cl_hud_minmode.GetBool() )
		{
			data->ProcessResolutionKeys( "_minmode" );
		}
	}
	if( g_pIVgui->GetVRMode() )
	{
		data->ProcessResolutionKeys( "_vrmode" );
	}

	CScheme *newScheme = new CScheme();
	newScheme->LoadFromFile( sizingPanel, fileName, tag, data );

	return m_Schemes.AddToTail(newScheme);
}

//-----------------------------------------------------------------------------
// Purpose: loads a scheme from disk
//-----------------------------------------------------------------------------
HScheme CSchemeManager::LoadSchemeFromFile(const char *fileName, const char *tag)
{
	return LoadSchemeFromFileEx( 0, fileName, tag );
}

//-----------------------------------------------------------------------------
// Purpose: Table of scheme file entries, translation from old goldsrc schemes to new src schemes
//-----------------------------------------------------------------------------
struct SchemeEntryTranslation_t
{
	const char *pchNewEntry;
	const char *pchOldEntry;
	const char *pchDefaultValue;
};
SchemeEntryTranslation_t g_SchemeTranslation[] =
{
	{ "Border.Bright",					"BorderBright",		"200 200 200 196" },	// the lit side of a control
	{ "Border.Dark"						"BorderDark",		"40 40 40 196" },		// the dark/unlit side of a control
	{ "Border.Selection"				"BorderSelection",	"0 0 0 196" },			// the additional border color for displaying the default/selected button

	{ "Button.TextColor",				"ControlFG",		"White" },
	{ "Button.BgColor",					"ControlBG",		"Blank" },
	{ "Button.ArmedTextColor",			"ControlFG" },
	{ "Button.ArmedBgColor",			"ControlBG" },
	{ "Button.DepressedTextColor",		"ControlFG" },
	{ "Button.DepressedBgColor",		"ControlBG" },
	{ "Button.FocusBorderColor",		"0 0 0 255" },

	{ "CheckButton.TextColor",			"BaseText" },
	{ "CheckButton.SelectedTextColor",	"BrightControlText" },
	{ "CheckButton.BgColor",			"CheckBgColor" },
	{ "CheckButton.Border1",  			"CheckButtonBorder1" },
	{ "CheckButton.Border2",  			"CheckButtonBorder2" },
	{ "CheckButton.Check",				"CheckButtonCheck" },

	{ "ComboBoxButton.ArrowColor",		"LabelDimText" },
	{ "ComboBoxButton.ArmedArrowColor",	"MenuButton/ArmedArrowColor" },
	{ "ComboBoxButton.BgColor",			"MenuButton/ButtonBgColor" },
	{ "ComboBoxButton.DisabledBgColor",	"ControlBG" },

	{ "Frame.TitleTextInsetX",			NULL,		"32" },
	{ "Frame.ClientInsetX",				NULL,		"8" },
	{ "Frame.ClientInsetY",				NULL,		"6" },
	{ "Frame.BgColor",					"BgColor" },
	{ "Frame.OutOfFocusBgColor",		"BgColor" },
	{ "Frame.FocusTransitionEffectTime",NULL,		"0" },
	{ "Frame.TransitionEffectTime",		NULL,		"0" },
	{ "Frame.AutoSnapRange",			NULL,		"8" },
	{ "FrameGrip.Color1",				"BorderBright" },
	{ "FrameGrip.Color2",				"BorderSelection" },
	{ "FrameTitleButton.FgColor",		"TitleButtonFgColor" },
	{ "FrameTitleButton.BgColor",		"TitleButtonBgColor" },
	{ "FrameTitleButton.DisabledFgColor",	"TitleButtonDisabledFgColor" },
	{ "FrameTitleButton.DisabledBgColor",	"TitleButtonDisabledBgColor" },
	{ "FrameSystemButton.FgColor",		"TitleBarBgColor" },
	{ "FrameSystemButton.BgColor",		"TitleBarBgColor" },
	{ "FrameSystemButton.Icon",			"TitleBarIcon" },
	{ "FrameSystemButton.DisabledIcon",	"TitleBarDisabledIcon" },
	{ "FrameTitleBar.Font",				NULL,		"Default" },
	{ "FrameTitleBar.TextColor",		"TitleBarFgColor" },
	{ "FrameTitleBar.BgColor",			"TitleBarBgColor" },
	{ "FrameTitleBar.DisabledTextColor","TitleBarDisabledFgColor" },
	{ "FrameTitleBar.DisabledBgColor",	"TitleBarDisabledBgColor" },

	{ "GraphPanel.FgColor",				"BrightControlText" },
	{ "GraphPanel.BgColor",				"WindowBgColor" },

	{ "Label.TextDullColor",			"LabelDimText" },
	{ "Label.TextColor",				"BaseText" },
	{ "Label.TextBrightColor",			"BrightControlText" },
	{ "Label.SelectedTextColor",		"BrightControlText" },
	{ "Label.BgColor",					"LabelBgColor" },
	{ "Label.DisabledFgColor1",			"DisabledFgColor1" },
	{ "Label.DisabledFgColor2",			"DisabledFgColor2" },

	{ "ListPanel.TextColor",				"WindowFgColor" },
	{ "ListPanel.TextBgColor",				"Menu/ArmedBgColor" },
	{ "ListPanel.BgColor",					"ListBgColor" },
	{ "ListPanel.SelectedTextColor",		"ListSelectionFgColor" },
	{ "ListPanel.SelectedBgColor",			"Menu/ArmedBgColor" },
	{ "ListPanel.SelectedOutOfFocusBgColor","SelectionBG2" },
	{ "ListPanel.EmptyListInfoTextColor",	"LabelDimText" },
	{ "ListPanel.DisabledTextColor",		"LabelDimText" },
	{ "ListPanel.DisabledSelectedTextColor","ListBgColor" },

	{ "Menu.TextColor",					"Menu/FgColor" },
	{ "Menu.BgColor",					"Menu/BgColor" },
	{ "Menu.ArmedTextColor",			"Menu/ArmedFgColor" },
	{ "Menu.ArmedBgColor",				"Menu/ArmedBgColor" },
	{ "Menu.TextInset",					NULL,		"6" },

	{ "Panel.FgColor",					"FgColor" },
	{ "Panel.BgColor",					"BgColor" },

	{ "ProgressBar.FgColor",				"BrightControlText" },
	{ "ProgressBar.BgColor",				"WindowBgColor" },

	{ "PropertySheet.TextColor",			"FgColorDim" },
	{ "PropertySheet.SelectedTextColor",	"BrightControlText" },
	{ "PropertySheet.TransitionEffectTime",	NULL,		"0" },

	{ "RadioButton.TextColor",			"FgColor" },
	{ "RadioButton.SelectedTextColor",	"BrightControlText" },

	{ "RichText.TextColor",				"WindowFgColor" },
	{ "RichText.BgColor",				"WindowBgColor" },
	{ "RichText.SelectedTextColor",		"SelectionFgColor" },
	{ "RichText.SelectedBgColor",		"SelectionBgColor" },

	{ "ScrollBar.Wide",					NULL,		"19" },

	{ "ScrollBarButton.FgColor",			"DimBaseText" },
	{ "ScrollBarButton.BgColor",			"ControlBG" },
	{ "ScrollBarButton.ArmedFgColor",		"BaseText" },
	{ "ScrollBarButton.ArmedBgColor",		"ControlBG" },
	{ "ScrollBarButton.DepressedFgColor",	"BaseText" },
	{ "ScrollBarButton.DepressedBgColor",	"ControlBG" },

	{ "ScrollBarSlider.FgColor",				"ScrollBarSlider/ScrollBarSliderFgColor" },
	{ "ScrollBarSlider.BgColor",				"ScrollBarSlider/ScrollBarSliderBgColor" },

	{ "SectionedListPanel.HeaderTextColor",	"SectionTextColor" },
	{ "SectionedListPanel.HeaderBgColor",	"BuddyListBgColor" },
	{ "SectionedListPanel.DividerColor",	"SectionDividerColor" },
	{ "SectionedListPanel.TextColor",		"BuddyButton/FgColor1" },
	{ "SectionedListPanel.BrightTextColor",	"BuddyButton/ArmedFgColor1" },
	{ "SectionedListPanel.BgColor",			"BuddyListBgColor" },
	{ "SectionedListPanel.SelectedTextColor",			"BuddyButton/ArmedFgColor1" },
	{ "SectionedListPanel.SelectedBgColor",				"BuddyButton/ArmedBgColor" },
	{ "SectionedListPanel.OutOfFocusSelectedTextColor",	"BuddyButton/ArmedFgColor2" },
	{ "SectionedListPanel.OutOfFocusSelectedBgColor",	"SelectionBG2" },

	{ "Slider.NobColor",			"SliderTickColor" },
	{ "Slider.TextColor",			"Slider/SliderFgColor" },
	{ "Slider.TrackColor",			"SliderTrackColor"},
	{ "Slider.DisabledTextColor1",	"DisabledFgColor1" },
	{ "Slider.DisabledTextColor2",	"DisabledFgColor2" },

	{ "TextEntry.TextColor",		"WindowFgColor" },
	{ "TextEntry.BgColor",			"WindowBgColor" },
	{ "TextEntry.CursorColor",		"TextCursorColor" },
	{ "TextEntry.DisabledTextColor","WindowDisabledFgColor" },
	{ "TextEntry.DisabledBgColor",	"ControlBG" },
	{ "TextEntry.SelectedTextColor","SelectionFgColor" },
	{ "TextEntry.SelectedBgColor",	"SelectionBgColor" },
	{ "TextEntry.OutOfFocusSelectedBgColor",	"SelectionBG2" },
	{ "TextEntry.FocusEdgeColor",	"BorderSelection" },

	{ "ToggleButton.SelectedTextColor",	"BrightControlText" },

	{ "Tooltip.TextColor",			"BorderSelection" },
	{ "Tooltip.BgColor",			"SelectionBG" },

	{ "TreeView.BgColor",			"ListBgColor" },

	{ "WizardSubPanel.BgColor",		"SubPanelBgColor" },
};

//-----------------------------------------------------------------------------
// Purpose: loads a scheme from from disk into memory
//-----------------------------------------------------------------------------
void CScheme::LoadFromFile( VPANEL sizingPanel, const char *inFilename, const char *inTag, KeyValues *inKeys )
{
	COM_TimestampedLog( "CScheme::LoadFromFile( %s )", inFilename );

	Q_strncpy(fileName, inFilename, sizeof(fileName) );
	
	m_SizingPanel = sizingPanel;

	m_pData = inKeys;
	m_pkvBaseSettings = m_pData->FindKey("BaseSettings", true);
	m_pkvColors = m_pData->FindKey("Colors", true);

	// override the scheme name with the tag name
	KeyValues *name = m_pData->FindKey("Name", true);
	name->SetString("Name", inTag);

	if ( inTag )
	{
		Q_strncpy( tag, inTag, sizeof( tag ) );
	}
	else
	{
		Assert( "You need to name the scheme!" );
		Q_strncpy( tag, "default", sizeof( tag ) );
	}

	// translate format from goldsrc scheme to new scheme
	for (int i = 0; i < ARRAYSIZE(g_SchemeTranslation); i++)
	{
		if (!m_pkvBaseSettings->FindKey(g_SchemeTranslation[i].pchNewEntry, false))
		{
			const char *pchColor;

			if (g_SchemeTranslation[i].pchOldEntry)
			{
				pchColor = LookupSchemeSetting(g_SchemeTranslation[i].pchOldEntry);
			}
			else
			{
				pchColor = g_SchemeTranslation[i].pchDefaultValue;
			}

			Assert( pchColor );

			m_pkvBaseSettings->SetString(g_SchemeTranslation[i].pchNewEntry, pchColor);
		}
	}

	// need to copy tag before loading fonts
	LoadFonts();
	LoadBorders();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CScheme::GetFontRange( const char *fontname, int &nMin, int &nMax )
{
	int i = m_FontRanges.Find( fontname );
	if ( i != m_FontRanges.InvalidIndex() )
	{
		nMin = m_FontRanges[i]._min;
		nMax = m_FontRanges[i]._max;
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScheme::SetFontRange( const char *fontname, int nMin, int nMax )
{
	int i = m_FontRanges.Find( fontname );
	if ( i != m_FontRanges.InvalidIndex() )
	{
		m_FontRanges[i]._min = nMin;
		m_FontRanges[i]._max = nMax;
		return;
	}

	// not already in our list
	int iNew = m_FontRanges.Insert( fontname );
	
	m_FontRanges[iNew]._min = nMin;
	m_FontRanges[iNew]._max = nMax;
}

//-----------------------------------------------------------------------------
// Purpose: adds all the font specifications to the surface
//-----------------------------------------------------------------------------
void CScheme::LoadFonts()
{
	bool bValid = false;
	char language[64];
	memset( language, 0, sizeof( language ) );

	// get our language
	if ( IsPC() )
	{
		bValid = vgui::g_pSystem->GetRegistryString( "HKEY_CURRENT_USER\\Software\\Valve\\Source\\Language", language, sizeof( language ) - 1 );
	}
	else
	{
		Q_strncpy( language, XBX_GetLanguageString(), sizeof( language ) );
		bValid = true;
	}

	if ( !bValid )
	{
		Q_strncpy( language, "english", sizeof( language ) );
	}

	// add our custom fonts
	for (KeyValues *kv = m_pData->FindKey("CustomFontFiles", true)->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
	{
		const char *fontFile = kv->GetString();
		if (fontFile && *fontFile)
		{
			g_pSurface->AddCustomFontFile( NULL, fontFile );
		}
		else
		{
			// we have a block to read
			int nRangeMin = 0, nRangeMax = 0;
			const char *pszName = NULL;
			bool bUseRange = false;

			for ( KeyValues *pData = kv->GetFirstSubKey(); pData != NULL; pData = pData->GetNextKey() )
			{
				const char *pszKey = pData->GetName();
				if ( !Q_stricmp( pszKey, "font" ) )
				{
					fontFile = pData->GetString();
				}
				else if ( !Q_stricmp( pszKey, "name" ) )
				{
					pszName = pData->GetString();
				}
				else
				{
					// we must have a language
					if ( Q_stricmp( language, pszKey ) == 0 ) // matches the language we're running?
					{
						// get the range
						KeyValues *pRange = pData->FindKey( "range" );
						if ( pRange )
						{
							bUseRange = true;
							sscanf( pRange->GetString(), "%x %x", &nRangeMin, &nRangeMax );

							if ( nRangeMin > nRangeMax )
							{
								int nTemp = nRangeMin;
								nRangeMin = nRangeMax;
								nRangeMax = nTemp;
							}
						}
					}
				}
			}

			if ( fontFile && *fontFile )
			{
				g_pSurface->AddCustomFontFile( pszName, fontFile );

				if ( bUseRange )
				{
					SetFontRange( pszName, nRangeMin, nRangeMax );
				}
			}
		}
	}

	// add bitmap fonts
	for (KeyValues *kv = m_pData->FindKey("BitmapFontFiles", true)->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
	{
		const char *fontFile = kv->GetString();
		if (fontFile && *fontFile)
		{
			bool bSuccess = g_pSurface->AddBitmapFontFile( fontFile );
			if ( bSuccess )
			{
				// refer to the font by a user specified symbol
				g_pSurface->SetBitmapFontName( kv->GetName(), fontFile );
			}
		}
	}

	// create the fonts
	for (KeyValues *kv = m_pData->FindKey("Fonts", true)->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
	{
		for ( int i = 0; i < 2; i++ )
		{
			// create the base font
			bool proportionalFont = static_cast<bool>( i );
			const char *fontName = GetMungedFontName( kv->GetName(), tag, proportionalFont ); // first time it adds a normal font, and then a proportional one
			HFont font = g_pSurface->CreateFont();

			int j = m_FontAliases.Insert( fontName );
			m_FontAliases[j]._trueFontName = kv->GetName();
			m_FontAliases[j]._font = font;
			m_FontAliases[j].m_bProportional = proportionalFont;
		}
	}

	// load in the font glyphs
	ReloadFontGlyphs();
}

//-----------------------------------------------------------------------------
// Purpose: Reloads all scheme fonts
//-----------------------------------------------------------------------------
void CScheme::ReloadFontGlyphs()
{
	COM_TimestampedLog( "ReloadFontGlyphs(): Start" );

	// get our current resolution
	if ( m_SizingPanel != 0 )
	{
		g_pIPanel->GetSize( m_SizingPanel, m_nScreenWide, m_nScreenTall );
	}
	else
	{
		g_pSurface->GetScreenSize( m_nScreenWide, m_nScreenTall );
	}

	// check our language; some have minimum sizes
	int minimumFontHeight = GetMinimumFontHeightForCurrentLanguage();

	// add the data to all the fonts
	KeyValues *fonts = m_pData->FindKey("Fonts", true);
	FOR_EACH_DICT_FAST( m_FontAliases, i )
	{
		KeyValues *kv = fonts->FindKey( m_FontAliases[i]._trueFontName.String(), true );
	
		// walk through creating adding the first matching glyph set to the font
		for (KeyValues *fontdata = kv->GetFirstSubKey(); fontdata != NULL; fontdata = fontdata->GetNextKey())
		{
			// skip over fonts not meant for this resolution
			int fontYResMin = 0, fontYResMax = 0;
			sscanf(fontdata->GetString("yres", ""), "%d %d", &fontYResMin, &fontYResMax);
			if (fontYResMin)
			{
				if (!fontYResMax)
				{
					fontYResMax = fontYResMin;
				}
				// check the range
				if (m_nScreenTall < fontYResMin || m_nScreenTall > fontYResMax)
					continue;
			}

			int flags = 0;
			if (fontdata->GetInt( "italic" ))
			{
				flags |= ISurface::FONTFLAG_ITALIC;
			}
			if (fontdata->GetInt( "underline" ))
			{
				flags |= ISurface::FONTFLAG_UNDERLINE;
			}
			if (fontdata->GetInt( "strikeout" ))
			{
				flags |= ISurface::FONTFLAG_STRIKEOUT;
			}
			if (fontdata->GetInt( "symbol" ))
			{
				flags |= ISurface::FONTFLAG_SYMBOL;
			}
			if (fontdata->GetInt( "antialias" ) && g_pSurface->SupportsFeature(ISurface::ANTIALIASED_FONTS))
			{
				flags |= ISurface::FONTFLAG_ANTIALIAS;
			}
			if (fontdata->GetInt( "dropshadow" ) && g_pSurface->SupportsFeature(ISurface::DROPSHADOW_FONTS))
			{
				flags |= ISurface::FONTFLAG_DROPSHADOW;
			}
			if (fontdata->GetInt( "outline" ) && g_pSurface->SupportsFeature(ISurface::OUTLINE_FONTS))
			{
				flags |= ISurface::FONTFLAG_OUTLINE;
			}
			if (fontdata->GetInt( "custom" ))
			{
				flags |= ISurface::FONTFLAG_CUSTOM;
			}
			if (fontdata->GetInt( "bitmap" ))
			{
				flags |= ISurface::FONTFLAG_BITMAP;
			}
			if (fontdata->GetInt( "rotary" ))
			{
				flags |= ISurface::FONTFLAG_ROTARY;
			}
			if (fontdata->GetInt( "additive" ))
			{
				flags |= ISurface::FONTFLAG_ADDITIVE;
			}

			int tall = fontdata->GetInt( "tall" );
			int blur = fontdata->GetInt( "blur" );
			int scanlines = fontdata->GetInt( "scanlines" );
			float scalex = fontdata->GetFloat( "scalex", 1.0f );
			float scaley = fontdata->GetFloat( "scaley", 1.0f );

			// only grow this font if it doesn't have a resolution filter specified
			if ( ( !fontYResMin && !fontYResMax ) && m_FontAliases[i].m_bProportional )
			{
				tall = g_Scheme.GetProportionalScaledValueEx( this, tall );
				blur = g_Scheme.GetProportionalScaledValueEx( this, blur );
				scanlines = g_Scheme.GetProportionalScaledValueEx( this, scanlines ); 
				scalex = g_Scheme.GetProportionalScaledValueEx( this, scalex * 10000.0f ) * 0.0001f;
				scaley = g_Scheme.GetProportionalScaledValueEx( this, scaley * 10000.0f ) * 0.0001f;
			}

			// clip the font size so that fonts can't be too big
			if ( tall > 127 )
			{
				tall = 127;
			}

			// check our minimum font height
			if ( tall < minimumFontHeight )
			{
				tall = minimumFontHeight;
			}
			
			if ( flags & ISurface::FONTFLAG_BITMAP )
			{
				// add the new set
				g_pSurface->SetBitmapFontGlyphSet(
					m_FontAliases[i]._font,
					g_pSurface->GetBitmapFontName( fontdata->GetString( "name" ) ), 
					scalex,
					scaley,
					flags);
			}
			else
			{
				int nRangeMin, nRangeMax;

				if ( GetFontRange( fontdata->GetString( "name" ), nRangeMin, nRangeMax ) )
				{
					// add the new set
					g_pSurface->SetFontGlyphSet(
						m_FontAliases[i]._font,
						fontdata->GetString( "name" ), 
						tall, 
						fontdata->GetInt( "weight" ), 
						blur,
						scanlines,
						flags,
						nRangeMin,
						nRangeMax);					
				}
				else
				{
					// add the new set
					g_pSurface->SetFontGlyphSet(
						m_FontAliases[i]._font,
						fontdata->GetString( "name" ), 
						tall, 
						fontdata->GetInt( "weight" ), 
						blur,
						scanlines,
						flags);
				}
			}

			// don't add any more
			break;
		}
	}

	COM_TimestampedLog( "ReloadFontGlyphs(): End" );
}

//-----------------------------------------------------------------------------
// Purpose: create the Border objects from the scheme data
//-----------------------------------------------------------------------------
void CScheme::LoadBorders()
{
	m_pkvBorders = m_pData->FindKey("Borders", true);
	{for ( KeyValues *kv = m_pkvBorders->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
	{
		if (kv->GetDataType() == KeyValues::TYPE_STRING)
		{
			// it's referencing another border, ignore for now
		}
		else
		{
			int i = m_BorderList.AddToTail();

			IBorder *border = NULL;
			const char *pszBorderType = kv->GetString( "bordertype", NULL );
			if ( pszBorderType && pszBorderType[0] )
			{
				if ( !stricmp(pszBorderType,"image") )
				{
					border = new ImageBorder();
				}
				else if ( !stricmp(pszBorderType,"scalable_image") )
				{
					border = new ScalableImageBorder();
				}
				else
				{
					Assert(0);
					// Fall back to the base border type. See below.
					pszBorderType = NULL;
				}
			}

			if ( !pszBorderType || !pszBorderType[0] )
			{
				border = new Border();
			}

			border->SetName(kv->GetName());
			border->ApplySchemeSettings(this, kv);

			m_BorderList[i].border = border;
			m_BorderList[i].bSharedBorder = false;
			m_BorderList[i].borderSymbol = kv->GetNameSymbol();
		}
	}}

	// iterate again to get the border references
	for ( KeyValues *kv = m_pkvBorders->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
	{
		if (kv->GetDataType() == KeyValues::TYPE_STRING)
		{
			// it's referencing another border, find it
			Border *border = (Border *)GetBorder(kv->GetString());
//			const char *str = kv->GetName();
			Assert(border);

			// add an entry that just references the existing border
			int i = m_BorderList.AddToTail();
			m_BorderList[i].border = border;
			m_BorderList[i].bSharedBorder = true;
			m_BorderList[i].borderSymbol = kv->GetNameSymbol();
		}
	}
	
	m_pBaseBorder = GetBorder("BaseBorder");
}

void CScheme::SpewFonts( void )
{
	Msg( "Scheme: %s (%s)\n", GetName(), GetFileName() );
	FOR_EACH_DICT_FAST( m_FontAliases, i )
	{
		const fontalias_t& FontAlias = m_FontAliases[ i ];
		uint32 Font = FontAlias._font;
		const char *szFontName = g_pSurface->GetFontName( Font );
		const char *szFontFamilyName = g_pSurface->GetFontFamilyName( Font );
		const char *szTrueFontName = FontAlias._trueFontName.String();
		const char *szFontAlias = m_FontAliases.GetElementName( i );

		Msg( "  %2d: HFont:0x%8.8x, %s, %s, font:%s, tall:%d(%d). %s\n", 
			i, 
			Font,
			szTrueFontName ? szTrueFontName : "??", 
			szFontAlias ? szFontAlias : "??",
			szFontName ? szFontName : "??", 
			g_pSurface->GetFontTall( Font ),
			g_pSurface->GetFontTallRequested( Font ),
			szFontFamilyName ? szFontFamilyName : "" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: reloads the scheme from the file
//-----------------------------------------------------------------------------
void CSchemeManager::ReloadSchemes()
{
	int count = m_Schemes.Count();
	Shutdown( false );
	
	// reload the scheme
	for (int i = 1; i < count; i++)
	{
		LoadSchemeFromFile(m_Schemes[i]->GetFileName(), m_Schemes[i]->GetName());
	}
}

//-----------------------------------------------------------------------------
// Purpose: kills all the schemes
//-----------------------------------------------------------------------------
void CScheme::Shutdown( bool full )
{
	for (int i = 0; i < m_BorderList.Count(); i++)
	{
		// delete if it's not shared
		if (!m_BorderList[i].bSharedBorder)
		{
			IBorder *border = m_BorderList[i].border;
			delete border;
		}
	}

	m_pBaseBorder = NULL;
	m_BorderList.RemoveAll();
	m_pkvBorders = NULL;

	if (full && m_pData)
	{
		m_pData->deleteThis();
		m_pData = NULL;
		delete this;
	}
}

//-----------------------------------------------------------------------------
// Purpose: returns a handle to the default (first loaded) scheme
//-----------------------------------------------------------------------------
HScheme CSchemeManager::GetDefaultScheme()
{
	return 1;
}

//-----------------------------------------------------------------------------
// Purpose: returns a handle to the scheme identified by "tag"
//-----------------------------------------------------------------------------
HScheme CSchemeManager::GetScheme(const char *tag)
{
	for (int i=1;i<m_Schemes.Count();i++)
	{
		if ( !stricmp(tag,m_Schemes[i]->GetName()) )
		{
			return i;
		}
	}
	return 1; // default scheme
}

int CSchemeManager::GetProportionalScaledValue_( int rootWide, int rootTall, int normalizedValue )
{
	int proH, proW;
	g_pSurface->GetProportionalBase( proW, proH );
	double scale = (double)rootTall / (double)proH;

	return (int)( normalizedValue * scale );
}

int CSchemeManager::GetProportionalNormalizedValue_( int rootWide, int rootTall, int scaledValue )
{
	int proH, proW;
	g_pSurface->GetProportionalBase( proW, proH );
	float scale = (float)rootTall / (float)proH;

	return (int)( scaledValue / scale );
}

//-----------------------------------------------------------------------------
// Purpose: converts a value into proportional mode
//-----------------------------------------------------------------------------
int CSchemeManager::GetProportionalScaledValue(int normalizedValue)
{
	int wide, tall;
	g_pSurface->GetScreenSize( wide, tall );
	return GetProportionalScaledValue_( wide, tall, normalizedValue );
}

//-----------------------------------------------------------------------------
// Purpose: converts a value out of proportional mode
//-----------------------------------------------------------------------------
int CSchemeManager::GetProportionalNormalizedValue(int scaledValue)
{
	int wide, tall;
	g_pSurface->GetScreenSize( wide, tall );
	return GetProportionalNormalizedValue_( wide, tall, scaledValue );
}

// gets the proportional coordinates for doing screen-size independant panel layouts
// use these for font, image and panel size scaling (they all use the pixel height of the display for scaling)
int CSchemeManager::GetProportionalScaledValueEx( CScheme *pScheme, int normalizedValue )
{
	VPANEL sizing = pScheme->GetSizingPanel();
	if ( !sizing )
	{
		return GetProportionalScaledValue( normalizedValue );
	}

	int w, h;
	g_pIPanel->GetSize( sizing, w, h );
	return GetProportionalScaledValue_( w, h, normalizedValue );
}

int CSchemeManager::GetProportionalNormalizedValueEx( CScheme *pScheme, int scaledValue )
{
	VPANEL sizing = pScheme->GetSizingPanel();
	if ( !sizing )
	{
		return GetProportionalNormalizedValue( scaledValue );
	}

	int w, h;
	g_pIPanel->GetSize( sizing, w, h );
	return GetProportionalNormalizedValue_( w, h, scaledValue );
}

int CSchemeManager::GetProportionalScaledValueEx( HScheme scheme, int normalizedValue )
{
	IScheme *pscheme = GetIScheme( scheme );
	if ( !pscheme )
	{
		Assert( 0 );
		return GetProportionalScaledValue( normalizedValue );
	}

	CScheme *p = static_cast< CScheme * >( pscheme );
	return GetProportionalScaledValueEx( p, normalizedValue );
}

int CSchemeManager::GetProportionalNormalizedValueEx( HScheme scheme, int scaledValue )
{
	IScheme *pscheme = GetIScheme( scheme );
	if ( !pscheme )
	{
		Assert( 0 );
		return GetProportionalNormalizedValue( scaledValue );
	}

	CScheme *p = static_cast< CScheme * >( pscheme );
	return GetProportionalNormalizedValueEx( p, scaledValue );
}

void CSchemeManager::SpewFonts( void )
{
	for ( int i = 1; i < m_Schemes.Count(); i++ )
	{
		m_Schemes[i]->SpewFonts();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CScheme::GetResourceString(const char *stringName)
{
	return m_pkvBaseSettings->GetString(stringName);
}

//-----------------------------------------------------------------------------
// Purpose: returns a pointer to an image
//-----------------------------------------------------------------------------
IImage *CSchemeManager::GetImage(const char *imageName, bool hardwareFiltered)
{
	if ( !imageName || strlen(imageName) <= 0 ) // frame icons and the like are in the scheme file and may not be defined, so if this is null then fail silently
	{
		return NULL; 
	}

	// set up to search for the bitmap
	CachedBitmapHandle_t searchBitmap;
	searchBitmap.pBitmap = NULL;

	// Prepend 'vgui/'. Resource files try to load images assuming they live in the vgui directory.
	// Used to do this in Bitmap::Bitmap, moved so that the s_pszSearchString is searching for the
	// filename with 'vgui/' already added.
	char szFileName[MAX_PATH];

	//if ( Q_IsAbsolutePath(imageName) )
	//{
	//	Q_strncpy( szFileName, imageName, sizeof(szFileName) );
	//}
	//else
	{
		if ( Q_stristr( imageName, ".pic" ) )
		{
			Q_snprintf( szFileName, sizeof(szFileName), "%s", imageName );
		}
		else
		{
			Q_snprintf( szFileName, sizeof(szFileName), "vgui/%s", imageName );
		}
	}

	s_pszSearchString = szFileName;
	int i = m_Bitmaps.Find( searchBitmap );
	if (m_Bitmaps.IsValidIndex( i ) )
	{
		return m_Bitmaps[i].pBitmap;
	}

	// couldn't find the image, try and load it
	CachedBitmapHandle_t hBitmap = { new Bitmap( szFileName, hardwareFiltered ) };
	m_Bitmaps.Insert( hBitmap );
	return hBitmap.pBitmap;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
HTexture CSchemeManager::GetImageID(const char *imageName, bool hardwareFiltered)
{
	IImage *img = GetImage(imageName, hardwareFiltered);
	return ((Bitmap *)img)->GetID();
}

//-----------------------------------------------------------------------------
// Delete a managed image
//-----------------------------------------------------------------------------
bool CSchemeManager::DeleteImage( const char *pImageName )
{
	if ( !pImageName )
	{
		// nothing to do
		return false;
	}

	// set up to search for the bitmap
	CachedBitmapHandle_t searchBitmap;
	searchBitmap.pBitmap = NULL;

	// Prepend 'vgui/'. Resource files try to load images assuming they live in the vgui directory.
	// Used to do this in Bitmap::Bitmap, moved so that the s_pszSearchString is searching for the
	// filename with 'vgui/' already added.
	char szFileName[256];
	if ( Q_stristr( pImageName, ".pic" ) )
	{
		Q_snprintf( szFileName, sizeof(szFileName), "%s", pImageName );
	}
	else
	{
		Q_snprintf( szFileName, sizeof(szFileName), "vgui/%s", pImageName );
	}
	s_pszSearchString = szFileName;

	int i = m_Bitmaps.Find( searchBitmap );
	if ( !m_Bitmaps.IsValidIndex( i ) )
	{
		// not found
		return false;
	}
		
	// no way to know if eviction occured, assume it does
	m_Bitmaps[i].pBitmap->Evict();
	delete  m_Bitmaps[i].pBitmap;	
	m_Bitmaps.RemoveAt( i );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: returns a pointer to an existing border
//-----------------------------------------------------------------------------
IBorder *CScheme::GetBorder(const char *borderName)
{
	int symbol = KeyValuesSystem()->GetSymbolForString(borderName);
	for (int i = 0; i < m_BorderList.Count(); i++)
	{
		if (m_BorderList[i].borderSymbol == symbol)
		{
			return m_BorderList[i].border;
		}
	}

	return m_pBaseBorder;
}

//-----------------------------------------------------------------------------
// Purpose: Get the number of borders
//-----------------------------------------------------------------------------
int CScheme::GetBorderCount() const
{
	return m_BorderList.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Get the border at the given index
//-----------------------------------------------------------------------------
IBorder *CScheme::GetBorderAtIndex( int iIndex )
{
	if ( !m_BorderList.IsValidIndex( iIndex ) )
		return NULL;

	return m_BorderList[ iIndex ].border;
}

//-----------------------------------------------------------------------------
// Finds a font in the alias list
//-----------------------------------------------------------------------------
HFont CScheme::FindFontInAliasList( const char *fontName )
{
	int i = m_FontAliases.Find( fontName );
	if ( i != m_FontAliases.InvalidIndex() )
	{
		return m_FontAliases[i]._font;
	}

	// No dice
	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : font - 
// Output : char const
//-----------------------------------------------------------------------------
char const *CScheme::GetFontName( const HFont& font )
{
	for (int i = m_FontAliases.Count(); --i >= 0; )
	{
		HFont fnt = (HFont)m_FontAliases[i]._font;
		if ( fnt == font )
			return m_FontAliases[i]._trueFontName.String();
	}

	return "<Unknown font>";
}

//-----------------------------------------------------------------------------
// Purpose: returns a pointer to an existing font, proportional=false means use default
//-----------------------------------------------------------------------------
HFont CScheme::GetFont( const char *fontName, bool proportional )
{
	// First look in the list of aliases...
	return FindFontInAliasList( GetMungedFontName( fontName, tag, proportional ) );
}

//-----------------------------------------------------------------------------
// Purpose:Get the number of fonts
//-----------------------------------------------------------------------------
int CScheme::GetFontCount() const
{
	return m_FontAliases.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Get the font at the given index
//-----------------------------------------------------------------------------
HFont CScheme::GetFontAtIndex( int iIndex )
{
	if ( !m_FontAliases.IsValidIndex( iIndex ) )
		return INVALID_FONT;
	
	return m_FontAliases[ iIndex ]._font;
}

//-----------------------------------------------------------------------------
// Purpose: returns a char string of the munged name this font is stored as in the font manager
//-----------------------------------------------------------------------------
const char *CScheme::GetMungedFontName( const char *fontName, const char *scheme, bool proportional )
{
	static char mungeBuffer[ 64 ];
	if ( scheme )
	{
		Q_snprintf( mungeBuffer, sizeof( mungeBuffer ), "%s%s-%s", fontName, scheme, proportional ? "p" : "no" );
	}
	else
	{ 
		Q_snprintf( mungeBuffer, sizeof( mungeBuffer ), "%s-%s", fontName, proportional ? "p" : "no" ); // we don't want the "(null)" snprintf appends
	}
	return mungeBuffer;
}

//-----------------------------------------------------------------------------
// Purpose: Gets a color from the scheme file
//-----------------------------------------------------------------------------
Color CScheme::GetColor(const char *colorName, Color defaultColor)
{
	const char *pchT = LookupSchemeSetting(colorName);
	if (!pchT)
		return defaultColor;

	int r = 0, g = 0, b = 0, a = 0;
	if (sscanf(pchT, "%d %d %d %d", &r, &g, &b, &a) >= 3)
		return Color(r, g, b, a);

	return defaultColor;
}

//-----------------------------------------------------------------------------
// Purpose: Get the color at the given index
//-----------------------------------------------------------------------------
const KeyValues *CScheme::GetColorData() const
{
	return m_pkvColors;
}

//-----------------------------------------------------------------------------
// Purpose: recursively looks up a setting
//-----------------------------------------------------------------------------
const char *CScheme::LookupSchemeSetting(const char *pchSetting)
{
	// try parse out the color
	int r, g, b, a = 0;
	int res = sscanf(pchSetting, "%d %d %d %d", &r, &g, &b, &a);
	if (res >= 3)
	{
		return pchSetting;
	}

	// check the color area first
	const char *colStr = m_pkvColors->GetString(pchSetting, NULL);
	if (colStr)
		return colStr;

	// check base settings
	colStr = m_pkvBaseSettings->GetString(pchSetting, NULL);
	if (colStr)
	{
		return LookupSchemeSetting(colStr);
	}

	return pchSetting;
}

//-----------------------------------------------------------------------------
// Purpose: gets the minimum font height for the current language
//-----------------------------------------------------------------------------
int CScheme::GetMinimumFontHeightForCurrentLanguage()
{
	char language[64];
	bool bValid;
	if ( IsPC() )
	{
		bValid = vgui::g_pSystem->GetRegistryString( "HKEY_CURRENT_USER\\Software\\Valve\\Source\\Language", language, sizeof(language)-1 );
	}
	else
	{
		Q_strncpy( language, XBX_GetLanguageString(), sizeof( language ) );
		bValid = true;
	}

	if ( bValid )
	{
		if (!stricmp(language, "korean")
			|| !stricmp(language, "tchinese")
			|| !stricmp(language, "schinese")
			|| !stricmp(language, "japanese"))
		{
			// the bitmap-based fonts for these languages simply don't work with a pt. size of less than 9 (13 pixels)
			return 13;
		}

		if ( !stricmp(language, "thai" ) )
		{
			// thai has problems below 18 pts
			return 18;
		}
	}

	// no special minimum height required
	return 0;
}