// Copyright (C) 2007 Id Software, Inc.
//


#include "../precompiled.h"
#pragma hdrstop

#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "UserInterfaceLocal.h"
#include "UserInterfaceExpressions.h"
#include "UserInterfaceManagerLocal.h"
#include "UIWindow.h"

#include "../../sys/sys_local.h"

using namespace sdProperties;

idCVar sdUserInterfaceLocal::g_debugGUIEvents( "g_debugGUIEvents", "0", CVAR_GAME | CVAR_INTEGER, "Show the results of events" );
idCVar sdUserInterfaceLocal::g_debugGUI( "g_debugGUI", "0", CVAR_GAME | CVAR_INTEGER, "1 - Show GUI window outlines\n2 - Show GUI window names\n3 - Only show visible windows" );
idCVar sdUserInterfaceLocal::g_debugGUITextRect( "g_debugGUITextRect", "0", CVAR_GAME | CVAR_BOOL, "Show windows' text rectangle outlines" );
idCVar sdUserInterfaceLocal::g_debugGUITextScale( "g_debugGUITextScale", "24", CVAR_GAME | CVAR_FLOAT, "Size that the debug GUI info font is drawn in." );
idCVar sdUserInterfaceLocal::s_volumeMusic_dB( "s_volumeMusic_dB", "0", CVAR_GAME | CVAR_SOUND | CVAR_ARCHIVE | CVAR_FLOAT, "music volume in dB" );

#ifdef SD_PUBLIC_BETA_BUILD
idCVar sdUserInterfaceLocal::g_skipIntro( "g_skipIntro", "1", CVAR_GAME | CVAR_BOOL | CVAR_ROM, "skip the opening intro movie" );
#else
idCVar sdUserInterfaceLocal::g_skipIntro( "g_skipIntro", "0", CVAR_GAME | CVAR_BOOL | CVAR_ARCHIVE | CVAR_PROFILE, "skip the opening intro movie" );
#endif

