// 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 "UserInterfaceManager.h"
#include "UIWindow.h"
#include "UserInterfaceLocal.h"
#include "../../decllib/declTypeHolder.h"
#include "../../renderer/Image.h"

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

using namespace sdProperties;

#define INIT_SCRIPT_FUNCTION( SCRIPTNAME, RETURN, PARMS, FUNCTION ) windowFunctions.Set( SCRIPTNAME, new sdUITemplateFunction< sdUIWindow >( RETURN, PARMS, &sdUIWindow::FUNCTION ) );

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

	sdUIWindow

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

/*
============
sdUIWindow::InitFunctions
============
*/
#pragma inline_depth( 0 )
#pragma optimize( "", off )
SD_UI_PUSH_CLASS_TAG( sdUIWindow )
void sdUIWindow::InitFunctions( void ) {
	SD_UI_FUNC_TAG( attachRenderCallback, "Attach a render callback to the drawing of the window." )
		SD_UI_FUNC_PARM( string, "callbackName", "Name of the render callback." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "attachRenderCallback", 'v', "s", Script_AttachRenderCallback );

	SD_UI_FUNC_TAG( attachInputHandler, "Attach an input handler for the window." )
		SD_UI_FUNC_PARM( string, "inputHandlerName", "Name of the input handler callback." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "attachInputHandler", 'v', "s", Script_AttachInputHandler );

	SD_UI_FUNC_TAG( drawMaterial, "Draw a material." )
		SD_UI_FUNC_PARM( string, "materialName", "Material name." )
		SD_UI_FUNC_PARM( rect, "rectangle", "The rectangle where we draw the material." )
		SD_UI_FUNC_PARM( color, "materialColor", "The color to use." )
		SD_UI_FUNC_PARM( vec2, "offset", "Texture offset." )
		SD_UI_FUNC_PARM( vec2, "scale", "Texture scale." )
		SD_UI_FUNC_PARM( float, "angle", "Angle to draw." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawMaterial", 'v', "s4422f", Script_DrawMaterial );

	SD_UI_FUNC_TAG( drawRenderCallback, "Call the draw render callback for the given render callback handle." )
		SD_UI_FUNC_PARM( handle, "renderCallback", "Render callback handle." )
		SD_UI_FUNC_PARM( rect, "drawRect", "Draw rectangle." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawRenderCallback", 'v', "i4", Script_DrawRenderCallback );

	SD_UI_FUNC_TAG( drawCachedMaterial, "Draw cached material." )
		SD_UI_FUNC_PARM( handle, "materialHandle", "Material handle." )
		SD_UI_FUNC_PARM( rect, "rectangle", "Rectangle to draw in." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawCachedMaterial", 'v', "i44", Script_DrawCachedMaterial );

	SD_UI_FUNC_TAG( getCachedMaterialDimensions, "Get the width and height of the material." )
		SD_UI_FUNC_PARM( handle, "materialHandle", "Material handle." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "getCachedMaterialDimensions", '2', "i", Script_GetCachedMaterialDimensions );

	SD_UI_FUNC_TAG( drawMaterialInfo, "Draw material. Get data from the material info." )
		SD_UI_FUNC_PARM( handle, "material", "Material name." )
		SD_UI_FUNC_PARM( rect, "rectangle", "Rectangle to draw in." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawMaterialInfo", 'v', "s44", Script_DrawMaterialInfo );

	SD_UI_FUNC_TAG( drawMaterialArc, "Draw an arc." )
		SD_UI_FUNC_PARM( string, "material", "Material name." )
		SD_UI_FUNC_PARM( vec2, "origin", "Origin where arc is drawn from." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
		SD_UI_FUNC_PARM( float, "radius", "Radius of arc." )
		SD_UI_FUNC_PARM( float, "start", "Starting angle." )
		SD_UI_FUNC_PARM( float, "percent", "Percent of coverage." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawMaterialArc", 'v', "s24fff", Script_DrawMaterialArc );

	SD_UI_FUNC_TAG( drawTimer, "Draw a timer, used by the grenade indicator and progress indicators by the crosshair." )
		SD_UI_FUNC_PARM( handle, "materialHandle", "Material handle." )
		SD_UI_FUNC_PARM( rect, "rectangle", "Position and size of timer." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
		SD_UI_FUNC_PARM( float, "percent", "Percent complete, between 0 and 1." )
		SD_UI_FUNC_PARM( float, "invert", "Invert the direction of the timer." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawTimer", 'v', "i44ff", Script_DrawTimer );

	SD_UI_FUNC_TAG( drawText, "Draw text." )
		SD_UI_FUNC_PARM( wstring, "text", "Text to be drawn." )
		SD_UI_FUNC_PARM( rect, "rectangle", "rectangle to draw text in." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
		SD_UI_FUNC_PARM( float, "scale", "Text scale." )
		SD_UI_FUNC_PARM( float, "flags", "Draw text flags." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawText", 'v', "w44ff", Script_DrawText );

	SD_UI_FUNC_TAG( measureText, "Measure the text." )
		SD_UI_FUNC_PARM( wstring, "text", "Text to measure." )
		SD_UI_FUNC_PARM( rect, "rectangle", "rectangle to draw text in." )
		SD_UI_FUNC_PARM( float, "scale", "Text scale." )
		SD_UI_FUNC_PARM( float, "flags", "Draw text flags." )
		SD_UI_FUNC_RETURN_PARM( vec2, "The width and height of the text measured." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "measureText", '2', "w4ff", Script_MeasureText );

	SD_UI_FUNC_TAG( measureLocalizedText, "Measure the text." )
		SD_UI_FUNC_PARM( handle, "textHandle", "Handle to text to measure." )
		SD_UI_FUNC_PARM( rect, "rectangle", "rectangle to draw text in." )
		SD_UI_FUNC_PARM( float, "scale", "Text scale." )
		SD_UI_FUNC_PARM( float, "flags", "Draw text flags." )
		SD_UI_FUNC_RETURN_PARM( vec2, "The width and height of the text measured." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "measureLocalizedText", '2', "i4ff", Script_MeasureLocalizedText );

	SD_UI_FUNC_TAG( drawTiledMaterial, "Draw a tiled material." )
		SD_UI_FUNC_PARM( handle, "textHandle", "Handle to text to measure." )
		SD_UI_FUNC_PARM( rect, "rectangle", "rectangle to draw text in." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
		SD_UI_FUNC_PARM( vec2, "repeats", "Number of X/Y repeats." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawTiledMaterial", 'v', "i442", Script_DrawTiledMaterial );

	SD_UI_FUNC_TAG( drawLocalizedText, "Text to be drawn." )
		SD_UI_FUNC_PARM( handle, "textHandle", "Handle to text to be drawn." )
		SD_UI_FUNC_PARM( rect, "rectangle", "rectangle to draw text in." )
		SD_UI_FUNC_PARM( color, "materialColor", "Color of the material." )
		SD_UI_FUNC_PARM( float, "scale", "Text scale." )
		SD_UI_FUNC_PARM( float, "flags", "Draw text flags." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawLocalizedText", 'v', "i44ff", Script_DrawLocalizedText );

	SD_UI_FUNC_TAG( drawLine, "Draw a line." )
		SD_UI_FUNC_PARM( vec2, "start", "Line start." )
		SD_UI_FUNC_PARM( vec2, "end", "Line end." )
		SD_UI_FUNC_PARM( color, "lineColor", "Line color." )
		SD_UI_FUNC_PARM( float, "width", "Line width." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawLine", 'v', "224f", Script_DrawLine );

	SD_UI_FUNC_TAG( requestLayout, "Request the window layout to be calculated again." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "requestLayout", 'v', "", Script_RequestLayout );

	SD_UI_FUNC_TAG( drawRect, "Draw a rectangle." )
		SD_UI_FUNC_PARM( rect, "rectangle", "Rectangle to draw." )
		SD_UI_FUNC_PARM( color, "rectangleColor", "Rectangle color." )
		SD_UI_FUNC_PARM( float, "borderWidth", "Width of the border." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawRect", 'v', "44f", Script_DrawRect );

	SD_UI_FUNC_TAG( nextTabStop, "Get the next tab stop for the specified window." )
		SD_UI_FUNC_PARM( string, "window", "Window name." )
		SD_UI_FUNC_RETURN_PARM( string, "The name of the next tab stop window or self.name if there are no other tab stops." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "nextTabStop", 's', "s", Script_NextTabStop );

	SD_UI_FUNC_TAG( prevTabStop, "Get the previous tab stop for the specified window." )
		SD_UI_FUNC_PARM( string, "window", "Window name." )
		SD_UI_FUNC_RETURN_PARM( string, "The name of the previous tab stop window or self.name if there are no other tab stops." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "prevTabStop", 's', "s", Script_PrevTabStop );

	SD_UI_FUNC_TAG( setTabStop, "Focuses the nth tab stop." )
		SD_UI_FUNC_PARM( float, "tabIndex", "Tab stop to focus." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "setTabStop", 'v', "f", Script_SetTabStop );

	SD_UI_FUNC_TAG( containsPoint, "Checks if the (world-based) point is in the client rectangle." )
		SD_UI_FUNC_PARM( rect, "rectangle", "Client rectangle." )
		SD_UI_FUNC_PARM( float, "screenX", "X position." )
		SD_UI_FUNC_PARM( float, "screenY", "Y position." )
		SD_UI_FUNC_RETURN_PARM( float, "Return 1 if screenX,screenY is within the client rectangle." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "containsPoint", 'f', "4ff", Script_ContainsPoint );

	SD_UI_FUNC_TAG( cacheRenderCallback, "Return a reference to a render callback." )
		SD_UI_FUNC_PARM( string, "callbackName", "Name of the render callback." )
		SD_UI_FUNC_RETURN_PARM( string, "Reference to the render callback." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "cacheRenderCallback", 'i', "s", Script_CacheRenderCallback );

	SD_UI_FUNC_TAG( clipToRect, "Clip subsequent drawing to the clipping rectangle. Must be ended with unclipRect after clipped drawing is finished." )
		SD_UI_FUNC_PARM( rect, "clipRectangle", "Clipping rectangle." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "clipToRect", 'v', "4", Script_ClipToRect );

	SD_UI_FUNC_TAG( unclipRect, "Remove clipping to rectangle specified in clipToRect." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "unclipRect", 'v', "", Script_UnclipRect );

	SD_UI_FUNC_TAG( pushColor, "Push a color on the GUI's color stack." )
		SD_UI_FUNC_PARM( color, "pushColor", "Color to push." )
		SD_UI_FUNC_PARM( float, "inherit", "If not 0, multiply the color with the color on the top of the color stack before pushing." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "pushColor", 'v', "4f", Script_PushColor );

	SD_UI_FUNC_TAG( pushColorComponents, "Push a color on the GUI's color stack." )
		SD_UI_FUNC_PARM( float, "R", "Red." )
		SD_UI_FUNC_PARM( float, "G", "Green." )
		SD_UI_FUNC_PARM( float, "B", "Blue." )
		SD_UI_FUNC_PARM( float, "A", "Alpha." )
		SD_UI_FUNC_PARM( float, "inherit", "If not 0, multiply the color with the color on the top of the color stack before pushing." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "pushColorComponents", 'v', "fffff", Script_PushColor );				// r,g,b,a, inherit previous alpha	(not a C&P error, just different ways of getting the same inputs)
	
	SD_UI_FUNC_TAG( popColor, "Pop a color from the GUI's color stack." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "popColor", 'v', "", Script_PopColor );

	SD_UI_FUNC_TAG( drawShaderParm, "Set a shader parm value." )
		SD_UI_FUNC_PARM( float, "index", "Shader parameter index." )
		SD_UI_FUNC_PARM( float, "value", "Shader parameter value." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "drawShaderParm", 'v', "ff", Script_SetShaderParm );

	SD_UI_FUNC_TAG( isVisible, "Check if self is visible." )
		SD_UI_FUNC_RETURN_PARM( float, "Returns false if self or any parents are hidden." )
	SD_UI_END_FUNC_TAG
	INIT_SCRIPT_FUNCTION( "isVisible", 'f', "", Script_IsVisible );

	SD_UI_PUSH_GROUP_TAG( "Text Align Flags" )

	SD_UI_ENUM_TAG( TA_LEFT, "Left align text." )
	sdDeclGUI::AddDefine( va( "TA_LEFT %i", TA_LEFT ) );
	SD_UI_ENUM_TAG( TA_CENTER, "Center align text." )
	sdDeclGUI::AddDefine( va( "TA_CENTER %i", TA_CENTER ) );
	SD_UI_ENUM_TAG( TA_RIGHT, "Right align text." )
	sdDeclGUI::AddDefine( va( "TA_RIGHT %i", TA_RIGHT ) );

	SD_UI_ENUM_TAG( TA_TOP, "Align to the top." )
	sdDeclGUI::AddDefine( va( "TA_TOP %i", TA_TOP ) );
	SD_UI_ENUM_TAG( TA_VCENTER, "Align to the vertical center." )
	sdDeclGUI::AddDefine( va( "TA_VCENTER %i", TA_VCENTER ) );
	SD_UI_ENUM_TAG( TA_BOTTOM, "Align to the bottom." )
	sdDeclGUI::AddDefine( va( "TA_BOTTOM %i", TA_BOTTOM ) );

	SD_UI_POP_GROUP_TAG
	SD_UI_PUSH_GROUP_TAG( "Window Flags" )

	SD_UI_ENUM_TAG( WF_CLIP_TO_RECT, "Clip all drawing to the window rectangle." )
	sdDeclGUI::AddDefine( va( "WF_CLIP_TO_RECT %i", WF_CLIP_TO_RECT ) );
	SD_UI_ENUM_TAG( WF_COLOR_ESCAPES, "Parse color escapes when drawing text." )
	sdDeclGUI::AddDefine( va( "WF_COLOR_ESCAPES %i", WF_COLOR_ESCAPES ) );
	SD_UI_ENUM_TAG( WF_CAPTURE_KEYS, "Capture all key events even if the window does not have focus." )
	sdDeclGUI::AddDefine( va( "WF_CAPTURE_KEYS %i", WF_CAPTURE_KEYS ) );
	SD_UI_ENUM_TAG( WF_CAPTURE_MOUSE, "Capture mouse click events even if mouse is not inside the window. Capture mouse movement even when window does not have focus." )
	sdDeclGUI::AddDefine( va( "WF_CAPTURE_MOUSE %i", WF_CAPTURE_MOUSE ) );
	SD_UI_ENUM_TAG( WF_WRAP_TEXT, "Wrap text if wider than rectangle width." )
	sdDeclGUI::AddDefine( va( "WF_WRAP_TEXT %i", WF_WRAP_TEXT ) );
	SD_UI_ENUM_TAG( WF_MULTILINE_TEXT, "Support line breaks." )
	sdDeclGUI::AddDefine( va( "WF_MULTILINE_TEXT %i", WF_MULTILINE_TEXT ) );
	SD_UI_ENUM_TAG( WF_AUTO_SIZE_WIDTH, "Resize the width to fit all the text inside the rectangle. Recalculated when the window layout is dirty." )
	sdDeclGUI::AddDefine( va( "WF_AUTO_SIZE_WIDTH %i", WF_AUTO_SIZE_WIDTH ) );
	SD_UI_ENUM_TAG( WF_AUTO_SIZE_HEIGHT, "Resize the height to fit all the text inside the rectangle. Recalculated when the window layout is dirty." )
	sdDeclGUI::AddDefine( va( "WF_AUTO_SIZE_HEIGHT %i", WF_AUTO_SIZE_HEIGHT ) );
	SD_UI_ENUM_TAG( WF_ALLOW_FOCUS, "Allow window to have focus." )
	sdDeclGUI::AddDefine( va( "WF_ALLOW_FOCUS %i", WF_ALLOW_FOCUS ) );
	SD_UI_ENUM_TAG( WF_TAB_STOP, "Should stop at window when using tab to cycle focus window." )
	sdDeclGUI::AddDefine( va( "WF_TAB_STOP %i", WF_TAB_STOP ) );
	SD_UI_ENUM_TAG( WF_TRUNCATE_TEXT, "Truncate with ... if text goes outside the rectangle. WF_MULTILINE_TEXT and WF_WRAP_TEXT must not be specified for this flag to have an effect." )
	sdDeclGUI::AddDefine( va( "WF_TRUNCATE_TEXT %i",	WF_TRUNCATE_TEXT ) );
	SD_UI_ENUM_TAG( WF_INHERIT_PARENT_COLORS, "Multiply colorMultiplier with the parent's color before pushing on the color stack." )
	sdDeclGUI::AddDefine( va( "WF_INHERIT_PARENT_COLORS %i",	WF_INHERIT_PARENT_COLORS ) );
	SD_UI_ENUM_TAG( WF_DROPSHADOW, "Add a drop shadow to the text." )
	sdDeclGUI::AddDefine( va( "WF_DROPSHADOW %i",	WF_DROPSHADOW ) );

	SD_UI_POP_GROUP_TAG
	SD_UI_PUSH_GROUP_TAG( "Draw Text Flags" )

	SD_UI_ENUM_TAG( DTF_TOP, "Align to the top." )
	sdDeclGUI::AddDefine( va( "DTF_TOP %i",		DTF_TOP ) );
	SD_UI_ENUM_TAG( DTF_VCENTER, "Align to the vertical center." )
	sdDeclGUI::AddDefine( va( "DTF_VCENTER %i", DTF_VCENTER ) );
	SD_UI_ENUM_TAG( DTF_BOTTOM, "Align to the bottom." )
	sdDeclGUI::AddDefine( va( "DTF_BOTTOM %i",	DTF_BOTTOM ) );

	SD_UI_ENUM_TAG( DTF_LEFT, "Align text to the left." )
	sdDeclGUI::AddDefine( va( "DTF_LEFT %i",	DTF_LEFT ) );
	SD_UI_ENUM_TAG( DTF_CENTER, "Center align text." )
	sdDeclGUI::AddDefine( va( "DTF_CENTER %i",	DTF_CENTER ) );
	SD_UI_ENUM_TAG( DTF_RIGHT, "Align text to the right." )
	sdDeclGUI::AddDefine( va( "DTF_RIGHT %i",	DTF_RIGHT ) );

	SD_UI_ENUM_TAG( DTF_SINGLELINE, "Single line text only." )
	sdDeclGUI::AddDefine( va( "DTF_SINGLELINE %i",	DTF_SINGLELINE ) );
	SD_UI_ENUM_TAG( DTF_WORDWRAP, "Wrap the text to the next line if longer than the rectangle width." )
	sdDeclGUI::AddDefine( va( "DTF_WORDWRAP %i",	DTF_WORDWRAP ) );
	SD_UI_ENUM_TAG( DTF_DROPSHADOW, "Add a drop shadow to the text." )
	sdDeclGUI::AddDefine( va( "DTF_DROPSHADOW %i",	DTF_DROPSHADOW ) );
	SD_UI_ENUM_TAG( DTF_TRUNCATE, "Truncate with ... if text goes outside the rectangle. DTF_SINGLELINE must also be specified for this flag to have an effect." )
	sdDeclGUI::AddDefine( va( "DTF_TRUNCATE %i",	DTF_TRUNCATE ) );

	SD_UI_POP_GROUP_TAG
}
SD_UI_POP_CLASS_TAG
#pragma optimize( "", on )
#pragma inline_depth()

/*
============
sdUIWindow::Script_AttachRenderCallback
============
*/
void sdUIWindow::Script_AttachRenderCallback( sdUIFunctionStack& stack ) {
	idStr name;
	stack.Pop( name );
	
	uiManager->SetRenderCallback( this, name );
}

/*
============
sdUIWindow::Script_AttachInputHandler
============
*/
void sdUIWindow::Script_AttachInputHandler( sdUIFunctionStack& stack ) {
	idStr name;
	stack.Pop( name );
	
	uiManager->SetInputHandler( this, name );
}

/*
============
sdUIWindow::Script_DrawMaterial
============
*/
void sdUIWindow::Script_DrawMaterial( sdUIFunctionStack& stack ) {
	idStr	material;
	idVec4	rect;
	idVec4	color;
	idVec2	shift;
	idVec2	scale;
	float	angle;

	stack.Pop( material );
	stack.Pop( rect );
	stack.Pop( color );
	stack.Pop( shift );
	stack.Pop( scale );
	stack.Pop( angle );

	uiMaterialInfo_t mi;
	GetUI()->LookupMaterial( material, mi );	
	deviceContext->DrawMaterial( rect, mi.material, color, scale, shift, angle );
}

/*
============
sdUIWindow::Script_DrawMaterialInfo
============
*/
void sdUIWindow::Script_DrawMaterialInfo( sdUIFunctionStack& stack ) {
	idStr	material;
	idVec4	rect;
	idVec4	color;

	stack.Pop( material );
	stack.Pop( rect );
	stack.Pop( color );

	uiMaterialInfo_t mi;
	idStr outMaterial;

	GetUI()->LookupMaterial( material, mi );
	DrawMaterial( mi, rect.x, rect.y, rect.z, rect.w, color );
}

/*
============
sdUIWindow::Script_DrawRect
============
*/
void sdUIWindow::Script_DrawRect( sdUIFunctionStack& stack ) {
	idVec4	rect;
	idVec4	color;
	float	size;

	stack.Pop( rect );
	stack.Pop( color );
	stack.Pop( size );

	if ( size <= 0.0f ) {
		deviceContext->DrawClippedRect( rect.x, rect.y, rect.z, rect.w, color );
	} else {
		deviceContext->DrawClippedBox( rect.x, rect.y, rect.z, rect.w, size, color );
	}
}

/*
============
sdUIWindow::Script_DrawText
============
*/
void sdUIWindow::Script_DrawText( sdUIFunctionStack& stack ) {
	idWStr	text;
	idVec4	rect;
	idVec4	color;
	float	scale;
	float	flags;

	stack.Pop( text );
	stack.Pop( rect );
	stack.Pop( color );
	stack.Pop( scale );
	stack.Pop( flags );

	if( text.IsEmpty() ) {
		return;
	}

	ActivateFont( false );
	
	int iFlags = idMath::Ftoi( flags );

	sdWStringBuilder_Heap  builder;
	const wchar_t* drawText = text.c_str();
	if( ( iFlags & DTF_TRUNCATE ) && ( iFlags & DTF_SINGLELINE ) ) {		

		const wchar_t* truncationText = L"...";
		int truncationWidth;
		int truncationHeight;
		deviceContext->GetTextDimensions( truncationText, sdBounds2D( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT ), DTF_SINGLELINE | DTF_VCENTER | DTF_CENTER, cachedFontHandle, scale, truncationWidth, truncationHeight );

		ShortenText( text.c_str(), sdBounds2D( rect ), cachedFontHandle, iFlags, scale, truncationText, truncationWidth, builder );
		drawText = builder.c_str();
	}
	deviceContext->SetColor( color );
	deviceContext->SetFontSize( scale );
	deviceContext->DrawText( drawText, sdBounds2D( rect ), iFlags );
}

/*
============
sdUIWindow::Script_MeasureText
============
*/
void sdUIWindow::Script_MeasureText( sdUIFunctionStack& stack ) {
	idWStr	text;
	idVec4	rect;
	float	scale;
	float	flags;

	stack.Pop( text );
	stack.Pop( rect );
	stack.Pop( scale );
	stack.Pop( flags );

	if ( text.Length() == 0 ) {
		stack.Push( idVec2( 0.0f, 0.0f ) );
	} else {
		ActivateFont( false );

		int w, h;
		deviceContext->GetTextDimensions( text.c_str(), sdBounds2D( rect ), idMath::Ftoi( flags ), cachedFontHandle, idMath::Ftoi( scale ), w, h );
		stack.Push( idVec2( w, h ) );
	}
}

/*
============
sdUIWindow::Script_MeasureLocalizedText
============
*/
void sdUIWindow::Script_MeasureLocalizedText( sdUIFunctionStack& stack ) {
	int	text;
	idVec4	rect;
	float	scale;
	float	flags;

	stack.Pop( text );
	stack.Pop( rect );
	stack.Pop( scale );
	stack.Pop( flags );

	int w = 0;
	int h = 0;

	ActivateFont( false );

	const sdDeclLocStr* str = declHolder.declLocStrType.LocalFindByIndex( text, false );
	if ( str != NULL && str->GetText()[ 0 ] != L'\0' ) {
		deviceContext->GetTextDimensions( str->GetText(), sdBounds2D( rect ), idMath::Ftoi( flags ), cachedFontHandle, idMath::Ftoi( scale ), w, h );
	}
	
	stack.Push( idVec2( w, h ) );
}

/*
============
sdUIWindow::Script_DrawLocalizedText
============
*/
void sdUIWindow::Script_DrawLocalizedText( sdUIFunctionStack& stack ) {
	int		text;
	idVec4	rect;
	idVec4	color;
	float	scale;
	float	flags;

	stack.Pop( text );
	stack.Pop( rect );
	stack.Pop( color );
	stack.Pop( scale );
	stack.Pop( flags );

	if( text >= 0 && text < declHolder.declLocStrType.Num() ) {
		const wchar_t* textStr = declHolder.FindLocStrByIndex( text )->GetText();

		if( textStr[ 0 ] == L'\0' ) {
			return;
		}

		ActivateFont( false );

		int iFlags = idMath::Ftoi( flags );
		const wchar_t* drawText = textStr;
		sdWStringBuilder_Heap  builder;
		if( ( iFlags & DTF_TRUNCATE ) && ( iFlags & DTF_SINGLELINE ) ) {
			const wchar_t* truncationText = L"...";
			int truncationWidth;
			int truncationHeight;
			deviceContext->GetTextDimensions( truncationText, sdBounds2D( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT ), DTF_SINGLELINE | DTF_VCENTER | DTF_CENTER, cachedFontHandle, scale, truncationWidth, truncationHeight );

			ShortenText(textStr, sdBounds2D( rect ), cachedFontHandle, iFlags, scale, truncationText, truncationWidth, builder );
			drawText = builder.c_str();
		}
		
		deviceContext->SetColor( color );
		deviceContext->SetFontSize( scale );
		deviceContext->DrawText( drawText, sdBounds2D( rect ), iFlags );
	}	
}


/*
============
sdUIWindow::Script_DrawLine
============
*/
void sdUIWindow::Script_DrawLine( sdUIFunctionStack& stack ) {
	idVec2	start;
	idVec2	end;
	idVec4	color;
	float	width;

	stack.Pop( start );
	stack.Pop( end );
	stack.Pop( color );
	stack.Pop( width );

	deviceContext->DrawLine( start, end, width, color );
}

/*
============
sdUIWindow::Script_DrawMaterialArc
============
*/
void sdUIWindow::Script_DrawMaterialArc( sdUIFunctionStack& stack ) {
	idStr material;
	idVec2 origin;
	float radius;
	float percent;
	float start;
	idVec4 color;

	stack.Pop( material );
	stack.Pop( origin );
	stack.Pop( color );
	stack.Pop( radius );
	stack.Pop( start );
	stack.Pop( percent );

	uiMaterialInfo_t mi;
	GetUI()->LookupMaterial( material, mi );
	deviceContext->DrawFilledArc( origin.x, origin.y, radius, 32, percent, color, start, mi.material );
}

/*
============
sdUIWindow::Script_RequestLayout
============
*/
void sdUIWindow::Script_RequestLayout( sdUIFunctionStack& stack ) {
	MakeLayoutDirty();
}

/*
============
sdUIWindow::Script_NextTabStop
============
*/
void sdUIWindow::Script_NextTabStop( sdUIFunctionStack& stack ) {
	idStr currentItem;
	stack.Pop( currentItem );

	const sdUIObject* targetChild = GetUI()->GetWindow( currentItem.c_str() );
	if( targetChild == NULL ) {
		stack.Push( "" );
		return;
	}

	int numTabStops = NumTabStops_r( this );
	if( numTabStops == 0 ) {
		stack.Push( "" );
		return;
	}

	int index = 0;
	const sdUIObject** tabStops = static_cast< const sdUIObject** >( _alloca( numTabStops * sizeof( const sdUIObject* )) );
	ListTabStops_r( this, tabStops, index );

	int i;
	for( i = 0; i < numTabStops; i++ ) {
		if( tabStops[ i ] == targetChild ) {
			break;
		}
	}
	if( i < numTabStops - 1 ) {
		i++;
	} else {
		i = 0;
	}
	const sdUIObject* tabStop = tabStops[ i ];

	assert( tabStop != NULL );
	stack.Push( tabStop->name.GetValue().c_str() );

	if( sdUserInterfaceLocal::g_debugGUIEvents.GetInteger() ) {
		gameLocal.Printf( "NextTabStop: Found '%s'\n", tabStop->name.GetValue().c_str() );
	}
}

/*
============
sdUIWindow::Script_PrevTabStop
============
*/
void sdUIWindow::Script_PrevTabStop( sdUIFunctionStack& stack ) {
	idStr currentItem;
	stack.Pop( currentItem );

	const sdUIObject* targetChild = GetUI()->GetWindow( currentItem.c_str() );
	if( targetChild == NULL ) {
		stack.Push( "" );
		return;
	}

	int numTabStops = NumTabStops_r( this );
	if( numTabStops == 0 ) {
		stack.Push( "" );
		return;
	}

	int index = 0;
	const sdUIObject** tabStops = static_cast< const sdUIObject** >( _alloca( numTabStops * sizeof( const sdUIObject* )) );
	ListTabStops_r( this, tabStops, index );

	int i;
	for( i = numTabStops - 1; i >= 0; i-- ) {
		if( tabStops[ i ] == targetChild ) {
			break;
		}
	}
	if( i > 0 ) {
		i--;
	} else {
		i = numTabStops - 1;
	}
	const sdUIObject* tabStop = tabStops[ i ];

	stack.Push( tabStop->name.GetValue().c_str() );

	if( sdUserInterfaceLocal::g_debugGUIEvents.GetInteger() ) {
		gameLocal.Printf( "PrevTabStop: Found '%s'\n", tabStop->name.GetValue().c_str() );
	}
}

/*
============
sdUIWindow::Script_SetTabStop
============
*/
void sdUIWindow::Script_SetTabStop( sdUIFunctionStack& stack ) {
	int targetIndex;
	stack.Pop( targetIndex );

	if( targetIndex < 0 ) {
		gameLocal.Warning( "Script_SetTabStop: '%s' '%i' out of range", name.GetValue().c_str(), targetIndex );
		return;
	}

	int numTabStops = NumTabStops_r( this );
	if( numTabStops == 0 ) {
		return;
	}

	int index = 0;
	const sdUIObject** tabStops = static_cast< const sdUIObject** >( _alloca( numTabStops * sizeof( const sdUIObject* )) );
	ListTabStops_r( this, tabStops, index );
	if( targetIndex < numTabStops ) {
		GetUI()->focusedWindowName = tabStops[ targetIndex ]->name;
		return;
	}

	gameLocal.Warning( "Script_SetTabStop: '%s' '%i' out of range", name.GetValue().c_str(), index );
}

/*
============
sdUIWindow::Script_ContainsPoint
============
*/
void sdUIWindow::Script_ContainsPoint( sdUIFunctionStack& stack ) {
	idVec4 rect;
	stack.Pop( rect );

	idVec2 point;
	stack.Pop( point );	
	
	sdBounds2D bounds( rect );
	bool contained = bounds.ContainsPoint( point );
	stack.Push( contained ? 1.0f : 0.0f );
}

/*
============
sdUIWindow::Script_DrawCachedMaterial
============
*/
void sdUIWindow::Script_DrawCachedMaterial( sdUIFunctionStack& stack ) {
	int		handle;
	idVec4	rect;
	idVec4	color;

	stack.Pop( handle );
	stack.Pop( rect );
	stack.Pop( color );
		
	uiMaterialCache_t::Iterator iter = GetUI()->FindCachedMaterialForHandle( handle );
	if( !GetUI()->IsValidMaterial( iter ) ) {
		//assert( 0 );
		return;
	}

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

	switch( cached.drawMode ) {
		case BDM_USE_ST:
		case BDM_SINGLE_MATERIAL:
			DrawMaterial( cached.material, rect.x, rect.y, rect.z, rect.w, color );
			break;
		case BDM_FRAME:
		case BDM_TRI_PART_H:	// FALL THROUGH
		case BDM_TRI_PART_V:	// FALL THROUGH
		case BDM_FIVE_PART_H:	// FALL THROUGH
			DrawFrame( rect, iter, color );
			break;
	}	
}

/*
============
sdUIWindow::Script_DrawTiledMaterial
============
*/
void sdUIWindow::Script_DrawTiledMaterial( sdUIFunctionStack& stack ) {
	int		handle;
	idVec4	rect;
	idVec4	color;
	idVec2	repeats;

	stack.Pop( handle );
	stack.Pop( rect );
	stack.Pop( color );
	stack.Pop( repeats );

	uiMaterialCache_t::Iterator iter = GetUI()->FindCachedMaterialForHandle( handle );
	if( !GetUI()->IsValidMaterial( iter ) ) {
		//assert( 0 );
		return;
	}

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

	int xRepeat = idMath::Ftoi( repeats.x );
	int yRepeat = idMath::Ftoi( repeats.y );

	idVec4 drawRect = rect;
	for( int x = 0; x < xRepeat; x++ ) {
		drawRect.x = rect.x + ( x * rect.z );
		for( int y = 0; y < yRepeat; y++ ) {			
			drawRect.y = rect.y + ( y * rect.w );
			switch( cached.drawMode ) {
			case BDM_USE_ST:
			case BDM_SINGLE_MATERIAL:
				DrawMaterial( cached.material, drawRect.x, drawRect.y, drawRect.z, drawRect.w, color );
				break;
			case BDM_FRAME:
			case BDM_TRI_PART_H:	// FALL THROUGH
			case BDM_TRI_PART_V:	// FALL THROUGH
			case BDM_FIVE_PART_H:	// FALL THROUGH
				DrawFrame( drawRect, iter, color );
				break;
			}
		}
	}
}

/*
============
sdUIWindow::Script_DrawRenderCallback
============
*/
void sdUIWindow::Script_DrawRenderCallback ( sdUIFunctionStack& stack ) {
	int callbackHandle;
	stack.Pop( callbackHandle );

	idVec4 rect;
	stack.Pop( rect );
	 
	uiRenderCallback_t callback = uiManager->GetRenderCallback( callbackHandle );
	if( callback != NULL ) {
		callback( GetUI(), rect.x, rect.y, rect.z, rect.w );
	}
}

/*
============
sdUIWindow::Script_CacheRenderCallback
============
*/
void sdUIWindow::Script_CacheRenderCallback( sdUIFunctionStack& stack ) {
	idStr callbackName;
	stack.Pop( callbackName );

	sdUserInterfaceManager::renderCallbackHandle_t handle = uiManager->GetRenderCallbackHandle( callbackName.c_str() );
	stack.Push( handle );
}

/*
============
sdUIWindow::Script_DrawTimer
============
*/
void sdUIWindow::Script_DrawTimer( sdUIFunctionStack& stack ) {
	int handle;
	stack.Pop( handle );

	idVec4 rect;
	stack.Pop( rect );

	idVec4 color;
	stack.Pop( color );
	
	float percent;
	stack.Pop( percent );

	float invert;
	stack.Pop( invert );

	uiMaterialCache_t::Iterator iter = GetUI()->FindCachedMaterialForHandle( handle );
	if( !GetUI()->IsValidMaterial( iter ) ) {
		return;
	}
	uiCachedMaterial_t& cached = *iter->second;
	if( cached.material.material == NULL ) {
		return;
	}
	float halfW = rect.z * 0.5f;
	float halfH = rect.w * 0.5f;
	deviceContext->DrawTimer( rect.x + halfW, rect.y + halfH, halfW, halfH, percent, color, cached.material.material, invert != 0.0f, cached.material.st0, cached.material.st1 );
}

/*
============
sdUIWindow::Script_ClipToRect
============
*/
void sdUIWindow::Script_ClipToRect( sdUIFunctionStack& stack ) {
	idVec4 rect;
	stack.Pop( rect );
	deviceContext->PushClipRect( sdBounds2D( rect ) );
}

/*
============
sdUIWindow::Script_UnclipRect
============
*/
void sdUIWindow::Script_UnclipRect( sdUIFunctionStack& stack ) {
	deviceContext->PopClipRect();
}

/*
============
sdUIWindow::Script_GetCachedMaterialDimensions
============
*/
void sdUIWindow::Script_GetCachedMaterialDimensions( sdUIFunctionStack& stack ) {
	int		handle;
	stack.Pop( handle );

	uiMaterialCache_t::Iterator iter = GetUI()->FindCachedMaterialForHandle( handle );
	if( !GetUI()->IsValidMaterial( iter ) ) {
		stack.Push( idVec2( cachedClientRect.z, cachedClientRect.w ) );
		return;
	}

	uiCachedMaterial_t& cached = *( iter->second );
	switch( cached.drawMode ) {
		case BDM_USE_ST:
		case BDM_SINGLE_MATERIAL:
			if( const idImage* image = cached.material.material->GetEditorImage() ) {
				stack.Push( idVec2( image->sourceWidth, image->sourceHeight ) );
				return;
			}
			break;
		case BDM_FRAME:
		case BDM_TRI_PART_H:	// FALL THROUGH
		case BDM_TRI_PART_V:	// FALL THROUGH
		case BDM_FIVE_PART_H:	// FALL THROUGH			
			break;
	}
	stack.Push( idVec2( cachedClientRect.z, cachedClientRect.w ) );
}

/*
============
sdUIWindow::Script_IsVisible
============
*/
void sdUIWindow::Script_IsVisible( sdUIFunctionStack& stack ) {
	stack.Push( IsVisible() ? 1.0f : 0.0f );
}

/*
============
sdUIWindow::Script_PushColor
============
*/
void sdUIWindow::Script_PushColor( sdUIFunctionStack& stack ) {
	idVec4 color;
	stack.Pop( color );
	bool inherit;
	stack.Pop( inherit );
	
	if( inherit ) {
		const idVec4& parent = GetUI()->TopColor();
		color.x *= parent.x;
		color.y *= parent.y;
		color.z *= parent.z;
		color.w *= parent.w;
	}
	GetUI()->PushColor( color );
}

/*
============
sdUIWindow::Script_PopColor
============
*/
void sdUIWindow::Script_PopColor( sdUIFunctionStack& stack ) {
	GetUI()->PopColor();
}

/*
============
sdUIWindow::Script_SetShaderParm
============
*/
void sdUIWindow::Script_SetShaderParm( sdUIFunctionStack& stack ) {
	int parm;
	stack.Pop( parm );
	
	float value;
	stack.Pop( value );

	if( parm < 0 || parm >= MAX_ENTITY_SHADER_PARMS ) {
		return;
	}

	deviceContext->SetRegister( parm, value );
}