// Crosshair
idCVar sdUserInterfaceLocal::gui_crosshairDef( "gui_crosshairDef", "crosshairs", CVAR_GAME | CVAR_ARCHIVE | CVAR_PROFILE, "name of def containing crosshair" );
idCVar sdUserInterfaceLocal::gui_crosshairKey( "gui_crosshairKey", "pin_01", CVAR_GAME | CVAR_ARCHIVE | CVAR_PROFILE, "name of crosshair key in def specified by gui_crosshairDef" );
idCVar sdUserInterfaceLocal::gui_crosshairAlpha( "gui_crosshairAlpha", "0.5", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of crosshair" );
idCVar sdUserInterfaceLocal::gui_crosshairSpreadAlpha( "gui_crosshairSpreadAlpha", "0.5", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of spread components" );
idCVar sdUserInterfaceLocal::gui_crosshairStatsAlpha( "gui_crosshairStatsAlpha", "0", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of health/ammo/reload components" );
idCVar sdUserInterfaceLocal::gui_crosshairGrenadeAlpha( "gui_crosshairGrenadeAlpha", "0.5", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of grenade timer components" );
idCVar sdUserInterfaceLocal::gui_crosshairSpreadScale( "gui_crosshairSpreadScale", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "amount to scale the spread indicator movement" );
idCVar sdUserInterfaceLocal::gui_crosshairColor( "gui_crosshairColor", "1 1 1 1", CVAR_GAME | CVAR_ARCHIVE | CVAR_PROFILE, "RGB color tint for crosshair elements" );

// HUD
idCVar sdUserInterfaceLocal::gui_chatAlpha( "gui_chatAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of chat text" );
idCVar sdUserInterfaceLocal::gui_fireTeamAlpha( "gui_fireTeamAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of fireteam list" );
idCVar sdUserInterfaceLocal::gui_commandMapAlpha( "gui_commandMapAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of command map" );
idCVar sdUserInterfaceLocal::gui_objectiveListAlpha( "gui_objectiveListAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of objective list" );
idCVar sdUserInterfaceLocal::gui_personalBestsAlpha( "gui_personalBestsAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of personal bests display list" );
idCVar sdUserInterfaceLocal::gui_objectiveStatusAlpha( "gui_objectiveStatusAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of objective status" );
idCVar sdUserInterfaceLocal::gui_obitAlpha( "gui_obitAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of obituaries" );
idCVar sdUserInterfaceLocal::gui_voteAlpha( "gui_voteAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of vote" );
idCVar sdUserInterfaceLocal::gui_tooltipAlpha( "gui_tooltipAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of tooltips" );
idCVar sdUserInterfaceLocal::gui_vehicleAlpha( "gui_vehicleAlpha", "1", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of vehicle information" );
idCVar sdUserInterfaceLocal::gui_vehicleDirectionAlpha( "gui_vehicleDirectionAlpha", "0.5", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha of vehicle direction indicators" );
idCVar sdUserInterfaceLocal::gui_showRespawnText( "gui_showRespawnText", "1", CVAR_GAME | CVAR_BOOL | CVAR_ARCHIVE | CVAR_PROFILE, "show text about respawning when in limbo or dead" );

idCVar sdUserInterfaceLocal::gui_tooltipDelay( "gui_tooltipDelay", "0.7", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "Delay in seconds before tooltips pop up." );
idCVar sdUserInterfaceLocal::gui_doubleClickTime( "gui_doubleClickTime", "0.2", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "Delay in seconds between considering two mouse clicks a double-click" );

idStrList sdUserInterfaceLocal::parseStack;
const int sdUserInterfaceLocal::TOOLTIP_MOVE_TOLERANCE = 2;

idBlockAlloc< uiCachedMaterial_t, 64 > sdUserInterfaceLocal::materialCacheAllocator;

const char* sdUserInterfaceLocal::partNames[ FP_MAX ] = {
	"tl",
	"t",
	"tr",
	"l",
	"r",
	"bl",
	"b",
	"br",
	"c",
};


/*
===============================================================================

	sdPropertyBinder

===============================================================================
*/

/*
================
sdPropertyBinder::ClearPropertyExpression
================
*/
void sdPropertyBinder::ClearPropertyExpression( int propertyKey, int propertyIndex ) {
	boundProperty_t& bp = indexedProperties[ propertyKey ];
	int index = bp.second + propertyIndex;	

	if ( !propertyExpressions[ index ] ) {
		return;
	}

	int count = sdProperties::CountForPropertyType( propertyExpressions[ index ]->GetType() );
	int i;
	for ( i = 0; i < count; i++ ) {
		if ( !propertyExpressions[ index + i ] ) {
			continue;
		}

		propertyExpressions[ index + i ]->Detach();
		propertyExpressions[ index + i ] = NULL;
	}
}

/*
================
sdPropertyBinder::Clear
================
*/
void sdPropertyBinder::Clear( void ) {
	indexedProperties.Clear();
	propertyExpressions.Clear();
}

/*
================
sdPropertyBinder::IndexForProperty
================
*/
int sdPropertyBinder::IndexForProperty( sdProperties::sdProperty* property ) {
	int i;
	for ( i = 0; i < indexedProperties.Num(); i++ ) {
		if ( indexedProperties[ i ].first == property ) {
			return i;
		}
	}

	boundProperty_t& bp = indexedProperties.Alloc();
	bp.first = property;
	bp.second = propertyExpressions.Num();

	int count = CountForPropertyType( property->GetValueType() );
	if ( count == -1 ) {
		gameLocal.Error( "sdPropertyBinder::IndexForProperty Property has Invalid Field Count" );
	}
	for ( i = 0; i < count; i++ ) {
		propertyExpressions.Append( NULL );
	}
		
	return indexedProperties.Num() - 1;
}

/*
================
sdPropertyBinder::SetPropertyExpression
================
*/
void sdPropertyBinder::SetPropertyExpression( int propertyKey, int propertyIndex, sdUIExpression* expression, sdUserInterfaceScope* scope ) {
	boundProperty_t& bp = indexedProperties[ propertyKey ];
	int index = bp.second + propertyIndex;

	int count = sdProperties::CountForPropertyType( expression->GetType() );
	int i;
	for ( i = 0; i < count; i++ ) {
		if ( propertyExpressions[ index + i ] ) {
			propertyExpressions[ index + i ]->Detach();
			propertyExpressions[ index + i ] = NULL;
		}
	}

	propertyExpressions[ index ] = expression;
	propertyExpressions[ index ]->SetProperty( bp.first, propertyIndex, propertyKey, scope );
}

/*
===============================================================================

	sdUserInterfaceState

===============================================================================
*/

/*
================
sdUserInterfaceState::~sdUserInterfaceState
================
*/
sdUserInterfaceState::~sdUserInterfaceState( void ) {
	for ( int i = 0; i < expressions.Num(); i++ ) {
		expressions[ i ]->Free();
	}
	expressions.Clear();
}

/*
============
sdUserInterfaceState::GetName
============
*/
const char* sdUserInterfaceState::GetName() const {
	return ui->GetName();
}

/*
============
sdUserInterfaceState::GetSubScope
============
*/
sdUserInterfaceScope* sdUserInterfaceState::GetSubScope( const char* name ) {
	if ( !idStr::Icmp( name, "module" ) ) {
		return ( ui->GetModule() != NULL ) ? ui->GetModule()->GetScope() : NULL;
	}

	if( !idStr::Icmp( name, "gui" ) ) {
		return this;
	}

	if( !idStr::Icmp( name, "timeline" ) ) {
		return ui->GetTimelineManager();
	}

	sdUIObject* window = ui->GetWindow( name );
	if ( window ) {
		return &window->GetScope();
	}

	return NULL;
}

/*
================
sdUserInterfaceState::GetProperty
================
*/
sdProperties::sdProperty* sdUserInterfaceState::GetProperty( const char* name ) {
	return properties.GetProperty( name, PT_INVALID, false );
}

/*
============
sdUserInterfaceState::GetProperty
============
*/
sdProperties::sdProperty* sdUserInterfaceState::GetProperty( const char* name, sdProperties::ePropertyType type ) {
	sdProperties::sdProperty* prop = properties.GetProperty( name, PT_INVALID, false );
	if ( prop && prop->GetValueType() != type && type != PT_INVALID ) {
		gameLocal.Error( "sdUserInterfaceState::GetProperty: type mismatch for property '%s'", name );
	}
	return prop;
}

/*
================
sdUserInterfaceState::SetPropertyExpression
================
*/
void sdUserInterfaceState::SetPropertyExpression( int propertyKey, int propertyIndex, sdUIExpression* expression ) {
	boundProperties.SetPropertyExpression( propertyKey, propertyIndex, expression, this );
}

/*
================
sdUserInterfaceState::ClearPropertyExpression
================
*/
void sdUserInterfaceState::ClearPropertyExpression( int propertyKey, int propertyIndex ) {
	boundProperties.ClearPropertyExpression( propertyKey, propertyIndex );
}

/*
================
sdUserInterfaceState::RunFunction
================
*/
void sdUserInterfaceState::RunFunction( int expressionIndex ) {
	expressions[ expressionIndex ]->Evaluate();
}

/*
================
sdUserInterfaceState::IndexForProperty
================
*/
int sdUserInterfaceState::IndexForProperty( sdProperties::sdProperty* property ) {
	return boundProperties.IndexForProperty( property );
}


/*
============
sdUserInterfaceState::GetEvent
============
*/
sdUIEventHandle sdUserInterfaceState::GetEvent( const sdUIEventInfo& info ) const {
	return ui->GetEvent( info );
}

/*
============
sdUserInterfaceState::AddEvent
============
*/
void sdUserInterfaceState::AddEvent( const sdUIEventInfo& info, sdUIEventHandle scriptHandle ) {
	ui->AddEvent( info, scriptHandle );
}

/*
============
sdUserInterfaceState::ClearExpressions
============
*/
void sdUserInterfaceState::ClearExpressions() {
	for ( int i = 0; i < expressions.Num(); i++ ) {
		expressions[ i ]->Free();
	}
	expressions.Clear();
}

/*
============
sdUserInterfaceState::Clear
============
*/
void sdUserInterfaceState::Clear() {
	properties.Clear();
	transitionExpressions.Clear();
	boundProperties.Clear();
}

/*
============
sdUserInterfaceState::GetFunction
============
*/
sdUIFunctionInstance* sdUserInterfaceState::GetFunction( const char* name ) {
	return ui->GetFunction( name );
}

/*
============
sdUserInterfaceState::RunNamedFunction
============
*/
bool sdUserInterfaceState::RunNamedFunction( const char* name, sdUIFunctionStack& stack ) {
	const sdUserInterfaceLocal::uiFunction_t* func = sdUserInterfaceLocal::FindFunction( name );
	if ( !func ) {
		return false;
	}

	CALL_MEMBER_FN_PTR( ui, func->GetFunction() )( stack );
	return true;
}

/*
============
sdUserInterfaceState::FindPropertyName
============
*/
const char* sdUserInterfaceState::FindPropertyName( sdProperties::sdProperty* property, sdUserInterfaceScope*& scope ) {
	scope = this;

	const char* name = properties.NameForProperty( property );
	if ( name != NULL ) {
		return name;
	}

	for ( int i = 0 ; i < ui->GetNumWindows(); i++ ) {
		sdUIObject* obj = ui->GetWindow( i );
		name = obj->GetScope().FindPropertyName( property, scope );
		if ( name != NULL ) {
			return name;
		}
	}

	return NULL;
}

/*
============
sdUserInterfaceState::GetEvaluator
============
*/
sdUIEvaluatorTypeBase* sdUserInterfaceState::GetEvaluator( const char* name ) {
	return GetUI()->GetEvaluator( name );
}

/*
============
sdUserInterfaceState::Update
============
*/
void sdUserInterfaceState::Update( void ) {
	int i;
	for ( i = 0; i < transitionExpressions.Num(); ) {
		sdUIExpression* expression = transitionExpressions[ i ];
		
		if ( !expression->UpdateValue() ) {
			transitionExpressions.RemoveIndex( i );
		} else {
			i++;
		}
	}
}

/*
================
sdUserInterfaceState::AddTransition
================
*/
void sdUserInterfaceState::AddTransition( sdUIExpression* expression ) {
	transitionExpressions.AddUnique( expression );
}

/*
================
sdUserInterfaceState::RemoveTransition
================
*/
void sdUserInterfaceState::RemoveTransition( sdUIExpression* expression ) {
	transitionExpressions.Remove( expression );
}


/*
============
sdUserInterfaceState::OnSnapshotHitch
============
*/
void sdUserInterfaceState::OnSnapshotHitch( int delta ) {
	for( int i = 0; i < transitionExpressions.Num(); i++ ) {
		transitionExpressions[ i ]->OnSnapshotHitch( delta );
	}
}

/*
===============================================================================

	sdUserInterfaceLocal

===============================================================================
*/

idHashMap< sdUserInterfaceLocal::uiFunction_t* >	sdUserInterfaceLocal::uiFunctions;
idList< sdUIEvaluatorTypeBase* >					sdUserInterfaceLocal::uiEvaluators;

SD_UI_PUSH_CLASS_TAG( sdUserInterfaceLocal )
const char* sdUserInterfaceLocal::eventNames[ GE_NUM_EVENTS ] = {
	SD_UI_EVENT_TAG( "onCreate",			"",					"Called on window creation" ),
	SD_UI_EVENT_TAG( "onActivate",			"",					"This happens when the GUI is activated." ),
	SD_UI_EVENT_TAG( "onDeactivate",		"",					"This happens when the GUI is activated." ),
	SD_UI_EVENT_TAG( "onNamedEvent",		"[Event ...]",		"Called when one of the events specified occurs" ),
	SD_UI_EVENT_TAG( "onPropertyChanged",	"[Property ...]",	"Called when one of the properties specified occurs" ),
	SD_UI_EVENT_TAG( "onCVarChanged",		"[CVar ...]",		"Called when one of the CVars' value changes" ),
	SD_UI_EVENT_TAG( "onCancel",			"",					"Called when any key bound to the _menuCancel is pressed" ),
	SD_UI_EVENT_TAG( "onCancel",			"",					"Called when any key bound to the _menuCancel is pressed" ),
	SD_UI_EVENT_TAG( "onToolTipEvent",		"",					"Called when a tooltip event occurs" ),
};
SD_UI_POP_CLASS_TAG

/*
================
sdUserInterfaceLocal::sdUserInterfaceLocal
================
*/
sdUserInterfaceLocal::sdUserInterfaceLocal( int _spawnId, bool _isUnique, bool _isPermanent, sdHudModule* _module ) :
	spawnId( _spawnId ),
	desktop( NULL ),
	focusedWindow( NULL ),
	entity( NULL ),
	guiTime( 0.0f ){

	guiDecl				= NULL;
	theme				= NULL;
	module				= _module;
	bindContext			= NULL;

	shaderParms.SetNum( MAX_ENTITY_SHADER_PARMS - 4 );
	for( int i = 0 ; i < shaderParms.Num(); i++ ) {
		shaderParms[ i ] = 0.0f;
	}

	flags.isActive		= false;
	flags.isUnique		= _isUnique;
	flags.isPermanent	= _isPermanent;		
	flags.shouldUpdate	= true;

	currentTime = 0;

	scriptState.Init( this );	

	UI_ADD_STR_CALLBACK( cursorMaterialName, sdUserInterfaceLocal, OnCursorMaterialNameChanged )
	UI_ADD_STR_CALLBACK( postProcessMaterialName,sdUserInterfaceLocal, OnPostProcessMaterialNameChanged )
	UI_ADD_STR_CALLBACK( focusedWindowName, sdUserInterfaceLocal, OnFocusedWindowNameChanged )
	UI_ADD_STR_CALLBACK( screenSaverName, sdUserInterfaceLocal, OnScreenSaverMaterialNameChanged )	
	UI_ADD_STR_CALLBACK( themeName, sdUserInterfaceLocal, OnThemeNameChanged )	
	UI_ADD_STR_CALLBACK( bindContextName, sdUserInterfaceLocal, OnBindContextChanged )
	UI_ADD_VEC2_CALLBACK( screenDimensions, sdUserInterfaceLocal, OnScreenDimensionChanged )
	
	postProcessMaterial = NULL;
	screenSaverMaterial = NULL;

	lastMouseMoveTime = 0;
	nextAllowToolTipTime = 0;

	generalStacks.SetGranularity( 1 );
}

/*
============
sdUserInterfaceLocal::Init
============
*/
void sdUserInterfaceLocal::Init() {
	scriptState.GetPropertyHandler().RegisterProperty( "cursorMaterial", cursorMaterialName );
	scriptState.GetPropertyHandler().RegisterProperty( "cursorSize", cursorSize );
	scriptState.GetPropertyHandler().RegisterProperty( "cursorColor", cursorColor );
	scriptState.GetPropertyHandler().RegisterProperty( "cursorPos", cursorPos );
	scriptState.GetPropertyHandler().RegisterProperty( "postProcessMaterial", postProcessMaterialName );
	scriptState.GetPropertyHandler().RegisterProperty( "focusedWindow", focusedWindowName );
	scriptState.GetPropertyHandler().RegisterProperty( "screenDimensions", screenDimensions );
	scriptState.GetPropertyHandler().RegisterProperty( "screenCenter", screenCenter );
	scriptState.GetPropertyHandler().RegisterProperty( "screenSaverName", screenSaverName );
	scriptState.GetPropertyHandler().RegisterProperty( "time", guiTime );
	scriptState.GetPropertyHandler().RegisterProperty( "theme", themeName );
	scriptState.GetPropertyHandler().RegisterProperty( "bindContext", bindContextName );
	scriptState.GetPropertyHandler().RegisterProperty( "flags", scriptFlags );
	scriptState.GetPropertyHandler().RegisterProperty( "inputScale", inputScale );
	scriptState.GetPropertyHandler().RegisterProperty( "blankWStr", blankWStr );

	inputScale						= 1.0f;
	cursorSize						= idVec2( 32.0f, 32.0f );
	cursorColor						= GetColor( "system/cursor" );

	screenSaverName					= "system/screensaver";
	cursorMaterialName				= "system/cursor";

	scriptFlags						= GUI_INTERACTIVE | GUI_SCREENSAVER;



	screenDimensions				= idVec2( SCREEN_WIDTH, SCREEN_HEIGHT );
	screenDimensions				.SetReadOnly( true );

	screenCenter					= idVec2( SCREEN_WIDTH * 0.5f, SCREEN_HEIGHT * 0.5f );
	screenCenter					.SetReadOnly( true );

	guiTime.SetReadOnly( true );
	blankWStr.SetReadOnly( true );

	cursorPos						= screenCenter;

	focusedWindow					= NULL;
	focusedWindowName				= "";

	flags.ignoreLocalCursorUpdates	= false;
	flags.shouldUpdate				= true;

	toolTipWindow					= NULL;
	toolTipSource					= NULL;
	tooltipAnchor					= vec2_origin;
	postProcessMaterialName 		= "";
	themeName						= "default";

	generalStacks.Clear();
	scriptStack.Clear();
	
	colorStack.Clear();
	colorStack.SetGranularity( 1 );
	currentColor = colorWhite;
}

/*
================
sdUserInterfaceLocal::~sdUserInterfaceLocal
================
*/
sdUserInterfaceLocal::~sdUserInterfaceLocal( void ) {
	parseStack.Clear();
	Clear();
}

/*
============
sdUserInterfaceLocal::PushTrace
============
*/
void sdUserInterfaceLocal::PushTrace( const char* info ) {
	parseStack.Append( info );
}

/*
============
sdUserInterfaceLocal::PopTrace
============
*/
void sdUserInterfaceLocal::PopTrace() {
	if( parseStack.Num() == 0 ) {
		gameLocal.Warning( "sdUserInterfaceLocal::PopTrace: Stack underflow" );
		return;
	}
	parseStack.RemoveIndex( parseStack.Num() - 1 );
}

/*
============
sdUserInterfaceLocal::PrintStackTrace
============
*/
void sdUserInterfaceLocal::PrintStackTrace() {	
	if( parseStack.Num() == 0 ) {
		return;
	}

	gameLocal.Printf( "^3===============================================\n" );
	
	for( int i = parseStack.Num() - 1; i >= 0; i-- ) {
		gameLocal.Printf( "%s\n", parseStack[ i ].c_str() );
	}
	
	gameLocal.Printf( "^3===============================================\n" );
	parseStack.Clear();
}

/*
================
sdUserInterfaceLocal::Load
================
*/
bool sdUserInterfaceLocal::Load( const char* name ) {
	if ( guiDecl ) {
		assert( false );
		return false;
	}

	guiDecl = gameLocal.declGUIType[ name ];
	if ( guiDecl == NULL ) {
		gameLocal.Warning( "sdUserInterfaceLocal::Load Invalid GUI '%s'", name );
		return false;
	}

	Init();

	PushTrace( va( "Loading %s", GetName() ) );
	scriptStack.SetID( GetName() );

	const sdDeclGUITheme* theme = gameLocal.declGUIThemeType.LocalFind( "default" );
	declManager->AddDependency( GetDecl(), theme );

	idTokenCache& tokenCache = declManager->GetGlobalTokenCache();

	try {
		sdUIWindow::SetupProperties( scriptState.GetPropertyHandler(), guiDecl->GetProperties(), this, tokenCache );

		int i;
		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {
			const sdDeclGUIWindow* windowDecl = guiDecl->GetWindow( i );
			PushTrace( windowDecl->GetName() );

			sdUIObject* object = uiManager->CreateWindow( windowDecl->GetTypeName() );
			if ( !object ) {			
				gameLocal.Error( "sdUserInterfaceLocal::Load Invalid Window Type '%s'", windowDecl->GetTypeName() );
			}

			object->CreateProperties( this, windowDecl, tokenCache );
			object->CreateTimelines( this, windowDecl, tokenCache );

			if( windows.Find( object->GetName() ) != windows.End() ) {
				gameLocal.Error( "Window named '%s' already exists", object->GetName() );
			}
			windows.Set( object->GetName(), object );

			PopTrace();
		}

		CreateEvents( guiDecl, tokenCache );

		assert( windows.Num() == guiDecl->GetNumWindows() );

		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {
			GetWindow( i )->InitEvents();
		}

		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {
			GetWindow( i )->CreateEvents( this, guiDecl->GetWindow( i ), tokenCache );
		}
		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {
			GetWindow( i )->CacheEvents();
		}
		

		desktop = GetWindow( "desktop" )->Cast< sdUIWindow >();
		if( desktop == NULL ) {
			gameLocal.Warning( "sdUserInterfaceLocal::Load: could not find 'desktop' in '%s'", name );
		}

		toolTipWindow = GetWindow( "toolTip" )->Cast< sdUIWindow >();

		// parent all the nested windows
		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {
			const sdDeclGUIWindow* windowDecl = guiDecl->GetWindow( i );
			const idStrList& children = windowDecl->GetChildren();

			PushTrace( windowDecl->GetName() );

			windowHash_t::Iterator parentIter = windows.Find( windowDecl->GetName() );
			if( parentIter == windows.End() ) {
				gameLocal.Error( "sdUserInterfaceLocal::Could not find window '%s'", windowDecl->GetName() );
			}

			for( int childIndex = 0; childIndex < children.Num(); childIndex++ ) {
				windowHash_t::Iterator iter = windows.Find( children[ childIndex ] );
				if( iter == windows.End() ) {
					gameLocal.Error( "sdUserInterfaceLocal::Could not find window '%s'", children[ childIndex ].c_str() );
				}
				iter->second->SetParent( parentIter->second );
			}
			PopTrace();
		}

		// run constructors now that everything is parented
		for ( i = 0; i < guiDecl->GetNumWindows(); i++ ) {			
			GetWindow( i )->RunEvent( sdUIEventInfo( sdUIObject::OE_CREATE, 0 ) );
			GetWindow( i )->OnCreate();
		}
	} catch ( idException& exception ) {
		PrintStackTrace();
		throw exception;
	}

	PopTrace();

	return true;
}

/*
================
sdUserInterfaceLocal::Draw
================
*/
void sdUserInterfaceLocal::Draw() {
#ifdef _DEBUG
	if( guiDecl && guiDecl->GetBreakOnDraw() ) {
		assert( !"BREAK_ON_DRAW" );
	}
#endif // _DEBUG
	if ( !desktop ) {
		return;
	}
	
	deviceContext->SetRegisters( shaderParms.Begin() );
	bool allowScreenSaver = TestGUIFlag( GUI_SCREENSAVER ) && !TestGUIFlag( GUI_FULLSCREEN );

	if ( IsActive() || !allowScreenSaver ) {
		desktop->ApplyLayout();
		desktop->Draw();
		desktop->FinalDraw();

		if ( TestGUIFlag( GUI_SHOWCURSOR ) ) {
			deviceContext->DrawMaterial( cursorPos.GetValue().x, cursorPos.GetValue().y, cursorSize.GetValue().x, cursorSize.GetValue().y, cursorMaterial, cursorColor );
		}
	} else if ( screenSaverMaterial != NULL && allowScreenSaver ) {
		deviceContext->DrawMaterial( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, screenSaverMaterial, colorWhite );
	}
	
	if( g_debugGUI.GetBool() ) {
		sdBounds2D rect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT );

		deviceContext->SetColor( colorWhite );
		deviceContext->SetFontSize( g_debugGUITextScale.GetFloat() );
		deviceContext->DrawText( va( L"%hs", guiDecl->GetName() ), rect, DTF_CENTER | DTF_VCENTER | DTF_SINGLELINE );
	}

	UpdateToolTip();
	
	if ( postProcessMaterial != NULL ) {
		deviceContext->DrawMaterial( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT, postProcessMaterial, colorWhite );
	}
	assert( colorStack.Num() == 0 );
}


/*
============
sdUserInterfaceLocal::UpdateToolTip
============
*/
void sdUserInterfaceLocal::UpdateToolTip() {
	if( TestGUIFlag( GUI_TOOLTIPS ) ) {
		if( toolTipWindow == NULL ) {
			gameLocal.Warning( "%s: could not find windowDef 'tooltip' for updating", GetName() );
			ClearGUIFlag( GUI_TOOLTIPS );
			return;
		}
		if( toolTipSource == NULL && GetCurrentTime() >= nextAllowToolTipTime ) {
			if( !keyInputManager->AnyKeysDown() ) {
				// try to spawn a new tool-tip
				if( toolTipSource = desktop->UpdateToolTip( cursorPos ) ) {
					tooltipAnchor = cursorPos;
				} else {
					nextAllowToolTipTime = GetCurrentTime() + SEC2MS( gui_tooltipDelay.GetFloat() );
				}
			}
		} else if( toolTipSource != NULL ) {
			bool keepWindow = false;
			if( sdUIWindow* window = toolTipSource->Cast< sdUIWindow >() ) {
				// see if the cursor has moved outside of the tool-tip window
				sdBounds2D bounds( window->GetWorldRect() );
				keepWindow = bounds.ContainsPoint( cursorPos );
			}
			if( !keepWindow ) {
				toolTipSource = NULL;
				nextAllowToolTipTime = GetCurrentTime() + SEC2MS( gui_tooltipDelay.GetFloat() );
			}
		}

		if( !toolTipSource ) {
			CancelToolTip();
			return;
		}
		if( idMath::Fabs( cursorPos.GetValue().x - tooltipAnchor.x ) >= TOOLTIP_MOVE_TOLERANCE || 
			idMath::Fabs( cursorPos.GetValue().y - tooltipAnchor.y ) >= TOOLTIP_MOVE_TOLERANCE ) {
			CancelToolTip();
			nextAllowToolTipTime = GetCurrentTime() + SEC2MS( gui_tooltipDelay.GetFloat() );
			return;
		}

		sdProperties::sdProperty* toolText	= toolTipSource->GetScope().GetProperty( "toolTipText", PT_WSTRING );

		sdProperties::sdProperty* active	= toolTipWindow->GetScope().GetProperty( "active", PT_FLOAT );
		sdProperties::sdProperty* tipText	= toolTipWindow->GetScope().GetProperty( "tipText", PT_WSTRING );
		sdProperties::sdProperty* rect		= toolTipWindow->GetScope().GetProperty( "rect", PT_VEC4 );

		if( toolText && tipText && active ) {
			*tipText->value.wstringValue = *toolText->value.wstringValue;
			*active->value.floatValue = 1.0f;				
		}

		if( rect != NULL ) {
			idVec4 temp = *rect->value.vec4Value;
			temp.x = cursorPos.GetValue().x;
			temp.y = cursorPos.GetValue().y + cursorSize.GetValue().y * 0.5f;
			
			if( temp.x + temp.z >= screenDimensions.GetValue().x ) {
				temp.x -= temp.z;
			}

			if( temp.y + temp.w >= screenDimensions.GetValue().y ) {
				temp.y -= temp.w + cursorSize.GetValue().y * 0.5f;;
			}
			*rect->value.vec4Value = temp;
		}
		tooltipAnchor = cursorPos;
		nextAllowToolTipTime = 0;
	}
}


/*
============
sdUserInterfaceLocal::CancelToolTip
============
*/
void sdUserInterfaceLocal::CancelToolTip() {
	if( !toolTipWindow ) {
		return;
	}

	sdProperties::sdProperty* active = toolTipWindow->GetScope().GetProperty( "active" );
	if( active ) {
		*active->value.floatValue = 0.0f;
	}
	toolTipSource = NULL;
}

/*
================
sdUserInterfaceLocal::GetWindow
================
*/
sdUIObject* sdUserInterfaceLocal::GetWindow( const char* name ) {
	windowHash_t::Iterator iter = windows.Find( name );
	if( iter == windows.End() ) {
		return NULL;
	}
	return iter->second;
}

/*
================
sdUserInterfaceLocal::GetWindow
================
*/
const sdUIObject* sdUserInterfaceLocal::GetWindow( const char* name ) const {
	windowHash_t::ConstIterator iter = windows.Find( name );
	if( iter == windows.End() ) {
		return NULL;
	}
	return iter->second;
}

/*
============
sdUserInterfaceLocal::Clear
============
*/
void sdUserInterfaceLocal::Clear() {
	scriptState.ClearExpressions();	

	// we must do this before we destroy any windows, since a window could be watching other windows' properties
	DisconnectGlobalCallbacks();

	windowHash_t::Iterator iter = windows.Begin();
	while( iter != windows.End() ) {
		iter->second->DisconnectGlobalCallbacks();
		++iter;
	}

	for( int i = 0; i < materialCache.Num(); i++ ) {
		uiMaterialCache_t::Iterator entry = materialCache.FindIndex( i );
		entry->second->material.Clear();
		materialCacheAllocator.Free( entry->second );
	}
	materialCache.Clear();

	timelineWindows.Clear();
	windows.DeleteValues();
	windows.Clear();	

	externalProperties.DeleteContents( true );

	scriptState.Clear();

	script.Clear();
	scriptStack.Clear();

	if( timelines.Get() != NULL ) {
		timelines->Clear();
	}

	focusedWindow	= NULL;
	desktop			= NULL;
	guiDecl			= NULL;
	toolTipSource	= NULL;
	toolTipWindow	= NULL;

	themeName		= "";
	focusedWindowName = "";
	cursorMaterialName = "";
	cursorSize = vec2_zero;
	cursorColor = vec4_zero;	
	screenSaverName = "";
	postProcessMaterialName = "";
}

/*
============
sdUserInterfaceLocal::RegisterTimelineWindow
============
*/
void sdUserInterfaceLocal::RegisterTimelineWindow( sdUIObject* window ) {
	timelineWindows.Alloc() = window;
}

idCVar sdUserInterfaceLocal::gui_invertMenuPitch( "gui_invertMenuPitch", "0", CVAR_BOOL | CVAR_ARCHIVE | CVAR_PROFILE, "invert mouse movement in in-game menus" );
/*
============
sdUserInterfaceLocal::PostEvent
============
*/
bool sdUserInterfaceLocal::PostEvent( const sdSysEvent* event ) {
	if ( !desktop || !IsInteractive() ) {
		return false;
	}
	
	if ( event->IsControllerButtonEvent() || event->IsKeyEvent() ) {
		if ( bindContext != NULL ) {
			bool down;
			sdKeyCommand* cmd = keyInputManager->GetCommand( bindContext, *keyInputManager->GetKeyForEvent( *event, down ) );
			if ( cmd != NULL ) {
				keyInputManager->ProcessUserCmdEvent( *event );
				return true;
			}
		}
	}

	// save these off for the events
	if ( !flags.ignoreLocalCursorUpdates && event->IsMouseEvent() ) {
		idVec2 pos = cursorPos;
		idVec2 scaledDelta( event->GetXCoord(), event->GetYCoord() );
		scaledDelta *= inputScale;

		if ( TestGUIFlag( GUI_FULLSCREEN ) ) {
			scaledDelta.x *= ( 1.0f / deviceContext->GetAspectRatioCorrection() );
		}		

		pos.x += scaledDelta.x;
		if ( TestGUIFlag( GUI_USE_MOUSE_PITCH ) && gui_invertMenuPitch.GetBool() ) {
			pos.y -= scaledDelta.y;
		} else {
			pos.y += scaledDelta.y;
		}

		pos.x = idMath::ClampFloat( 0.0f, screenDimensions.GetValue().x, pos.x );
		pos.y = idMath::ClampFloat( 0.0f, screenDimensions.GetValue().y, pos.y );
		cursorPos = pos;
	}

	bool retVal = false;
	
	if ( !TestGUIFlag( GUI_SHOWCURSOR ) &&
		( event->IsMouseEvent() || ( event->IsMouseButtonEvent() && event->GetMouseButton() >= M_MOUSE1 && event->GetMouseButton() <= M_MOUSE12 ) && !TestGUIFlag( GUI_NON_FOCUSED_MOUSE_EVENTS ) )) {
		retVal = false;
	} else {
		if ( event->IsMouseButtonEvent() && event->IsButtonDown() ) {
			if( focusedWindow ) {
				retVal |= focusedWindow->HandleFocus( event );
			}
			if( !retVal ) {
				retVal |= desktop->HandleFocus( event );
			}
			nextAllowToolTipTime = GetCurrentTime() + SEC2MS( gui_tooltipDelay.GetFloat() );
		}

		if( ( ( event->IsMouseButtonEvent() || event->IsKeyEvent() ) && event->IsButtonDown() ) || event->IsGuiEvent() )  {
			CancelToolTip();
			nextAllowToolTipTime = GetCurrentTime() + SEC2MS( gui_tooltipDelay.GetFloat() );
		}
		if ( focusedWindow == NULL && focusedWindowName.GetValue().Length() ) {
			SetFocus( GetWindow( focusedWindowName.GetValue().c_str() )->Cast< sdUIWindow >() );
		}
		if ( focusedWindow ) {
			bool focusedRetVal = focusedWindow->PostEvent( event );
			retVal |= focusedRetVal;
			if( !focusedRetVal ) {
				// give immediate parents that capture key events a crack
				if( !retVal && event->IsKeyEvent() || event->IsGuiEvent() ) {
					sdUIObject* parent = focusedWindow->GetNode().GetParent();
					while( parent != NULL && retVal == false ) {
						if( sdUIWindow* window = parent->Cast< sdUIWindow >() ) {
							if( window->TestFlag( sdUIWindow::WF_CAPTURE_KEYS ) ) {
								retVal |= parent->PostEvent( event );
							}
						}
						parent = parent->GetNode().GetParent();
					}
				}
			}
		} 
		
		if( !retVal ) {
			retVal |= desktop->PostEvent( event );
		}
	}

	// eat everything but the F-Keys
	if ( TestGUIFlag( GUI_CATCH_ALL_EVENTS ) ) {
		keyNum_t keyNum;
		
		if ( event->IsKeyEvent() ) {
			keyNum = event->GetKey();
		} else {
			keyNum = K_INVALID;
		}

		if ( ( keyNum != K_INVALID && ( keyNum < K_F1 || keyNum > K_F15 ) ) || ( event->IsControllerButtonEvent() ) ) {
			retVal = true;
		}
	}

	if( TestGUIFlag( GUI_TOOLTIPS ) && event->IsMouseEvent() ) {
		lastMouseMoveTime = GetCurrentTime();
	}

	return retVal;
}

/*
============
sdUserInterfaceLocal::Shutdown
============
*/
void sdUserInterfaceLocal::Shutdown( void ) {
	uiFunctions.DeleteContents();
	uiEvaluators.DeleteContents( true );
}

/*
============
sdUserInterfaceLocal::FindFunction
============
*/
sdUserInterfaceLocal::uiFunction_t* sdUserInterfaceLocal::FindFunction( const char* name ) {
	sdUserInterfaceLocal::uiFunction_t** ptr;
	return uiFunctions.Get( name, &ptr ) ? *ptr : NULL;
}

/*
============
sdUserInterfaceLocal::GetFunction
============
*/
sdUIFunctionInstance* sdUserInterfaceLocal::GetFunction( const char* name ) {
	uiFunction_t* function = FindFunction( name );
	if ( function == NULL ) {
		return NULL;
	}

	return new sdUITemplateFunctionInstance< sdUserInterfaceLocal, sdUITemplateFunctionInstance_Identifier >( this, function );
}

/*
============
sdUserInterfaceLocal::GetEvaluator
============
*/
sdUIEvaluatorTypeBase* sdUserInterfaceLocal::GetEvaluator( const char* name ) {
	int i;
	for ( i = 0; i < uiEvaluators.Num(); i++ ) {
		if ( !idStr::Cmp( uiEvaluators[ i ]->GetName(), name ) ) {
			return uiEvaluators[ i ];
		}
	}

	return NULL;
}

/*
================
sdUserInterfaceLocal::CreateEvents
================
*/
void sdUserInterfaceLocal::CreateEvents( const sdDeclGUI* guiDecl, idTokenCache& tokenCache ) {
	parseStack.Clear();
	const idList< sdDeclGUIProperty* >& guiProperties = guiDecl->GetProperties();

	events.Clear();
	events.SetNumEvents( GE_NUM_EVENTS );
	namedEvents.Clear();
	
	sdUserInterfaceLocal::PushTrace( va( "sdUserInterfaceLocal::CreateEvents for gui '%s'", guiDecl->GetName() ));

	idList<unsigned short> constructorTokens;
	bool hasValues = sdDeclGUI::CreateConstructor( guiDecl->GetProperties(), constructorTokens, tokenCache );

	if( hasValues ) {
		sdUserInterfaceLocal::PushTrace( "<constructor>" );
		idLexer parser( sdDeclGUI::LEXER_FLAGS );
		parser.LoadTokenStream( constructorTokens, tokenCache, "sdUserInterfaceLocal::CreateEvents" );

		sdUIEventInfo constructionEvent( GE_CONSTRUCTOR, 0 );
		GetScript().ParseEvent( &parser, constructionEvent, &scriptState );
		RunEvent( constructionEvent );

		sdUserInterfaceLocal::PopTrace();
	}
	

	if( guiDecl->GetTimelines().GetNumTimelines() > 0 ) {
		timelines.Reset( new sdUITimelineManager( *this, scriptState, script ));
		timelines->CreateTimelines( guiDecl->GetTimelines(), guiDecl );	
		timelines->CreateProperties( guiDecl->GetTimelines(), guiDecl, tokenCache );
	}

	const idList< sdDeclGUIEvent* >& guiEvents = guiDecl->GetEvents();

	idList< sdUIEventInfo > eventList;
	for ( int i = 0; i < guiEvents.Num(); i++ ) {
		const sdDeclGUIEvent* eventInfo = guiEvents[ i ];
		sdUserInterfaceLocal::PushTrace( tokenCache[ eventInfo->GetName() ] );

		eventList.Clear();
		EnumerateEvents( tokenCache[ eventInfo->GetName() ], eventInfo->GetFlags(), eventList, tokenCache );

		for ( int j = 0; j < eventList.Num(); j++ ) {
			idLexer parser( sdDeclGUI::LEXER_FLAGS );
			parser.LoadTokenStream( eventInfo->GetTokenIndices(), tokenCache, tokenCache[ eventInfo->GetName() ] );
			
			GetScript().ParseEvent( &parser, eventList[ j ], &scriptState );
		}
		sdUserInterfaceLocal::PopTrace();
	}

	if( timelines.Get() != NULL ) {
		timelines->CreateEvents( guiDecl->GetTimelines(), guiDecl, tokenCache );
	}

	RunEvent( sdUIEventInfo( GE_CREATE, 0 ) );
}

/*
================
sdUserInterfaceLocal::EnumerateEvents
================
*/
void sdUserInterfaceLocal::EnumerateEvents( const char* name, const idList<unsigned short>& flags, idList< sdUIEventInfo >& events, const idTokenCache& tokenCache ) {
	if ( !idStr::Icmp( name, "onActivate" ) ) {
		events.Append( sdUIEventInfo( GE_ACTIVATE, 0 ) );
		return;
	}

	if ( !idStr::Icmp( name, "onDeactivate" ) ) {
		events.Append( sdUIEventInfo( GE_DEACTIVATE, 0 ) );
		return;
	}

	if ( !idStr::Icmp( name, "onCancel" ) ) {
		events.Append( sdUIEventInfo( GE_CANCEL, 0 ) );
		return;
	}

	if ( !idStr::Icmp( name, "onNamedEvent" ) ) {
		int i;
		for ( i = 0; i < flags.Num(); i++ ) {
			events.Append( sdUIEventInfo( GE_NAMED, NamedEventHandleForString( tokenCache[ flags[ i ] ] ) ) );
		}
		return;
	}

	if( !idStr::Icmp( name, "onCVarChanged" ) ) {
		int i;
		for( i = 0; i < flags.Num(); i++ ) {
			const idToken& name = tokenCache[ flags[ i ] ];
			idCVar* cvar = cvarSystem->Find( name.c_str() );
			if( cvar == NULL ) {
				gameLocal.Error( "Event 'onCVarChanged' could not find cvar '%s'", name.c_str() );
				return;
			}

			int eventHandle = NamedEventHandleForString( name.c_str() );
			cvarCallback_t* callback = new cvarCallback_t( *this, *cvar, eventHandle );
			cvarCallbacks.Append( callback );

			events.Append( sdUIEventInfo( GE_CVARCHANGED, eventHandle ) );
		}
		return;
	}

	if ( !idStr::Icmp( name, "onToolTipEvent" ) ) {
		events.Append( sdUIEventInfo( GE_TOOLTIPEVENT, 0 ) );
		return;
	}

	if ( !idStr::Icmp( name, "onPropertyChanged" ) ) {
		int i;
		for ( i = 0; i < flags.Num(); i++ ) {
			const idToken& name = tokenCache[ flags[ i ] ];

			// do a proper lookup, so windows can watch guis and vice-versa
			idLexer p( sdDeclGUI::LEXER_FLAGS );
			p.LoadMemory( name, name.Length(), "onPropertyChanged event handler" );			

			sdUserInterfaceScope* propertyScope = gameLocal.GetUserInterfaceScope( GetState(), &p );

			idToken token;
			p.ReadToken( &token );

			sdProperty* prop = propertyScope->GetProperty( token );

			if( !prop ) {
				gameLocal.Error( "sdUserInterfaceLocal::EnumerateEvents: event 'onPropertyChanged' could not find property '%s'", name.c_str() );
				return;
			}

			int eventHandle = NamedEventHandleForString( name.c_str() );
			int cbHandle = -1;
			switch( prop->GetValueType() ) {
				case PT_VEC4: 
					cbHandle = prop->value.vec4Value->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const idVec4&, const idVec4& >( &sdUserInterfaceLocal::OnVec4PropertyChanged, this , eventHandle ) );
					break;
				case PT_VEC3: 
					cbHandle = prop->value.vec3Value->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const idVec3&, const idVec3& >( &sdUserInterfaceLocal::OnVec3PropertyChanged, this , eventHandle ) );
					break;
				case PT_VEC2: 
					cbHandle = prop->value.vec2Value->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const idVec2&, const idVec2& >( &sdUserInterfaceLocal::OnVec2PropertyChanged, this , eventHandle ) );
					break;
				case PT_INT: 
					cbHandle = prop->value.intValue->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const int, const int >( &sdUserInterfaceLocal::OnIntPropertyChanged, this , eventHandle ) );
					break;
				case PT_FLOAT: 
					cbHandle = prop->value.floatValue->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const float, const float >( &sdUserInterfaceLocal::OnFloatPropertyChanged, this , eventHandle ) );
					break;
				case PT_STRING: 
					cbHandle = prop->value.stringValue->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const idStr&, const idStr& >( &sdUserInterfaceLocal::OnStringPropertyChanged, this , eventHandle ) );
					break;
				case PT_WSTRING: 
					cbHandle = prop->value.wstringValue->AddOnChangeHandler( sdFunctions::sdBindMem1< void, int, const idWStr&, const idWStr& >( &sdUserInterfaceLocal::OnWStringPropertyChanged, this , eventHandle ) );
					break;
			}
			toDisconnect.Append( callbackHandler_t( prop, cbHandle ));

			events.Append( sdUIEventInfo( GE_PROPCHANGED, eventHandle ) );
		}
		return;
	}
	gameLocal.Error( "sdUserInterfaceLocal::EnumerateEvents: unknown event '%s'", name );
}

/*
================
sdUserInterfaceLocal::Activate
================
*/
void sdUserInterfaceLocal::Activate( void ) {
	if( !guiDecl ) {
		return;
	}

	if ( flags.isActive ) {
		return;
	}

	flags.isActive = true;
	CancelToolTip();

	if ( NonGameGui() ) {
		SetCurrentTime( sys->Milliseconds() );
	} else {
		SetCurrentTime( gameLocal.time + gameLocal.timeOffset );
	}
	Update();

	if( timelines.Get() != NULL ) {
		timelines->ResetAllTimelines();
	}

	int i;
	for ( i = 0; i < windows.Num(); i++ ) {
		sdUIObject* object = windows.FindIndex( i )->second;
		if( sdUIWindow* window = object->Cast< sdUIWindow >() ) {
			window->OnActivate();
		}		
	}

	RunEvent( sdUIEventInfo( GE_ACTIVATE, 0 ) );
}

/*
================
sdUserInterfaceLocal::Deactivate
================
*/
void sdUserInterfaceLocal::Deactivate( bool forceDeactivate ) {
	if( !guiDecl ) {
		return;
	}

	if ( !flags.isActive || ( !forceDeactivate && !TestGUIFlag( GUI_SCREENSAVER ) )) {
		return;
	}

	flags.isActive = false;

	if( timelines.Get() != NULL ) {
		timelines->ClearAllTimelines();
	}

	RunEvent( sdUIEventInfo( GE_DEACTIVATE, 0 ) );
}

/*
================
sdUserInterfaceLocal::Update
================
*/
void sdUserInterfaceLocal::Update( void ) {
	if ( !IsActive() ) {
		return;
	}

	guiTime.SetReadOnly( false );
	guiTime = currentTime;
	guiTime.SetReadOnly( true );
	
	screenDimensions.SetReadOnly( false );
	screenCenter.SetReadOnly( false );
	if ( TestGUIFlag( GUI_FULLSCREEN ) ) {
		float adjustedWidth = idMath::Ceil( SCREEN_WIDTH * ( 1.0f / deviceContext->GetAspectRatioCorrection() ) );
		screenDimensions.SetIndex( 0, adjustedWidth );
	} else {
		screenDimensions.SetIndex( 0, SCREEN_WIDTH );
	}

	screenCenter.SetIndex( 0 , screenDimensions.GetValue().x / 2.0f );
	screenCenter.SetReadOnly( true );
	screenDimensions.SetReadOnly( true );

	if ( timelines.Get() != NULL ) {
		timelines->Run( currentTime );
	}

	for ( int i = 0; i < timelineWindows.Num(); i++ ) {
		sdUITimelineManager* manager = timelineWindows[ i ]->GetTimelineManager();
		manager->Run( currentTime );
	}

	scriptState.Update();
}

/*
================
sdUserInterfaceLocal::AddEvent
================
*/
void sdUserInterfaceLocal::AddEvent( const sdUIEventInfo& info, sdUIEventHandle scriptHandle ) {
	events.AddEvent( info, scriptHandle );
}

/*
================
sdUserInterfaceLocal::GetEvent
================
*/
sdUIEventHandle sdUserInterfaceLocal::GetEvent( const sdUIEventInfo& info ) const {
	return events.GetEvent( info );
}

/*
============
sdUserInterfaceLocal::RunEvent
============
*/
bool sdUserInterfaceLocal::RunEvent( const sdUIEventInfo& info ) {
	return GetScript().RunEventHandle( GetEvent( info ), &scriptState );
}

/*
============
sdUserInterfaceLocal::SetFocus
============
*/
void sdUserInterfaceLocal::SetFocus( sdUIWindow* focus ) {
	if( focusedWindow == focus ) {
		return;
	}
	if( focusedWindow ) {
		focusedWindow->OnLoseFocus(); 
	}

	focusedWindow = focus;

	if( focusedWindow ) {
		focusedWindow->OnGainFocus();
	}	
}

/*
============
sdUserInterfaceLocal::OnCursorMaterialNameChanged
============
*/
void sdUserInterfaceLocal::OnCursorMaterialNameChanged( const idStr& oldValue, const idStr& newValue ) {
	if( newValue.Length() ) {
		cursorMaterial = gameLocal.declMaterialType.LocalFind( GetMaterial( newValue ));
		if( cursorMaterial && cursorMaterial->GetSort() < SS_POST_PROCESS ) {
			if ( cursorMaterial->GetSort() != SS_GUI && cursorMaterial->GetSort() != SS_NEAREST ) {
				gameLocal.Warning( "sdUserInterfaceLocal::OnCursorMaterialNameChanged: material %s used in gui '%s' without proper sort", cursorMaterial->GetName(), GetName() );
			}
		}
	} else {
		cursorMaterial = NULL;
	}
}

/*
============
sdUserInterfaceLocal::OnPostProcessMaterialNameChanged
============
*/
void sdUserInterfaceLocal::OnPostProcessMaterialNameChanged( const idStr& oldValue, const idStr& newValue ) {
	if( newValue.Length() ) {
		postProcessMaterial = gameLocal.declMaterialType.LocalFind( GetMaterial( newValue ));
	} else {
		postProcessMaterial = NULL;
	}
}

/*
============
sdUserInterfaceLocal::OnFocusedWindowNameChanged
============
*/
void sdUserInterfaceLocal::OnFocusedWindowNameChanged( const idStr& oldValue, const idStr& newValue ) {	
	SetFocus( GetWindow( newValue )->Cast< sdUIWindow >() );
	if( newValue.Length() && !focusedWindow ) {
		gameLocal.Warning( "sdUserInterfaceLocal::OnFocusedWindowNameChanged: '%s' could not find windowDef '%s' for focus", GetName(), newValue.c_str() );
	}
}

/*
============
sdUserInterfaceLocal::OnOnScreenSaverMaterialNameChanged
============
*/
void sdUserInterfaceLocal::OnScreenSaverMaterialNameChanged( const idStr& oldValue, const idStr& newValue ) {
	if( newValue.Length() ) {
		screenSaverMaterial = gameLocal.declMaterialType.LocalFind( GetMaterial( newValue ));
	} else {
		screenSaverMaterial = NULL;
	}
}

/*
============
sdUserInterfaceLocal::SetRenderCallback
============
*/
void sdUserInterfaceLocal::SetRenderCallback( const char* objectName, uiRenderCallback_t callback, uiRenderCallbackType_t type ) {
	sdUIWindow* object = GetWindow( objectName )->Cast< sdUIWindow >();
	if( object == NULL ) {
		gameLocal.Error( "sdUserInterfaceLocal::SetRenderCallback: could not find window '%s'", objectName );
	}
	object->SetRenderCallback( callback, type );
}


/*
============
sdUserInterfaceLocal::PostNamedEvent
============
*/
bool sdUserInterfaceLocal::PostNamedEvent( const char* event, bool allowMissing ) {
	assert( event );
	int index = namedEvents.FindIndex( event );
	if( index == -1 ) {
		if( !allowMissing ) {
			gameLocal.Error( "sdUserInterfaceLocal::PostNamedEvent: could not find event '%s' in '%s'", event, guiDecl != NULL ? guiDecl->GetName() : "unknown GUI" );
		}		
		return false;
	}

	if( g_debugGUIEvents.GetBool() ) {
		gameLocal.Printf( "GUI '%s': named event '%s'\n", GetName(), event );
	}
	return RunEvent( sdUIEventInfo( GE_NAMED, index ) );
}

/*
============
sdUserInterfaceLocal::NamedEventHandleForString
============
*/
int sdUserInterfaceLocal::NamedEventHandleForString( const char* name ) {
	int index = namedEvents.FindIndex( name );
	if( index == -1 ) {
		index = namedEvents.Append( name ) ;
	}
	return index;
}

/*
============
sdUserInterfaceLocal::OnStringPropertyChanged
============
*/
void sdUserInterfaceLocal::OnStringPropertyChanged( int event, const idStr& oldValue, const idStr& newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnWStringPropertyChanged
============
*/
void sdUserInterfaceLocal::OnWStringPropertyChanged( int event, const idWStr& oldValue, const idWStr& newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnIntPropertyChanged
============
*/
void sdUserInterfaceLocal::OnIntPropertyChanged( int event, const int oldValue, const int newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnFloatPropertyChanged
============
*/
void sdUserInterfaceLocal::OnFloatPropertyChanged( int event, const float oldValue, const float newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnVec4PropertyChanged
============
*/
void sdUserInterfaceLocal::OnVec4PropertyChanged( int event, const idVec4& oldValue, const idVec4& newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnVec3PropertyChanged
============
*/
void sdUserInterfaceLocal::OnVec3PropertyChanged( int event, const idVec3& oldValue, const idVec3& newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::OnVec2PropertyChanged
============
*/
void sdUserInterfaceLocal::OnVec2PropertyChanged( int event, const idVec2& oldValue, const idVec2& newValue ) {
	RunEvent( sdUIEventInfo( GE_PROPCHANGED, event ) );
}

/*
============
sdUserInterfaceLocal::SetCursor
============
*/
void sdUserInterfaceLocal::SetCursor( const int x, const int y ) {
	idVec2 pos( idMath::ClampInt( 0, SCREEN_WIDTH, x ), idMath::ClampInt( 0, SCREEN_HEIGHT, y ) );
	cursorPos = pos;
}

/*
============
sdUserInterfaceLocal::SetTheme
============
*/
void sdUserInterfaceLocal::SetTheme( const char* theme ) {
	const sdDeclGUITheme* newTheme = gameLocal.declGUIThemeType.LocalFind( theme, false );

	if( !newTheme ) {
		newTheme = gameLocal.declGUIThemeType.LocalFind( "default", true );
	}

	if( this->theme != newTheme ) {

		bool isActive = IsActive();
		if ( isActive ) {
			Deactivate( true );
		}

		this->theme = newTheme;
		if ( guiDecl != NULL ) {
			declManager->AddDependency( GetDecl(), newTheme );

			// regenerate
			idStr name = guiDecl->GetName();
			guiDecl = NULL;
			Clear();
			Load( name );	
		}

		if ( isActive ) {
			Activate();
		}
	}
}

/*
============
sdUserInterfaceLocal::GetMaterial
============
*/
const char* sdUserInterfaceLocal::GetMaterial( const char* key ) const {
	if( key[ 0 ] == '\0' ) {
		return "";
	}

	const char* out = GetDecl() ? GetDecl()->GetMaterials().GetString( key, "" ) : "";
	if( out[ 0 ] == '\0' && GetTheme() ) {
		out = GetTheme()->GetMaterial( key );
	}

	return out;
}

/*
============
sdUserInterfaceLocal::GetSound
============
*/
const char* sdUserInterfaceLocal::GetSound( const char* key ) const {
	if( key[ 0 ] == '\0' ) {
		return "";
	}
	
	if( idStr::Icmpn( key, "::", 2 ) == 0 ) {
		return key + 2;
	}

	const char* out = GetDecl() ? GetDecl()->GetSounds().GetString( key, "" ) : "";
	if( out[ 0 ] == '\0' && GetTheme() ) {
		out = GetTheme()->GetSound( key );
	}

	return out;
}

/*
============
sdUserInterfaceLocal::GetColor
============
*/
idVec4 sdUserInterfaceLocal::GetColor( const char* key ) const {
	if( key[ 0 ] == '\0' ) {
		return colorWhite;
	}

	idVec4 out;

	if( !GetDecl() || !GetDecl()->GetColors().GetVec4( key, "1 1 1 1", out ) && GetTheme() ) {
		out = GetTheme()->GetColor( key );
	}

	return out;
}


/*
============
sdUserInterfaceLocal::ApplyLatchedTheme
============
*/
void sdUserInterfaceLocal::ApplyLatchedTheme() {
	if ( latchedTheme.Length() > 0 ) {
		SetTheme( latchedTheme );
		latchedTheme.Clear();	
	}
}

/*
============
sdUserInterfaceLocal::OnThemeNameChanged
============
*/
void sdUserInterfaceLocal::OnThemeNameChanged( const idStr& oldValue, const idStr& newValue ) {
	if( newValue.IsEmpty() ) {
		latchedTheme = "default";
	} else {
		latchedTheme = newValue;
	}	
}

/*
============
sdUserInterfaceLocal::OnBindContextChanged
============
*/
void sdUserInterfaceLocal::OnBindContextChanged( const idStr& oldValue, const idStr& newValue ) {
	if ( newValue.IsEmpty() ) {
		bindContext = NULL;
	} else {
		bindContext = keyInputManager->AllocBindContext( newValue.c_str() );
	}	
}

/*
============
sdUserInterfaceLocal::OnScreenDimensionChanged
============
*/
void sdUserInterfaceLocal::OnScreenDimensionChanged( const idVec2& oldValue, const idVec2& newValue ) {
	windowHash_t::Iterator iter = windows.Begin();
	while( iter != windows.End() ) {
		if( sdUIWindow* window = iter->second->Cast< sdUIWindow >() ) {
			window->MakeLayoutDirty();
		}		
		++iter;
	}
}

/*
============
sdUserInterfaceLocal::Translate
============
*/
bool sdUserInterfaceLocal::Translate( const idKey& key, sdKeyCommand** cmd ) {
	if ( bindContext == NULL ) {
		return false;
	}
	*cmd = keyInputManager->GetCommand( bindContext, key );
	return *cmd != NULL;
}


/*
============
sdUserInterfaceLocal::EndLevelLoad
============
*/
void sdUserInterfaceLocal::EndLevelLoad() {
	uiMaterialCache_t::Iterator cacheIter= materialCache.Begin();
	while( cacheIter != materialCache.End() ) {
		uiCachedMaterial_t& cached = *( cacheIter->second );
		LookupPartSizes( cached.parts.Begin(), cached.parts.Num() );
		SetupMaterialInfo( cached.material );
		++cacheIter;
	}

	windowHash_t::Iterator iter = windows.Begin();
	while( iter != windows.End() ) {
		iter->second->EndLevelLoad();
		++iter;
	}
}

/*
============
sdUserInterfaceLocal::PopGeneralScriptVar
============
*/
void sdUserInterfaceLocal::PopGeneralScriptVar( const char* stackName, idStr& str ) {
	if( stackName[ 0 ] == '\0' ) {
		gameLocal.Error( "sdUserInterfaceLocal::PopGeneralScriptVar: empty stack name" );
	}
	stringStack_t& stack = generalStacks[ stackName ];
	if( stack.Num() == 0 ) {
		gameLocal.Error( "sdUserInterfaceLocal::PopGeneralScriptVar: stack underflow for '%s'", stackName );
	}

	int index = stack.Num() - 1;
	str = stack[ index ];
	stack.SetNum( index );
}

/*
============
sdUserInterfaceLocal::PushGeneralScriptVar
============
*/
void sdUserInterfaceLocal::PushGeneralScriptVar( const char* stackName, const char* str ) {
	if( stackName[ 0 ] == '\0' ) {
		gameLocal.Error( "sdUserInterfaceLocal::PushGeneralScriptVar: empty stack name" );
	}
	generalStacks[ stackName ].Append( str );
}

/*
============
sdUserInterfaceLocal::GetGeneralScriptVar
============
*/
void sdUserInterfaceLocal::GetGeneralScriptVar( const char* stackName, idStr& str ) {
	if( stackName[ 0 ] == '\0' ) {
		gameLocal.Error( "sdUserInterfaceLocal::GetGeneralScriptVar: empty stack name" );
	}

	stringStack_t& stack = generalStacks[ stackName ];
	if( stack.Num() == 0 ) {
		gameLocal.Error( "sdUserInterfaceLocal::GetGeneralScriptVar: stack underflow for '%s'", stackName );
	}
	
	int index = stack.Num() - 1;
	str = stack[ index ];
}

/*
============
sdUserInterfaceLocal::ClearGeneralStrings
============
*/
void sdUserInterfaceLocal::ClearGeneralStrings( const char* stackName ) {
	if( stackName[ 0 ] == '\0' ) {
		gameLocal.Error( "sdUserInterfaceLocal::ClearGeneralStrings: empty stack name" );
	}

	stringStack_t& stack = generalStacks[ stackName ];
	stack.Clear();
}

/*
============
sdUserInterfaceLocal::OnCVarChanged
============
*/
void sdUserInterfaceLocal::OnCVarChanged( idCVar& cvar, int id ) {
	bool result = RunEvent( sdUIEventInfo( GE_CVARCHANGED, id ) );
	if( result && sdUserInterfaceLocal::g_debugGUIEvents.GetInteger() ) {
		gameLocal.Printf( "%s: OnCVarChanged\n", GetName() );
	}
}

/*
============
sdUserInterfaceLocal::OnInputInit
============
*/
void sdUserInterfaceLocal::OnInputInit( void ) {	
	if ( bindContextName.GetValue().IsEmpty() ) {
		bindContext = NULL;
	} else {
		bindContext = keyInputManager->AllocBindContext( bindContextName.GetValue().c_str() );
	}
}

/*
============
sdUserInterfaceLocal::OnInputShutdown
============
*/
void sdUserInterfaceLocal::OnInputShutdown( void ) {
	bindContext = NULL;
}

/*
============
sdUserInterfaceLocal::OnLanguageInit
============
*/
void sdUserInterfaceLocal::OnLanguageInit( void ) {
	if ( desktop != NULL ) {
		desktop->OnLanguageInit();
		sdUIObject::OnLanguageInit_r( desktop );
	}
}

/*
============
sdUserInterfaceLocal::OnLanguageShutdown
============
*/
void sdUserInterfaceLocal::OnLanguageShutdown( void ) {
	if ( desktop != NULL ) {
		desktop->OnLanguageShutdown();
		sdUIObject::OnLanguageShutdown_r( desktop );
	}
}

/*
============
sdUserInterfaceLocal::MakeLayoutDirty
============
*/
void sdUserInterfaceLocal::MakeLayoutDirty() {
	if ( desktop != NULL ) {
		desktop->MakeLayoutDirty();
		sdUIObject::MakeLayoutDirty_r( desktop );
	}
}


/*
============
sdUserInterfaceLocal::SetCachedMaterial
============
*/
uiMaterialCache_t::Iterator sdUserInterfaceLocal::SetCachedMaterial( const char* alias, const char* newMaterial, int& handle ) {
	uiMaterialCache_t::Iterator findResult = FindCachedMaterial( alias, handle );
	if( findResult == materialCache.End() ) {
		uiMaterialCache_t::InsertResult result = materialCache.Set( alias, materialCacheAllocator.Alloc() );
		findResult = result.first;		
	}

	handle = findResult - materialCache.Begin();

	uiCachedMaterial_t& cached = *( findResult->second );

	idStr material;
	bool globalLookup = false;
	bool literal = false;

	int offset = ParseMaterial( newMaterial, material, globalLookup, literal, cached.drawMode );

	if( cached.drawMode != BDM_SINGLE_MATERIAL && cached.drawMode != BDM_USE_ST ) {
		InitPartsForBaseMaterial( material, cached );
		return findResult;
	}

	if( globalLookup ) {
		material = "::" + material;
	}

	if( literal ) {
		LookupMaterial( va( "literal: %hs", newMaterial + offset ), cached.material );
	} else if( ( material.Length() && !globalLookup ) || ( material.Length() > 2 && globalLookup ) ) {
		LookupMaterial( material, cached.material );
	}
	return findResult;
}

/*
============
sdUserInterfaceLocal::FindCachedMaterial
============
*/
uiMaterialCache_t::Iterator sdUserInterfaceLocal::FindCachedMaterial( const char* alias, int& handle ) {
	uiMaterialCache_t::Iterator iter = materialCache.Find( alias );
	if( iter == materialCache.End() ) {
		handle = -1;
	} else {
		handle = iter - materialCache.Begin();
	}

	return iter;
}



/*
============
sdUserInterfaceLocal::FindCachedMaterialForHandle
============
*/
uiMaterialCache_t::Iterator sdUserInterfaceLocal::FindCachedMaterialForHandle( int handle ) {
	if( handle < 0 || handle >= materialCache.Num() ) {
		return materialCache.End();
	}
	
	return materialCache.Begin() + handle;
}

/*
============
sdUserInterfaceLocal::LookupPartSizes
============
*/
void sdUserInterfaceLocal::LookupPartSizes( uiDrawPart_t* parts, int num ) {
	for ( int i= 0; i < num; i++ ) {
		uiDrawPart_t& part = parts[ i ];
		if ( part.mi.material == NULL || ( part.width != 0 && part.height != 0 ) ) {
			continue;
		}

		if ( part.mi.material->GetNumStages() == 0 ) {
			part.mi.material = NULL;
			continue;
		}

		SetupMaterialInfo( part.mi, &part.width, &part.height );

		if ( part.width == 0 || part.height == 0 ) {
			assert( 0 );
			part.mi.material = NULL;
		}		
	}
}

/*
============
sdUserInterfaceLocal::SetupMaterialInfo
============
*/
void sdUserInterfaceLocal::SetupMaterialInfo( uiMaterialInfo_t& mi, int* baseWidth, int* baseHeight ) {
	if( mi.material == NULL ) {		
		return;
	}

	if( const idImage* image = mi.material->GetEditorImage() ) {
		if( image->sourceWidth == 0 ) {	// the image hasn't been loaded yet, so defer texture coordinate calculation
			mi.flags.lookupST = true;
			return;
		}
	}

	if( !mi.flags.lookupST ) {
		return;
	}

	if( const idImage* image = mi.material->GetEditorImage() ) {
		// if they're zeroed assume 0-1 range
		if( mi.st0.Compare( vec2_zero, idMath::FLT_EPSILON ) && mi.st1.Compare( vec2_zero, idMath::FLT_EPSILON ) ) {
			mi.st0.Set( 0.0f, 0.0f );
			mi.st1.Set( 1.0f, 1.0f );

			if( baseWidth != NULL ) {
				*baseWidth = image->sourceWidth;
			}
			if( baseHeight != NULL ) {
				*baseHeight = image->sourceHeight;
			}
		} else {
			if( baseWidth != NULL ) {
				*baseWidth = idMath::Ftoi( mi.st1.x );
			}
			if( baseHeight != NULL ) {
				*baseHeight = idMath::Ftoi( mi.st1.y );
			}

			mi.st0.x = mi.st0.x / static_cast< float >( image->sourceWidth );
			mi.st0.y = mi.st0.y / static_cast< float >( image->sourceHeight );

			mi.st1.x = mi.st0.x + ( mi.st1.x / static_cast< float >( image->sourceWidth ) );
			mi.st1.y = mi.st0.y + ( mi.st1.y / static_cast< float >( image->sourceHeight ) );
		}		
	}
	if( mi.flags.flipX ) {
		idSwap( mi.st0.x, mi.st1.x );
	}
	if( mi.flags.flipY ) {
		idSwap( mi.st0.y, mi.st1.y );
	}

	mi.flags.lookupST = false;
}

/*
============
sdUserInterfaceLocal::ParseMaterial
============
*/
int sdUserInterfaceLocal::ParseMaterial( const char* mat, idStr& outMaterial, bool& globalLookup, bool& literal, uiDrawMode_e& mode ) {
	idLexer src( mat, idStr::Length( mat ), "ParseMaterial", LEXFL_ALLOWPATHNAMES );
	idToken token;

	outMaterial.Empty();
	globalLookup = false;
	literal = false;

	mode = BDM_SINGLE_MATERIAL;

	int materialStart = 0;

	while( !src.HadError() ) {
		materialStart = src.GetFileOffset();
		if( !src.ReadToken( &token )) {
			break;
		}

		if( token.Icmp( "literal:" ) == 0 ) {
			literal = true;
			continue;
		}

		if( token.Icmp( "_frame" ) == 0 ) {
			mode = BDM_FRAME;
			continue;
		}

		if( token.Icmp( "_st" ) == 0 ) {
			mode = BDM_USE_ST;
			continue;
		}

		if( token.Icmp( "_3v" ) == 0 ) {
			mode = BDM_TRI_PART_V;
			continue;
		}

		if( token.Icmp( "_3h" ) == 0 ) {
			mode = BDM_TRI_PART_H;
			continue;
		}

		if( token.Icmp( "_5h" ) == 0 ) {
			mode = BDM_FIVE_PART_H;
			continue;
		}

		if( token == "::" ) {
			globalLookup = true;
			continue;
		}	
		outMaterial = token;
		break;
	}
	return materialStart;
}


/*
============
sdUserInterfaceLocal::InitPartsForBaseMaterial
============
*/
void sdUserInterfaceLocal::InitPartsForBaseMaterial( const char* material, uiCachedMaterial_t& cached ) {
	cached.parts.SetNum( FP_MAX );

	if( cached.drawMode == BDM_FIVE_PART_H ) {
		SetupPart( cached.parts[ FP_TOPLEFT ],	partNames[ FP_TOPLEFT ], material );
		SetupPart( cached.parts[ FP_LEFT ],		partNames[ FP_LEFT ], material );		// stretched
		SetupPart( cached.parts[ FP_CENTER ],	partNames[ FP_CENTER ], material );
		SetupPart( cached.parts[ FP_RIGHT ],	partNames[ FP_RIGHT ], material );		// stretched
		SetupPart( cached.parts[ FP_TOPRIGHT ], partNames[ FP_TOPRIGHT ], material );		
		return;
	}

	if( cached.drawMode == BDM_TRI_PART_H ) {
		SetupPart( cached.parts[ FP_LEFT ], partNames[ FP_LEFT ], material );
		SetupPart( cached.parts[ FP_RIGHT ], partNames[ FP_RIGHT ], material );
		SetupPart( cached.parts[ FP_CENTER ], partNames[ FP_CENTER ], material );
		return;
	}

	if( cached.drawMode == BDM_TRI_PART_V ) {
		SetupPart( cached.parts[ FP_TOP ], partNames[ FP_TOP ], material );
		SetupPart( cached.parts[ FP_BOTTOM ], partNames[ FP_BOTTOM ], material );
		SetupPart( cached.parts[ FP_CENTER ], partNames[ FP_CENTER ], material );
		return;
	}

	for( int i = 0; i < FP_MAX; i++ ) {
		SetupPart( cached.parts[ i ], partNames[ i ], material );
	}
}


/*
============
sdUserInterfaceLocal::SetupPart
============
*/
void sdUserInterfaceLocal::SetupPart( uiDrawPart_t& part, const char* partName, const char* material ) {
	if( idStr::Length( material ) == 0 ) {
		part.mi.material = NULL;
		part.width = 0;
		part.height = 0;
		return;
	}

	LookupMaterial( va( "%s_%s", material, partName ), part.mi, &part.width, &part.height );

	if( part.mi.material->GetNumStages() == 0 ) {
		part.mi.material = NULL;
		part.width = 0;
		part.height = 0;
		return;
	}
}

/*
============
sdUserInterfaceLocal::LookupMaterial
============
*/
void sdUserInterfaceLocal::LookupMaterial( const char* materialName, uiMaterialInfo_t& mi, int* baseWidth, int* baseHeight ) {
	mi.Clear();

	bool globalLookup = false;
	static const char* LITERAL_ID = "literal:";
	static const int LITERAL_ID_LENGTH = idStr::Length( LITERAL_ID );
	bool literal = !idStr::Icmpn( LITERAL_ID, materialName, LITERAL_ID_LENGTH );

	if( !literal ) {
		globalLookup = !idStr::Icmpn( "::", materialName, 2 );
		if( globalLookup ) {
			materialName += 2;
		}
	}

	if( globalLookup ) {
		if(idStr::Length( materialName ) == 0 ) {
			mi.material = declHolder.FindMaterial( "_default" );
		} else {
			mi.material = declHolder.FindMaterial( materialName );
		}
	} else {
		const char* materialInfo = materialName;
		if( literal ) {
			materialInfo += LITERAL_ID_LENGTH;
		} else {
			materialInfo = GetMaterial( materialName );
		}
		idToken token;
		char buffer[128];
		token.SetStaticBuffer( buffer, sizeof(buffer) );
		idLexer src( materialInfo, idStr::Length( materialInfo ), "LookupMaterial", LEXFL_ALLOWPATHNAMES );

		src.ReadToken( &token );	// material name

		if( token.Length() == 0 ) {
			mi.material = declHolder.FindMaterial( "_default" );
		} else {
			mi.material = declHolder.FindMaterial( token );
		}

		while( src.ReadToken( &token )) {
			if( token == "," ) {
				continue;
			}
			if( token.Icmp( "flipX" ) == 0 ) {
				mi.flags.flipX = true;
				continue;
			}
			if( token.Icmp( "flipY" ) == 0 ) {
				mi.flags.flipY = true;
				continue;
			}
			static idVec4 vec;
			if( token.Icmp( "rect" ) == 0 ) {
				src.Parse1DMatrix( 4, vec.ToFloatPtr(), true );
				mi.st0.x = vec.x;
				mi.st0.y = vec.y;
				mi.st1.x = vec.z;
				mi.st1.y = vec.w;
				continue;
			}
			src.Error( "Unknown token '%s'", token.c_str() );
			break;
		}
	}


	if ( mi.material->GetSort() < SS_POST_PROCESS ) {
		if ( mi.material->GetSort() != SS_GUI && mi.material->GetSort() != SS_NEAREST ) {
			gameLocal.Warning( "LookupMaterial: '%s' material '%s' (alias '%s') used without proper sort", GetName(), mi.material->GetName(), materialName );
		}
	}

	mi.flags.lookupST = true;
	SetupMaterialInfo( mi, baseWidth, baseHeight );
}

/*
============
sdUserInterfaceLocal::PushColor
============
*/
void sdUserInterfaceLocal::PushColor( const idVec4& color ) {
	currentColor = color;
	colorStack.Push( deviceContext->SetColorMultiplier( color ) );
}

/*
============
sdUserInterfaceLocal::PopColor
============
*/
idVec4 sdUserInterfaceLocal::PopColor() {
	idVec4 c = colorStack.Top();
	deviceContext->SetColorMultiplier( c );
	colorStack.Pop();
	currentColor = c;
	return c;
}

/*
============
sdUserInterfaceLocal::TopColor
============
*/
const idVec4& sdUserInterfaceLocal::TopColor() const{
	return currentColor;
}


/*
============
sdUserInterfaceLocal::OnSnapshotHitch
============
*/
void sdUserInterfaceLocal::OnSnapshotHitch( int delta ) {
	scriptState.OnSnapshotHitch( delta );
	if( timelines.IsValid() ) {
		timelines->OnSnapshotHitch( delta );
	}
}

/*
============
sdUserInterfaceLocal::OnToolTipEvent
============
*/
void sdUserInterfaceLocal::OnToolTipEvent( const char* arg ) {
	sdUIEventInfo event( GE_TOOLTIPEVENT, 0 );

	if ( event.eventType.IsValid() ) {
		PushScriptVar( arg );
		RunEvent( sdUIEventInfo( GE_TOOLTIPEVENT, 0 ) );		
		ClearScriptStack();
	}
}