// 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 "../misc/WorldToScreen.h"
#include "UIWindow.h"
#include "UIRadialMenu.h"
#include "UserInterfaceLocal.h"
#include "UserInterfaceManager.h"
#include "../Player.h"
#include "../script/Script_Helper.h"


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

// the angles on the circle
static const float DEFAULT_WEDGE_SIZE		= 45.0f;
static const float DEFAULT_WEDGE_START		= 180.0f - DEFAULT_WEDGE_SIZE * 0.5f;
static const float DEFAULT_WEDGE_END		= DEFAULT_WEDGE_START + DEFAULT_WEDGE_SIZE;
static const float LEFT_ARC_START			= DEFAULT_WEDGE_END;
static const float LEFT_ARC_END				= 360.0f - 45.0f;
static const float LEFT_ARC_RANGE			= LEFT_ARC_END - LEFT_ARC_START;

const char sdUITemplateFunctionInstance_IdentifierRadialMenu[] = "sdUIRadialFunction";

idBlockAlloc< sdUIRadialMenu::vec4EvaluatorList_t, 32 > sdUIRadialMenu::vec4EvaluatorListAllocator;


SD_UI_IMPLEMENT_CLASS( sdUIRadialMenu, sdUIWindow )

idHashMap< sdUITemplateFunction< sdUIRadialMenu >* > sdUIRadialMenu::radialMenuFunctions;
SD_UI_PUSH_CLASS_TAG( sdUIRadialMenu )
const char* sdUIRadialMenu::eventNames[ RME_NUM_EVENTS - WE_NUM_EVENTS ] = {
	SD_UI_EVENT_TAG( "onCommand",			"[Command Name]", "Called when the given input command occurs. The game script calls these commands to control navigation within the quick chat." ),

	SD_UI_EVENT_PARM_TAG( "onMeasureItem",	"", "Measure the item size before drawing." ),
		SD_UI_EVENT_PARM( float, "itemIndex", "Item index" )
		SD_UI_EVENT_PARM( float, "itemStyle", "Item style, position of the item if drawing a radial menu." )
		SD_UI_EVENT_PARM( vec2, "size", "Size of rectangle" )
		SD_UI_EVENT_RETURN_PARM( vec2, "New size of rectangle" )
	SD_UI_END_EVENT_TAG

	SD_UI_EVENT_TAG( "onDrawItem",			"", "Draw a quick chat item." ),
		SD_UI_EVENT_PARM( wstring, "key", "Shortcut key" )
		SD_UI_EVENT_PARM( float, "title", "Localized title (convert float to a handle before usage)." )
		SD_UI_EVENT_PARM( float, "chevron", "Material handle for chevron to draw." )
		SD_UI_EVENT_PARM( float, "enabled", "Player is able to execute the quick chat item." )
		SD_UI_EVENT_PARM( rect, "itemRecte", "Item rectangle." )
		SD_UI_EVENT_PARM( float, "itemIndex", "Item index." )
		SD_UI_EVENT_PARM( float, "itemStyle", "Item style, position of the item if drawing a radial menu." )
		SD_UI_EVENT_PARM( string, "drawCallback", "Optional callback when drawing. GUI posts an optional named event with this string." )
	SD_UI_END_EVENT_TAG

	SD_UI_EVENT_TAG( "onDrawContext",		"", "Draw the context button (centered in the radial menu)." ),
		SD_UI_EVENT_PARM( rect, "itemRect", "Context rectangle" )
	SD_UI_END_EVENT_TAG

	SD_UI_EVENT_TAG( "onDrawDeadZone",		"", "Not used." ),
	SD_UI_EVENT_TAG( "onPagePushed",		"", "Called when the player enters a new page." ),
	SD_UI_EVENT_TAG( "onPagePopped",		"", "Called when the player exits a page. currentPage will be -1 if there is no valid page." ),
};
SD_UI_POP_CLASS_TAG

idCVar gui_debugRadialMenus(			"gui_debugRadialMenus",					"0",	CVAR_GAME | CVAR_BOOL,							"Show radial menu debugging info" );
idCVar g_radialMenuStyle(				"g_radialMenuStyle",					"0",	CVAR_GAME | CVAR_INTEGER | CVAR_ARCHIVE | CVAR_PROFILE,		"Sets the style of the quick chat menu: 0 = radial, 1 = vertical" );
idCVar g_radialMenuUseNumberShortcuts(	"g_radialMenuUseNumberShortcuts",		"1",	CVAR_GAME | CVAR_BOOL | CVAR_ARCHIVE | CVAR_PROFILE,			"Use numbers instead of alpha-numeric shortcuts" );
idCVar g_radialMenuMouseSensitivity(	"g_radialMenuMouseSensitivity",			"0.5",	CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE,			"Mouse input scale" );

/*
============
sdUIRadialMenu::radialItem_t::Update
============
*/
bool sdUIRadialMenu::radialItem_t::Update() {
	bool sizeChanged = false;
	if ( scriptUpdateCallback.Length() > 0 ) {
		idPlayer* localPlayer = gameLocal.GetLocalPlayer();
		if ( localPlayer != NULL ) {
			const sdProgram::sdFunction* callback = localPlayer->GetScriptFunction( scriptUpdateCallback.c_str() );
			if ( callback != NULL ) {
				bool wasEnabled = flags.enabled;

				sdScriptHelper h;
				h.Push( scriptUpdateParm.c_str() );
				localPlayer->CallNonBlockingScriptEvent( callback, h );

				const char* returnVal = h.GetReturnedString();
				idStrList list;
				idSplitStringIntoList( list, returnVal, "|" );
				if ( list.Num() >= 5 ) {
					flags.enabled = sdTypeFromString< bool >( list[ 4 ] );
				} else {
					flags.enabled = true;
				}

				if ( flags.enabled || wasEnabled ) {
					if ( list.Num() >= 1 ) {
						title = declHolder.FindLocStr( list[ 0 ] );
						sizeChanged = true;
						/* this can spam the console, only use it for debugging
						if( title->GetState() == DS_DEFAULTED ) {
							gameLocal.Warning( "Invalid title %s", title->GetName() );
						}
						*/
						
					} 
					if ( list.Num() >= 2 ) {
						if ( list[ 1 ].Length() == 0 ) {
							part.mi.Clear();
						} else {
							owner->GetScope().GetUI()->LookupMaterial( list[ 1 ].c_str(), part.mi, &part.width, &part.height );
						}
					}

					commandID.SetNum( 0 );
					commandData.SetNum( 0 );

					if ( list.Num() >= 4 ) {
						commandID.Alloc() = list[ 2 ];
						commandData.Alloc() = list[ 3 ];
					}
					if ( list.Num() >= 6 ) {
						// extra info
						commandData.Alloc() = list[ 5 ];
					}
				}
			}
		}
	}

	return sizeChanged;
}

/*
============
sdUIRadialMenu::InitFunctions
============
*/
#pragma inline_depth( 0 )
#pragma optimize( "", off )
SD_UI_PUSH_CLASS_TAG( sdUIRadialMenu )
void sdUIRadialMenu::InitFunctions() {
	SD_UI_FUNC_TAG( insertItem, "Insert an item into a page." )
		SD_UI_FUNC_PARM( float, "page", "Page number." )
		SD_UI_FUNC_PARM( string, "text", "Item text. \"title||id,id2,id3||data,data1,data2||key\"." )
		SD_UI_FUNC_RETURN_PARM( float, "Number of items." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "insertItem",			new sdUITemplateFunction< sdUIRadialMenu >( 'f', "fs",	&sdUIRadialMenu::Script_InsertItem ) );

	SD_UI_FUNC_TAG( insertPage, "Insert a new page." )
		SD_UI_FUNC_PARM( string, "title", "Page title." )
		SD_UI_FUNC_RETURN_PARM( float, "Page number for current page." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "insertPage",			new sdUITemplateFunction< sdUIRadialMenu >( 'f', "s",	&sdUIRadialMenu::Script_InsertPage ) );

	SD_UI_FUNC_TAG( getItemData, "Get item data." )
		SD_UI_FUNC_PARM( float, "itemPage", "Item page. If -1 then use the current page." )
		SD_UI_FUNC_PARM( float, "itemNumber", "Item number. If -1 then use the current page" )
		SD_UI_FUNC_PARM( float, "dataIndex", "Command data index." )
		SD_UI_FUNC_RETURN_PARM( string, "Commnand data." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "getItemData", 		new sdUITemplateFunction< sdUIRadialMenu >( 's', "fff", &sdUIRadialMenu::Script_GetItemData ) );

	SD_UI_FUNC_TAG( clear, "Clear all pages." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "clear",				new sdUITemplateFunction< sdUIRadialMenu >( 'v', "",	&sdUIRadialMenu::Script_Clear ) );

	SD_UI_FUNC_TAG( clearPage, "Clear all page items." )
		SD_UI_FUNC_PARM( float, "page", "Page index." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "clearPage",			new sdUITemplateFunction< sdUIRadialMenu >( 'v', "f",	&sdUIRadialMenu::Script_ClearPage ) );

	SD_UI_FUNC_TAG( pushPage, "Push page on stack, make it the current page and reset mouse position. Calls onPagePushed event." )
		SD_UI_FUNC_PARM( float, "page", "Page index." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "pushPage",			new sdUITemplateFunction< sdUIRadialMenu >( 'v', "f",	&sdUIRadialMenu::Script_PushPage ) );

	SD_UI_FUNC_TAG( popPage, "Pop the stack of pages. Current page is the page on the top after popping." )
		SD_UI_FUNC_RETURN_PARM( string, "The page popped." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "popPage",				new sdUITemplateFunction< sdUIRadialMenu >( 'f', "",	&sdUIRadialMenu::Script_PopPage ) );

	SD_UI_FUNC_TAG( clearPageStack, "Clear the page stack." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "clearPageStack",		new sdUITemplateFunction< sdUIRadialMenu >( 'v', "",	&sdUIRadialMenu::Script_ClearPageStack ) );

	SD_UI_FUNC_TAG( postCommand, "Post a command with the command data for the item." )
		SD_UI_FUNC_PARM( float, "page", "Page number. Current page if -1." )
		SD_UI_FUNC_PARM( float, "item", "Item number. Current item if -1." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "postCommand", 		new sdUITemplateFunction< sdUIRadialMenu >( 'v', "ff",	&sdUIRadialMenu::Script_PostCommand ) );

	SD_UI_FUNC_TAG( loadFromDef, "Load a radial menu from def files." )
		SD_UI_FUNC_PARM( string, "defName", "Def name to load." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "loadFromDef", 		new sdUITemplateFunction< sdUIRadialMenu >( 'v', "s",	&sdUIRadialMenu::Script_LoadFromDef ) );

	SD_UI_FUNC_TAG( appendFromDef, "Load a radial menu page from def files." )
		SD_UI_FUNC_PARM( string, "defName", "Def name to load." )
		SD_UI_FUNC_PARM( float, "page", "Page index." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "appendFromDef",		new sdUITemplateFunction< sdUIRadialMenu >( 'v', "sf",	&sdUIRadialMenu::Script_AppendFromDef ) );

	SD_UI_FUNC_TAG( fillFromEnumerator, "Fill menu from an enumerator." )
		SD_UI_FUNC_PARM( string, "enumerator", "Name of enumerator." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "fillFromEnumerator",	new sdUITemplateFunction< sdUIRadialMenu >( 'v', "s",	&sdUIRadialMenu::Script_FillFromEnumerator ) );
 
	SD_UI_FUNC_TAG( transitionItemVec4, "Transition for an item." )
		SD_UI_FUNC_PARM( float, "propertyType", "Property type. Either RTP_FORECOLOR/RTP_BACKCOLOR/RTP_PROPERTY_0/RTP_PROPERTY_1/RTP_PROPERTY_2/RTP_PROPERTY_3." )
		SD_UI_FUNC_PARM( vec4, "from", "Transition from." )
		SD_UI_FUNC_PARM( vec4, "to", "Transition to." )
		SD_UI_FUNC_PARM( float, "time", "Time for transition." )
		SD_UI_FUNC_PARM( string, "acceleration", "Non linear transition." )
		SD_UI_FUNC_PARM( float, "item", "Item index." )
		SD_UI_FUNC_PARM( float, "page", "Page index." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "transitionItemVec4",			new sdUITemplateFunction< sdUIRadialMenu >( 'v', "f44fsff",	&sdUIRadialMenu::Script_TransitionItemVec4 ) );

	SD_UI_FUNC_TAG( getItemTransitionVec4Result, "Get the result from a transition given a property type." )
		SD_UI_FUNC_PARM( float, "propertyType", "Where property type is one of:\n* RTP_FORECOLOR\n* RTP_BACKCOLOR\n* RTP_PROPERTY_0\n* RTP_PROPERTY_1\n* RTP_PROPERTY_2\n* RTP_PROPERTY_3." )
		SD_UI_FUNC_PARM( vec4, "default", "Default value is returned if item is not found or propertyType is invalid." )
		SD_UI_FUNC_PARM( float, "item", "Item index." )
		SD_UI_FUNC_PARM( float, "page", "Page index." )
		SD_UI_FUNC_RETURN_PARM( vec4, "Transition value." )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "getItemTransitionVec4Result",	new sdUITemplateFunction< sdUIRadialMenu >( '4', "f4ff",	&sdUIRadialMenu::Script_GetItemTransitionVec4Result ) );

	SD_UI_FUNC_TAG( clearTransitions, "Clear transitions." )
		SD_UI_FUNC_PARM( float, "item", "Item index. All items if less than 0" )
		SD_UI_FUNC_PARM( float, "page", "Page index. All pages if less than 0" )
	SD_UI_END_FUNC_TAG
	radialMenuFunctions.Set( "clearTransitions",			new sdUITemplateFunction< sdUIRadialMenu >( 'v', "ff",		&sdUIRadialMenu::Script_ClearTransitions ) );

	SD_UI_ENUM_TAG( RMF_USE_NUMBER_SHORTCUTS, "Use number shortcuts." )
	sdDeclGUI::AddDefine( va( "RMF_USE_NUMBER_SHORTCUTS %i", RMF_USE_NUMBER_SHORTCUTS ) );

	SD_UI_PUSH_GROUP_TAG( "Radial Transition Property Flags" )

	SD_UI_ENUM_TAG( RTP_FORECOLOR, "Forecolor transition property." )
	sdDeclGUI::AddDefine( va( "RTP_FORECOLOR %i", 		RTP_FORECOLOR ) );
	SD_UI_ENUM_TAG( RTP_BACKCOLOR, "Backcolor transition property." )
	sdDeclGUI::AddDefine( va( "RTP_BACKCOLOR %i", 		RTP_BACKCOLOR ) );
	SD_UI_ENUM_TAG( RTP_PROPERTY_0, "Transition property 0." )
	sdDeclGUI::AddDefine( va( "RTP_PROPERTY_0 %i", 		RTP_PROPERTY_0 ) );
	SD_UI_ENUM_TAG( RTP_PROPERTY_1, "Transition property 1." )
	sdDeclGUI::AddDefine( va( "RTP_PROPERTY_1 %i", 		RTP_PROPERTY_1 ) );
	SD_UI_ENUM_TAG( RTP_PROPERTY_2, "Transition property 2." )
	sdDeclGUI::AddDefine( va( "RTP_PROPERTY_2 %i", 		RTP_PROPERTY_2 ) );
	SD_UI_ENUM_TAG( RTP_PROPERTY_3, "Transition property 3." )
	sdDeclGUI::AddDefine( va( "RTP_PROPERTY_3 %i", 		RTP_PROPERTY_3 ) );

	SD_UI_POP_GROUP_TAG
	SD_UI_PUSH_GROUP_TAG( "Draw Style Flags" )

	SD_UI_ENUM_TAG( DS_ARC, "ARC draw style." )
	sdDeclGUI::AddDefine( va( "DS_ARC %i",				DS_ARC ) );
	SD_UI_ENUM_TAG( DS_VERTICAL, "Vertical draw style." )
	sdDeclGUI::AddDefine( va( "DS_VERTICAL %i",			DS_VERTICAL ) );
	SD_UI_ENUM_TAG( DS_INVALID, "Invalid draw style." )
	sdDeclGUI::AddDefine( va( "DS_INVALID %i",			DS_INVALID ) );

	SD_UI_POP_GROUP_TAG
	SD_UI_PUSH_GROUP_TAG( "Radial Item Style Flags" )

	SD_UI_ENUM_TAG( RIS_LEFT, "Item style left." )
	sdDeclGUI::AddDefine( va( "RIS_LEFT %i",			RIS_LEFT ) );
	SD_UI_ENUM_TAG( RIS_RIGHT, "Item style right." )
	sdDeclGUI::AddDefine( va( "RIS_RIGHT %i",			RIS_RIGHT ) );
	SD_UI_ENUM_TAG( RIS_CENTER, "Item style center." )
	sdDeclGUI::AddDefine( va( "RIS_CENTER %i",			RIS_CENTER ) );
	SD_UI_ENUM_TAG( RIS_TOP, "Item style top." )
	sdDeclGUI::AddDefine( va( "RIS_TOP %i",				RIS_TOP ) );
	SD_UI_ENUM_TAG( RIS_BOTTOM, "Item style bottom." )
	sdDeclGUI::AddDefine( va( "RIS_BOTTOM %i",			RIS_BOTTOM ) );

	SD_UI_POP_GROUP_TAG
}
SD_UI_POP_CLASS_TAG
#pragma optimize( "", on )
#pragma inline_depth()
/*
============
sdUIRadialMenu::sdUIRadialMenu
============
*/
sdUIRadialMenu::sdUIRadialMenu() :
	currentPage( -1.0f ),
	currentItem( -1.0f ),
	radius( 64.0f ),
	verticalPadding( 0.0f ),
	lastActiveEventFrame ( -1 ) {

	scriptState.GetProperties().RegisterProperty( "currentPage", currentPage );
	scriptState.GetProperties().RegisterProperty( "radius", radius );
	scriptState.GetProperties().RegisterProperty( "currentItem", currentItem );

	scriptState.GetProperties().RegisterProperty( "verticalPadding", verticalPadding );
	scriptState.GetProperties().RegisterProperty( "drawStyle", drawStyle );

	lastArcMoveInfo.Set( 0.0f, 0.0f );
	imaginaryCursorPos.Set( 0.0f, 0.0f );
	drawStyle = DS_ARC;

	UI_ADD_FLOAT_CALLBACK( currentPage, sdUIRadialMenu, OnCurrentPageChanged );
	UI_ADD_FLOAT_CALLBACK( currentPage, sdUIRadialMenu, OnDrawStyleChanged );
	UI_ADD_FLOAT_VALIDATOR( currentItem, sdUIRadialMenu, OnValidateCurrentItem );
	UI_ADD_FLOAT_VALIDATOR( drawStyle, sdUIRadialMenu, OnValidateDrawStyle );
}


/*
============
sdUIRadialMenu::~sdUIRadialMenu
============
*/
sdUIRadialMenu::~sdUIRadialMenu() {
	DisconnectGlobalCallbacks();
}

/*
============
sdUIRadialMenu::EnumerateEvents
============
*/
void sdUIRadialMenu::EnumerateEvents( const char* name, const idList<unsigned short>& flags, idList< sdUIEventInfo >& events, const idTokenCache& tokenCache ) {
	if( !idStr::Icmp( name, "onCommand" )) {
		int id = -1;		
		for( int i = 0; i < flags.Num(); i++ ) {
			const idToken& name = tokenCache[ flags[ i ] ];
			id = NamedEventHandleForString( name.c_str() );
			events.Append( sdUIEventInfo( RME_COMMAND, id ) );
		}
		return;
	}
	
	if( !idStr::Icmp( name, "onMeasureItem" )) {
		events.Append( sdUIEventInfo( RME_MEASUREITEM, 0 ) );
		return;
	}

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

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

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

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

	sdUIWindow::EnumerateEvents( name, flags, events, tokenCache );
}

/*
============
sdUIRadialMenu::FindFunction
============
*/
const sdUIRadialMenu::uiTemplateFunction_t* sdUIRadialMenu::FindFunction( const char* name ) {
	sdUITemplateFunction< sdUIRadialMenu >** ptr;
	return radialMenuFunctions.Get( name, &ptr ) ? *ptr : NULL;
}

/*
============
sdUIRadialMenu::GetFunction
============
*/
sdUIFunctionInstance* sdUIRadialMenu::GetFunction( const char* name ) {
	const sdUITemplateFunction< sdUIRadialMenu >* function = sdUIRadialMenu::FindFunction( name );
	if ( !function ) {		
		return sdUIWindow::GetFunction( name );
	}

	return new sdUITemplateFunctionInstance< sdUIRadialMenu, sdUITemplateFunctionInstance_IdentifierRadialMenu >( this, function );
}

/*
============
sdUIRadialMenu::RunNamedMethod
============
*/
bool sdUIRadialMenu::RunNamedMethod( const char* name, sdUIFunctionStack& stack ) {
	const sdUITemplateFunction< sdUIRadialMenu >* func = sdUIRadialMenu::FindFunction( name );
	if ( !func ) {
		return sdUIWindow::RunNamedMethod( name, stack );
	}

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

/*
============
sdUIRadialMenu::DrawLocal
============
*/
void sdUIRadialMenu::DrawLocal() {
	if( !PreDraw() ) {
		return;
	}

	idPlayer* player = gameLocal.GetLocalPlayer();
	if ( player != NULL ) {
		idEntity* entity = gameLocal.localPlayerProperties.GetContextEntity();
		if( entity != NULL ) {
			idVec3 org = entity->GetLastPushedOrigin();
			idMat3 axes = entity->GetLastPushedAxis();
			idBounds bounds = entity->GetPhysics()->GetBounds();

			sdWorldToScreenConverter converter( gameLocal.playerView.GetCurrentView() );

			sdBounds2D screenBounds;
			converter.Transform( bounds, axes, org, screenBounds );

			GetUI()->PushScriptVar( screenBounds.ToVec4() );
			RunEvent( sdUIEventInfo( RME_DRAWCONTEXT, 0 ) );
			GetUI()->ClearScriptStack();
		}
	}

	if( drawStyle == DS_INVALID ) {
		return;
	}

	int currentPageIndex = idMath::Ftoi( currentPage );
	if( currentPageIndex >= 0 && currentPageIndex < pages.Num() ) {
		radialPage_t& page			= pages[ currentPageIndex ];
		int currentItem				= idMath::Ftoi( this->currentItem );

		idVec2 origin;
		
		if( drawStyle == DS_ARC ) {
			origin.Set( cachedClientRect.x + cachedClientRect.z * 0.5f, cachedClientRect.y + cachedClientRect.w * 0.5f );
		} else if( drawStyle == DS_VERTICAL ) {
			origin.Set( cachedClientRect.x + cachedClientRect.z * 0.5f, cachedClientRect.y );
		}
		
		for ( int i = 0; i < page.items.Num(); i++ ) {
			page.items[ i ].Update();
		}

		DrawTitle( page, origin );
		if( drawStyle == DS_ARC ) {
			DrawItemCircle( page, origin );
		} else if( drawStyle == DS_VERTICAL ) {			
			DrawItemLine( page, origin );
		}
	}
}

/*
============
sdUIRadialMenu::DrawItemCircle
============
*/
void sdUIRadialMenu::DrawItemCircle( radialPage_t& page, const idVec2& center ) {
	if ( page.items.Num() < 1 ) {
		return;
	}

	// calculate an approximate angle interval to place the items at
	int numDivisions = page.items.Num();
	float angleInterval = 360.0f / ( numDivisions - 2 );
	
	// calculate the radius the circle will need to be
	float minHeight = page.maxSize.y + verticalPadding;
	float deltaD = 2.0f * radius * idMath::Sin( DEG2RAD( angleInterval * 0.5f ) );
	float deltaW = radius * idMath::Sin( DEG2RAD( angleInterval ) );
	float deltaH = idMath::Sqrt( deltaD * deltaD - deltaW * deltaW );

	float newRadius = radius;
	if ( deltaH > idMath::FLT_EPSILON ) {
		newRadius = ( minHeight / deltaH ) * radius;
		if ( newRadius < radius + page.maxSize.y * 0.5f ) {
			newRadius = radius + page.maxSize.y;
		}
	}

	if ( gui_debugRadialMenus.GetBool() ) {
		deviceContext->DrawCircle( center.x, center.y, idVec2( newRadius, newRadius ), 1.0f, 32, colorGreen );
		deviceContext->DrawClippedRect( center.x - 2.0f, center.y - 2.0f, 4.0f, 4.0f, colorYellow );
	}
	
	// calculate where the first position down can be
	int numRows = ( page.items.Num() - 1 ) / 2;

	// draw the odd item out at the bottom, centered to keep the list from looking lopsided
	bool drawBottomItem = ( ( page.items.Num() - 2 ) % 2 ) != 0 ;
	if( drawBottomItem ) {
		numRows--;
	}

	float currentY = ( numRows * ( page.maxSize.y ) ) * 0.5f;
	float xOffset = cachedClientRect.z * 0.5f - page.maxSize.y;
	
	// draw the first item right in the center - this is the default
	DrawItem( page, page.items[ 0 ], 0, center, center, RIS_CENTER );

	int itemUpto = 2;
	if ( itemUpto >= page.items.Num() ) {
		return;
	}

	DrawItem( page, page.items[ 1 ], 1, center, center - idVec2( 0.0f, currentY + page.maxSize.y + verticalPadding ), RIS_CENTER | RIS_TOP );

	for ( int i = 0; i < numRows; i++, currentY -= page.maxSize.y + verticalPadding ) {
		float currentX = -idMath::Sqrt( idMath::Fabs( newRadius * newRadius - currentY * currentY ) );

		radialItem_t& item = page.items[ itemUpto ];
		idVec2 offset( currentX - xOffset, -currentY );
		int flags = 0;
		if( itemUpto == 1 || itemUpto == 2 ) {
			flags = RIS_TOP;
		} else {
			if( drawBottomItem ) {
				if( itemUpto == page.items.Num() - 3 || itemUpto == page.items.Num() - 2 ) {
					flags = RIS_BOTTOM;
				}
			} else {
				if( itemUpto == page.items.Num() - 2 || itemUpto == page.items.Num() - 1 ) {
					flags = RIS_BOTTOM;
				}
			}
		}

		DrawItem( page, item, itemUpto, center, center + offset, RIS_LEFT | flags);
		if ( gui_debugRadialMenus.GetBool() ) {
			deviceContext->DrawLine( center, center + offset, 1.0f, colorRed );
		}
		itemUpto++;

		if ( itemUpto < page.items.Num() ) {
			radialItem_t& item = page.items[ itemUpto ];
			offset.x = -offset.x;
			DrawItem( page, item, itemUpto, center, center + offset, RIS_RIGHT | flags );
			if ( gui_debugRadialMenus.GetBool() ) {
				deviceContext->DrawLine( center, center + offset, 1.0f, colorRed );
			}
			itemUpto++;
		}
	}

	if( drawBottomItem ) {
		DrawItem( page, page.items[ page.items.Num() - 1 ], page.items.Num() - 1, center, center + idVec2( 0.0f, -currentY + verticalPadding ), RIS_CENTER | RIS_BOTTOM );
	}
}

/*
============
sdUIRadialMenu::DrawItemLine
============
*/
void sdUIRadialMenu::DrawItemLine( radialPage_t& page, const idVec2& center ) {

	float currentX = 0.0f;
	float currentY = 0.0f;
	for ( int i = 0; i < page.items.Num(); i++, currentY += page.maxSize.y + verticalPadding ) {

		radialItem_t& item = page.items[ i ];
		idVec2 offset( currentX, currentY );

		int flags = RIS_CENTER;
		if( i == 0 ) {
			flags |= RIS_TOP;
		} else if( i == page.items.Num() - 1 ) {
			flags |= RIS_BOTTOM;
		}

		DrawItem( page, item, i, center, center + offset, flags );
		if ( gui_debugRadialMenus.GetBool() ) {
			deviceContext->DrawLine( center, center + offset, 1.0f, colorRed );
		}
	}
}

/*
============
ToPolar
============
*/
static void ToPolar( const idVec2& valueExpr, float& angleOut, float& distanceOut ) {
	if( idMath::Fabs( valueExpr.x ) < idMath::FLT_EPSILON && idMath::Fabs( valueExpr.y ) < idMath::FLT_EPSILON ) {
		angleOut = 0.0f;
		distanceOut = 0.0f;
		return;
	}
	idVec2 conversionValue = valueExpr;
	if ( idMath::Fabs( conversionValue.x ) > idMath::FLT_EPSILON ) {
		angleOut = RAD2DEG( idMath::ATan( -conversionValue.y, conversionValue.x ) );
		distanceOut = conversionValue.Length();
	} else {
		if ( conversionValue.y > 0.0f ) {
			distanceOut = conversionValue.y;
			angleOut = -90.0f;
		} else {
			distanceOut = -conversionValue.y;
			angleOut = 90.0f;
		}
	}
	angleOut = idMath::AngleNormalize360( angleOut + 90.0f );
}

/*
============
ToCartesian
============
*/
static idVec2 ToCartesian( const float distanceIn, const float angleIn ) {
	return idVec2( idMath::Cos( DEG2RAD( angleIn - 90.0f ) ) * distanceIn, -idMath::Sin( DEG2RAD( angleIn - 90.0f ) ) * distanceIn );
}

/*
============
sdUIRadialMenu::DrawItem
============
*/
void sdUIRadialMenu::DrawItem( radialPage_t& page, radialItem_t& item, int index, const idVec2& center, const idVec2& offset, int radialItemStyle ) {
	sdBounds2D	drawRect;	

	idVec2 size( page.maxSize.x, item.size.y );

	GetUI()->PushScriptVar( size );
	GetUI()->PushScriptVar( static_cast< float >( radialItemStyle ) );
	GetUI()->PushScriptVar( static_cast< float >( index ) );

	if( RunEvent( sdUIEventInfo( RME_MEASUREITEM, 0 ) ) ) {
		GetUI()->PopScriptVar( size );
	}
	
	GetUI()->ClearScriptStack();

	drawRect.FromRectangle( 0.0f, 0.0f, size.x, size.y );
	drawRect.TranslateSelf( offset );
	drawRect.TranslateSelf( 0.5f * ( offset.x - drawRect.GetMins().x ), 0.0f );
	if( drawStyle == DS_ARC ) {
		drawRect.TranslateSelf( 0.0f, -size.y * 0.5f );
	}
	
	drawRect.TranslateSelf( -0.5f * drawRect.GetWidth(), 0.0f );

	idVec2 delta = drawRect.GetCenter() - center;
	float theta;
	float distance;
	ToPolar( delta, theta, distance );

	item.lastDrawAngle = theta;	
		
	if ( item.title != NULL ) {				
		bool useIndex = TestFlag( RMF_USE_NUMBER_SHORTCUTS );
		const wchar_t* shortcutKey = L"";

		if( !item.commandKey.IsEmpty() || useIndex ) {
			if( useIndex ) {
				if ( !item.commandNumberKey.IsEmpty() ) {
					shortcutKey = va( L"%hs", item.commandNumberKey.c_str() );
				} else {
					if( index == 9 ) {
						shortcutKey = L"0";
					} else {
						shortcutKey = va( L"%i", index + 1 );
					}
				}
			} else {
				shortcutKey = va( L"%hs", item.commandKey.c_str() );
			}			
		}

		GetUI()->PushScriptVar( item.drawCallback.c_str() );
		GetUI()->PushScriptVar( radialItemStyle );
		GetUI()->PushScriptVar( index );
		GetUI()->PushScriptVar( drawRect.ToVec4() );
		GetUI()->PushScriptVar( item.flags.enabled ? 1.0f : 0.0f );
		GetUI()->PushScriptVar( item.flags.drawChevron ? 1.0f : 0.0f );
		GetUI()->PushScriptVar( item.title->Index() );
		GetUI()->PushScriptVar( shortcutKey );

		RunEvent( sdUIEventInfo( RME_DRAWITEM, 0 ) );

		GetUI()->ClearScriptStack();
	}

	if ( gui_debugRadialMenus.GetBool() ) {
//		deviceContext->DrawClippedRect( offset.x - 2.0f, offset.y - 2.0f, 4.0f, 4.0f, idVec4( 1.0f, 0.0f, 1.0f, 0.5f ) );
//		deviceContext->DrawClippedRect( drawRect.GetMins().x, drawRect.GetMins().y, drawRect.GetWidth(), drawRect.GetHeight(), idVec4( 1.0f, 0.0f, 0.0f, 0.5f ) );
	}
}

/*
============
sdUIRadialMenu::DrawTitle
============
*/
void sdUIRadialMenu::DrawTitle( radialPage_t& page, const idVec2& center ) {
	if ( gui_debugRadialMenus.GetBool() ) {
		idVec2 centerPos = GetUI()->screenCenter;
		idVec2 cursorPos = GetUI()->cursorPos;

		deviceContext->DrawClippedRect( cursorPos.x - 3, cursorPos.y - 3, 6, 6, colorYellow );
		deviceContext->DrawLine( centerPos, cursorPos, 1, colorYellow );

		deviceContext->DrawClippedRect( imaginaryCursorPos.x - 3 + centerPos.x, imaginaryCursorPos.y - 3 + centerPos.y, 6, 6, colorGreen );
		deviceContext->DrawLine( centerPos, imaginaryCursorPos + centerPos, 1, colorGreen );
	}

	if( drawStyle == DS_ARC ) {
		if( gui_debugRadialMenus.GetBool() ) {
			idVec4 yellow( colorYellow );
			yellow.w = 0.5f;

			const idVec2& cursor = GetUI()->cursorPos;
			deviceContext->DrawLine( center, cursor, 1.0f, yellow );
		}
	} else if( drawStyle == DS_VERTICAL	) {

	}
}

/*
============
sdUIRadialMenu::HandleArcMouseMove
============
*/
void sdUIRadialMenu::HandleArcMouseMove( const sdSysEvent* event, const idVec2 delta, radialPage_t& page, int& currentItem ) {
	idVec2 newPosition = delta;

	float angle, distance;
	ToPolar( newPosition, angle, distance );

	// clamp the distance to the radius
	if ( idMath::Fabs( distance ) > radius ) {
		distance = idMath::ClampFloat( -radius, radius, distance );
		newPosition = ToCartesian( distance, angle );
		GetUI()->cursorPos = newPosition + GetUI()->screenCenter;
	}

	// find the delta from the last move
	idVec2 lastCursorPos = ToCartesian( lastArcMoveInfo.x, lastArcMoveInfo.y );
	idVec2 moveDelta = ( newPosition - lastCursorPos );

	// if it hasn't moved a few units from the last position that was processed then don't process it
	float moveDist = moveDelta.Length();	

	// record the processing
	lastArcMoveInfo.Set( distance, angle );

	// update where the imaginary cursor is
	imaginaryCursorPos = lastCursorPos + moveDelta;

	int iCurrentItem = idMath::Ftoi( currentItem );

	bool dontSnap = false;
	bool useDelta = false;

	if ( event->IsControllerMouseEvent() ) {
	
	} else {
		// check whether the player has made a fast movement (to be handled gesturally)
		bool isExtremeVerticalItem =	( iCurrentItem != -1 && 
										( ( idMath::Fabs( page.items[ iCurrentItem ].lastDrawAngle - 180.0f ) < 4.0f ) ||
										idMath::Fabs( page.items[ iCurrentItem ].lastDrawAngle ) < 4.0f ) );
		bool isVerticalMove = idMath::Fabs( angle - 180.0f ) < 4.0f || idMath::Fabs( angle ) < 4.0f;

		
		if ( moveDist > 5.0f || ( isVerticalMove && moveDist >= 2.0f ) ) {
			if ( idMath::Fabs( moveDelta.x ) < 2.0f ) {
				// not as sensitive to movements if they're largely up & down
				if ( moveDist > 10.0f || isExtremeVerticalItem ) {
					dontSnap = true;
					useDelta = true;
				}
			} else {
				dontSnap = true;
				useDelta = true;
			}
		}


	//		gameLocal.Printf( "%.1f %.1f\n", moveDelta.x, moveDelta.y );

		if ( useDelta ) {
			// do a super-fast snappy move
			
			// find the closest point of the flick line relative to the center
			idVec2 dir = moveDelta;
			dir.Normalize();
			idVec2 diff = -lastCursorPos;
			float t = diff * dir;
			idVec2 closest = lastCursorPos + t * dir;

			// find out the angle and length of the vector
			float alpha, dist;
			ToPolar( closest - lastCursorPos, alpha, dist );
			alpha = idMath::AngleNormalize360( alpha - 90.0f );

			float closestDistance = closest.Length();
			float distToPoint = idMath::Sqrt( Square( radius ) - Square( closestDistance ) );

			idVec2 point = closest + distToPoint * dir;
			ToPolar( point, angle, distance );
		} else if ( distance < radius * 0.25f ) {
			// move to the dead zone
			if( idMath::Ftoi( drawStyle ) == DS_ARC ) {
				currentItem = 0.0f;
			}
			return;
		}
	}

	// how many items on each side
	int numItems = page.items.Num();
	if ( numItems == 0 ) {
		return;
	}
	int numOnLeft = numItems / 2;

	if( ( ( numItems - 2 ) % 2 ) != 0 ) {
		numOnLeft--;
	}

	// figure out the angle divisions for items
	float angleInterval = LEFT_ARC_RANGE / numOnLeft;
	float midAngle = angle;
	float bestAngle = idMath::INFINITY;

	int	newItem = iCurrentItem;
	int checkedItems = 0;
	bool found = false;
	
	int i = ( iCurrentItem + 1 ) % numItems;
	while( checkedItems < page.items.Num() ) {
		float min = page.items[ i ].lastDrawAngle - angleInterval * 0.5f;
		
		float max = min + angleInterval;
 		float angleDifference = idMath::AngleNormalize360( idMath::Fabs( angle - page.items[ i ].lastDrawAngle ) );

		if ( ( ( angle > min && angle < max ) || ( angle > ( min + 360.0f ) && angle < ( max + 360.0f ) ) ) && angleDifference <= bestAngle ) {
			if( i != 0 || found == false ) {
				newItem = i;
				midAngle = ( min + max ) * 0.5f;
				distance = radius;
				bestAngle = angleDifference;
				found = true;
			}
		}
		i = ( i + 1 ) % numItems;
		checkedItems++;
	}

	// jrad - allow selection of disabled items to improve usability (muscle-memory)
//	if ( page.items[ newItem ].flags.enabled ) {
		currentItem = newItem;
//	}

	if ( !event->IsControllerMouseEvent() ) {
		//
		// OUTPUT
		// calculate the cursor position
		idVec2 newCursorPos = ToCartesian( distance, angle ) + GetUI()->screenCenter;
		if ( !dontSnap ) {
			imaginaryCursorPos = newCursorPos - GetUI()->screenCenter;
		}

		//
		// Debugging!
		newCursorPos = ToCartesian( radius, midAngle ) + GetUI()->screenCenter;

		if ( useDelta ) {
			GetUI()->cursorPos = newCursorPos;
			lastArcMoveInfo.Set( radius, midAngle );
			imaginaryCursorPos = newCursorPos - GetUI()->screenCenter;
		}
	}
}

/*
============
sdUIRadialMenu::PostEvent
============
*/
bool sdUIRadialMenu::PostEvent( const sdSysEvent* event ) {
	int currentPage = idMath::Ftoi( this->currentPage );
	int currentItem = idMath::Ftoi( this->currentItem );

	if( currentPage < 0 || currentPage >= pages.Num() ) {
		return false;
	}

	radialPage_t& page = pages[ currentPage ];

	bool retVal = false;

	if ( event->IsMouseEvent() ) {
		if( ( currentItem < 0 && idMath::Ftoi( drawStyle ) != DS_ARC ) || currentItem > page.items.Num() ) {
			return false;
		}

		idVec2 delta = GetUI()->cursorPos.GetValue() - GetUI()->screenCenter.GetValue();

		if( drawStyle == DS_ARC ) {
			HandleArcMouseMove( event, delta, page, currentItem );
			this->currentItem = idMath::ClampInt( -1, page.items.Num() - 1, currentItem );
		} else if( drawStyle == DS_VERTICAL ) {
			float moveThreshhold = Max< float >( radius, 32.0f );
			if( idMath::Fabs( delta.y ) > moveThreshhold ) {
				GetUI()->cursorPos = GetUI()->screenCenter;

				if( delta.y < 0.0f && currentItem > 0 ) {
					currentItem--;
				} else if( delta.y > 0.0f && currentItem < page.items.Num() ) {
					currentItem++;
				}
			}
			this->currentItem = idMath::ClampInt( 0, page.items.Num() - 1, currentItem );
		}
	
	} else if ( event->IsMouseButtonEvent() ) {
		if ( event->IsButtonDown() ) {
			// handle mouse wheel
			if ( drawStyle == DS_VERTICAL ) {
				mouseButton_t mb = event->GetMouseButton();
				if ( mb == M_MWHEELUP ) {
					currentItem--;
					retVal = true;
				} else if ( mb == M_MWHEELDOWN ) {
					currentItem++;
					retVal = true;
				}
				this->currentItem = idMath::ClampInt( 0, page.items.Num() - 1, currentItem );
			}
		}
	} else if ( event->IsKeyEvent() ) {
		if ( event->IsKeyDown() && lastActiveEventFrame != gameLocal.framenum ) {
			bool useIndex = TestFlag( RMF_USE_NUMBER_SHORTCUTS );
			keyNum_t keyNum = K_INVALID;

			for ( int i = 0; i < page.items.Num(); i++ ) {
				const radialItem_t& item = page.items[ i ];
				if ( !item.flags.enabled ) {
					continue;
				}

				if ( useIndex ) {
					if ( !item.commandNumberKey.IsEmpty() ) {
						keyNum = sys->Keyboard().ConvertCharToKey( item.commandNumberKey.c_str()[0] );	// FIXME: change storage to just a char
					} else {
						if ( i == 9 ) {
							keyNum = K_0;
						} else {
							keyNum = (keyNum_t)( K_1 + i );
						}						
					}
				} else {
					keyNum = sys->Keyboard().ConvertCharToKey( item.commandKey.c_str()[0] );	// FIXME: change storage to just a char
				}

				if ( keyNum == K_INVALID ) {
					continue;
				}

				if ( event->GetKey() == keyNum ) {
					this->currentItem = i;
					for ( int cmdIndex = 0; cmdIndex < item.commandID.Num(); cmdIndex++ ) {
						const char* id = item.commandID[ cmdIndex ];
						int eventID = namedEvents.FindIndex( id );
						if ( eventID == -1 || !RunEvent( sdUIEventInfo( RME_COMMAND, eventID ) ) ) {
							gameLocal.Warning( "sdUIRadialMenu::PostEvent: no command handler provided for '%s' (item '%s')", id, item.title == NULL ? "NULL" : item.title->GetName() );
						} else {
							lastActiveEventFrame = gameLocal.framenum;
						}
					}
					retVal = true;
					break;
				}
			}
		}
	}

	if ( !retVal ) {
		if ( event->IsMouseButtonEvent() || event->IsKeyEvent() ) {
			windowEvent_t eventID = event->IsKeyDown() ? WE_KEYDOWN : WE_KEYUP;

			retVal |= HandleBoundKeyInput( event );
			if ( !retVal && lastActiveEventFrame != gameLocal.framenum ) {
				bool down;
				idKey* key = keyInputManager->GetKeyForEvent( *event, down );
				int keyId = key == NULL ? -1 : key->GetId();

				retVal |= RunEvent( sdUIEventInfo( eventID, keyId ) );

				if ( retVal == true && event->GetMouseButton() == M_MOUSE1 ) {
					lastActiveEventFrame = gameLocal.framenum;
				}
			}
		}
	}

	return retVal;
}

/*
============
sdUIRadialMenu::Script_InsertItem
============
*/
void sdUIRadialMenu::Script_InsertItem( sdUIFunctionStack& stack ) {	
	int pageNum;
	stack.Pop( pageNum );
	if( pageNum < 0 ) {
		pageNum = idMath::Ftoi( currentPage );		
	}

	if( pageNum < 0 || pageNum > pages.Num() ) {
		stack.Push( -1.0f );
		return;
	}

	radialPage_t& page = pages[ pageNum ];
	radialItem_t& item = page.items.Alloc();

	idStr title;
	stack.Pop( title );

	idStrList list;
	idSplitStringIntoList( list, title.c_str(), "||" );
	if( list.Num() >= 1 ) {
		item.title = declHolder.FindLocStr( list[ 0 ].c_str() );
		if( item.title->GetState() == DS_DEFAULTED ) {
			gameLocal.Warning( "Invalid title %s", item.title->GetName() );
		}
	}

	if( list.Num() >= 2 ) {
		idSplitStringIntoList( item.commandID, list[ 1 ].c_str(), "," );
	}

	if( list.Num() >= 3 ) {
		idSplitStringIntoList( item.commandData, list[ 2 ].c_str(), "," );
	}

	if( list.Num() >= 4 ) {
		item.commandKey = list[ 3 ];
	}

	item.commandNumberKey = "";

	stack.Push( page.items.Num() - 1 );

	MakeLayoutDirty();
}

/*
============
sdUIRadialMenu::Script_InsertPage
============
*/
void sdUIRadialMenu::Script_InsertPage( sdUIFunctionStack& stack ) {	
	radialPage_t& page = pages.Alloc();

	idStr title;
	stack.Pop( title );
	page.title = declHolder.FindLocStr( title );
	if( page.title->GetState() == DS_DEFAULTED ) {
		gameLocal.Warning( "Invalid title %s", page.title->GetName() );
	}

	currentPage = pages.Num() - 1;
	stack.Push( currentPage );
}

/*
============
sdUIRadialMenu::Script_PushPage
============
*/
void sdUIRadialMenu::Script_PushPage( sdUIFunctionStack& stack ) {	
	int index;
	stack.Pop( index );
	pageStack.Push( index );
	currentPage = index;

	GetUI()->cursorPos = GetUI()->screenCenter;
	lastArcMoveInfo.x = 0.0f;
	lastArcMoveInfo.y = 0.0f;

	imaginaryCursorPos = GetUI()->screenCenter;

	RunEvent( sdUIEventInfo( RME_PAGE_PUSHED, 0 ) );
}

/*
============
sdUIRadialMenu::Script_PopPage
============
*/
void sdUIRadialMenu::Script_PopPage( sdUIFunctionStack& stack ) {	
	int index = -1;
	
	if( !pageStack.Empty() ) {
		pageStack.Pop();		
	}
	if( !pageStack.Empty() ) {
		index = pageStack.Top();
	}
	currentPage = index;
	stack.Push( index );
	RunEvent( sdUIEventInfo( RME_PAGE_POPPED, 0 ) );
}

/*
============
sdUIRadialMenu::OnCurrentPageChanged
============
*/
void sdUIRadialMenu::OnCurrentPageChanged( const float oldValue, const float newValue ) {
	radialPage_t* oldPage = GetSafePage( idMath::Ftoi( oldValue ) );
	radialPage_t* newPage = GetSafePage( idMath::Ftoi( newValue ) );
	if( oldPage != NULL ) {
		oldPage->currentItem = idMath::Ftoi( currentItem );
	}
	if( newPage != NULL ) {
		if( idMath::Ftoi( drawStyle ) != DS_ARC ) {
			MoveToFirstEnabledItem( newPage->currentItem );
		} else {
			currentItem = -1.0f;
		}
			
		newPage->maxSize.Zero();
		MakeLayoutDirty();
	} else {
		currentItem = 0.0f;
	}
}

/*
============
sdUIRadialMenu::Script_GetItemData
============
*/
void sdUIRadialMenu::Script_GetItemData( sdUIFunctionStack& stack ) {
	int pageNum;
	int itemNum;
	int dataIndex;
	stack.Pop( pageNum );
	stack.Pop( itemNum );
	stack.Pop( dataIndex );

	if( dataIndex < 0 ) {
		dataIndex = 0;
	}

	if( pageNum < 0 ) {
		pageNum = idMath::Ftoi( currentPage );
	}
	
	if( itemNum < 0 ) {
		itemNum = idMath::Ftoi( currentItem );		
	}

	radialItem_t* item = GetSafeItem( pageNum, itemNum );
	if( !item || dataIndex >= item->commandData.Num() ) {
		stack.Push( "" );
		return;
	}
	
	stack.Push( item->commandData[ dataIndex ] );
}


/*
============
sdUIRadialMenu::Script_ClearPage
============
*/
void sdUIRadialMenu::Script_ClearPage( sdUIFunctionStack& stack ) {
	int pageNum;
	stack.Pop( pageNum );
	if( pageNum < 0 ) {
		pageNum = idMath::Ftoi( currentPage );
	}

	if( radialPage_t* page = GetSafePage( pageNum )) {
		page->items.Clear();
		if( pageNum == currentPage ) {
			page->currentItem = -1;
		}
	}
	MakeLayoutDirty();
}

/*
============
sdUIRadialMenu::Script_ClearPageStack
============
*/
void sdUIRadialMenu::Script_ClearPageStack( sdUIFunctionStack& stack ) {
	pageStack.Clear();
}


/*
============
sdUIRadialMenu::Script_PostCommand
============
*/
void sdUIRadialMenu::Script_PostCommand( sdUIFunctionStack& stack ) {
	int pageNum;
	stack.Pop( pageNum );
	if( pageNum < 0.0f ) {
		pageNum = idMath::Ftoi( currentPage );
	}

	int itemNum;
	stack.Pop( itemNum );
	if( itemNum < 0.0f ) {
		itemNum = idMath::Ftoi( currentItem );
	}


	if( radialItem_t* item = GetSafeItem( pageNum, itemNum )) {
		if ( item->flags.enabled ) {
			for( int cmdIndex = 0; cmdIndex < item->commandID.Num(); cmdIndex++ ) {
				const char* id = item->commandID[ cmdIndex ];
				int eventID = namedEvents.FindIndex( id );
				if( eventID == -1 || !RunEvent( sdUIEventInfo( RME_COMMAND, eventID ) ) ) {
					gameLocal.Warning( "sdUIRadialMenu::PostEvent: no command handler provided for '%s' (item '%s')", id, item->title == NULL ? "NULL" : item->title->GetName() );
				}
			}
		}
	}
}

/*
============
sdUIRadialMenu::Script_LoadFromDef
============
*/
void sdUIRadialMenu::Script_LoadFromDef( sdUIFunctionStack& stack ) {
	idStr defName;
	stack.Pop( defName );

	Clear( this );

	if( defName.IsEmpty() ) {
		gameLocal.Warning( "sdUIRadialMenu::Script_LoadFromDef: gui '%s': window '%s', tried to load an empty radialMenuDef", GetUI()->GetName(), name.GetValue().c_str() );
		return;
	}

	const sdDeclRadialMenu* def = gameLocal.declRadialMenuType.LocalFind( defName, true );
	declManager->AddDependency( GetUI()->GetDecl(), def );

	for( int i = 0; i < def->GetNumPages(); i++ ) {
		declManager->AddDependency( GetUI()->GetDecl(), &def->GetPage( i ) );

		radialPage_t& page = pages.Alloc();
		page.title = def->GetPage( i ).GetTitle();
		if( page.title->GetState() == DS_DEFAULTED ) {
			gameLocal.Warning( "sdUIRadialMenu::Script_LoadFromDef: gui '%s': window '%s', defaulted title for '%s'", GetUI()->GetName(), name.GetValue().c_str(), page.title->GetName() );
		}
		page.popFactor = def->GetPage( i ).GetKeys().GetFloat( "popFactor", "1.5" );
		LoadFromDef( def->GetPage( i ), page );
	}
	
	if( pages.Num() ) {
		currentPage = 0.0f;
		if( pages.Front().items.Num() ) {
			currentItem = 0.0f;
		}
	}
	MakeLayoutDirty();
}


/*
============
LoadPrefixFromDict
============
*/
void LoadPrefixFromDict( const char* prefix, const idDict& dict, idStrList& list ) {
	const idKeyValue* kv = dict.FindKey( prefix );
	if( kv ) {
		list.Append( kv->GetValue() );
	}

	int index = 1;
	kv = dict.FindKey( va( "%s%i", prefix, index ) );
	while( kv ) {
		list.Append( kv->GetValue() );
		index++;
		kv = dict.FindKey( va( "%s%i", prefix, index ) );
	}
}

/*
============
sdUIRadialMenu::LoadFromDef
============
*/
void sdUIRadialMenu::LoadFromDef( const sdDeclRadialMenu& def, radialPage_t& page ) {
	const char* tempStr = NULL;
	for( int i = 0; i < def.GetNumItems(); i++ ) {
		if( i >= MAX_ITEMS_PER_PAGE ) {
			const char* pageTitle = va( "%ls", page.title->GetText() );
			gameLocal.Warning( "More than %i items on page '%s'", MAX_ITEMS_PER_PAGE, pageTitle );
			return;
		}

		radialItem_t& item = page.items.Alloc();
		item.owner = this;

		const idDict& keys = def.GetItemKeys( i );
		LoadPrefixFromDict( "data",		keys, item.commandData );
		LoadPrefixFromDict( "command",	keys, item.commandID );
		
		item.commandKey				= keys.GetString( "key" );
		item.commandNumberKey		= keys.GetString( "numberKey" );
		
		item.title					= def.GetItemTitle( i );
		item.flags.drawChevron		= keys.GetBool( "drawChevron", "0" );
		item.flags.enabled			= keys.GetBool( "enabled", "1" );
		item.drawCallback			= keys.GetString( "draw", "" );

		if( item.title->GetState() == DS_DEFAULTED ) {
			gameLocal.Warning( "sdUIRadialMenu::Script_LoadFromDef: gui '%s': window '%s', defaulted title for '%s' on page '%s'", GetUI()->GetName(), name.GetValue().c_str(), item.title->GetName(), page.title->GetName() );
		}

		item.scriptUpdateCallback	= keys.GetString( "scriptUpdate" );
		item.scriptUpdateParm		= keys.GetString( "scriptUpdateParm" );

		tempStr = keys.GetString( "mtr_icon" );
		if( tempStr[ 0 ] != '\0' ) {
			GetUI()->LookupMaterial( tempStr, item.part.mi, &item.part.width, &item.part.height );
		}
	}
}

/*
============
sdUIRadialMenu::Script_AppendFromDef
============
*/
void sdUIRadialMenu::Script_AppendFromDef( sdUIFunctionStack& stack ) {
	idStr defName;
	stack.Pop( defName );
	int pageNum;
	stack.Pop( pageNum );

	if( defName.IsEmpty() ) {
		gameLocal.Warning( "sdUIRadialMenu::Script_LoadFromDef: gui '%s': window '%s', tried to load an empty radialMenuDef", GetUI()->GetName(), name.GetValue().c_str() );
		return;
	}

	const sdDeclRadialMenu* def = gameLocal.declRadialMenuType.LocalFind( defName, true );
	declManager->AddDependency( GetUI()->GetDecl(), def );

	if( pageNum < 0.0f ) {
		pageNum = idMath::Ftoi( currentPage );
	}

	if( radialPage_t* page = GetSafePage( pageNum ) ) {
		LoadFromDef( *def, *page );
	}
	MakeLayoutDirty();
}

/*
============
sdUIRadialMenu::ClearPage
============
*/
void sdUIRadialMenu::Clear( sdUIRadialMenu* menu ) {
	sdUIFunctionStack stack;

	menu->RunNamedMethod( "clear", stack );
}

/*
============
sdUIRadialMenu::InsertPage
============
*/
int sdUIRadialMenu::InsertPage( sdUIRadialMenu* menu, int page, const char* text ) {
	sdUIFunctionStack stack;
	stack.Push( page );
	stack.Push( text );

	if( !menu->RunNamedMethod( "insertPage", stack ) ) {
		return -1;
	}

	int retVal;
	stack.Pop( retVal );
	return retVal;
}

/*
============
sdUIRadialMenu::InsertItem
============
*/
int sdUIRadialMenu::InsertItem( sdUIRadialMenu* menu, int page, const char* text ) {
	sdUIFunctionStack stack;
	stack.Push( page );
	stack.Push( text );

	if( !menu->RunNamedMethod( "insertItem", stack ) ) {
		return -1;
	}

	int retVal;
	stack.Pop( retVal );
	return retVal;
}

/*
============
sdUIRadialMenu::Script_FillFromEnumerator
============
*/
void sdUIRadialMenu::Script_FillFromEnumerator( sdUIFunctionStack& stack ) {
	idStr name;
	stack.Pop( name );


	uiRadialMenuEnumerationCallback_t enumerator = uiManager->GetRadialMenuEnumerationCallback( name );
	if ( enumerator != NULL ) {
		enumerator( this );
	} else {
		gameLocal.Warning( "sdUIRadialMenu::Script_FillFromEnumerator: '%s' Unknown enumerator '%s'", this->name.GetValue().c_str(), name.c_str() );
	}
}

/*
============
sdUIRadialMenu::Script_Clear
============
*/
void sdUIRadialMenu::Script_Clear( sdUIFunctionStack& stack ) {
	pages.Clear();
	pageStack.Clear();
	currentItem = -1.0f;
	currentPage = -1.0f;
	MakeLayoutDirty();
	lastActiveEventFrame = -1;
}

/*
============
sdUIRadialMenu::OnValidateCurrentItem
============
*/
bool sdUIRadialMenu::OnValidateCurrentItem( const float newValue ) {
	radialPage_t* page = GetSafePage( currentPage );
	if( page == NULL ) {
		return true;	// allow resetting the current selection when we're empty
	}
	int index = idMath::Ftoi( newValue );

	// arc style has a dead zone in the center that can be accessed
	if( ( newValue < 0 && idMath::Ftoi( drawStyle ) != DS_ARC ) || newValue >= page->items.Num() ) {
		return false;
	}
// jrad - allow selection of disabled items to improve usability (muscle-memory)
	/*
	if( page->items[ index ].flags.enabled == false ) {
		return false;
	}
	*/
	return true;
}

/*
============
sdUIRadialMenu::Script_TransitionItemVec4
============
*/
void sdUIRadialMenu::Script_TransitionItemVec4( sdUIFunctionStack& stack ) {
	float property;
	float page;
	float item;
	idVec4 from;
	idVec4 to;
	float time;
	idStr accel;

	stack.Pop( property );
	stack.Pop( from );
	stack.Pop( to );
	stack.Pop( time );
	stack.Pop( accel );
	stack.Pop( item );	
	stack.Pop( page );

	if( time < 0.0f ) {
		gameLocal.Error( "TransitionItemVec4: '%s' duration '%i' out of bounds", name.GetValue().c_str(), idMath::Ftoi( time ) );
		return;
	}

	// handle all pages
	if( page < 0.0f ) {
		for( int i = 0; i < pages.Num(); i++ ) {			
			InitVec4Transition( idMath::Ftoi( property ), from, to, idMath::Ftoi( time ), accel, item, i );
		}
	} else {
		InitVec4Transition( idMath::Ftoi( property ), from, to, idMath::Ftoi( time ), accel, item, page );
	}
}


/*
============
sdUIRadialMenu::InitVec4Transition
============
*/
void sdUIRadialMenu::InitVec4Transition( const int property, const idVec4& from, const idVec4& to, const int time, const idStr& accel, int item, int page ) {
	radialItem_t* radialItem = GetSafeItem( page, item );
	if( radialItem == NULL ) {
		return;
	}

	vec4Evaluator_t* evaluator = radialItem->transition.GetEvaluator( property, true );
	assert( evaluator != NULL );

	evaluator->InitLerp( GetUI()->GetCurrentTime(), GetUI()->GetCurrentTime() + idMath::Ftoi( time ), from, to );

	if( !accel.IsEmpty() ) {
		idLexer src( accel.c_str(), accel.Length(), "TransitionItemVec4", LEXFL_NOERRORS );
		idToken token;

		if( !src.ReadToken( &token ) ) {
			gameLocal.Error( "TransitionItemVec4: '%s' invalid acceleration", name.GetValue().c_str() );
			return;
		}
		bool isTable = idStr::Icmpn( token, "table://", 8 ) == 0;
		if( !isTable ) {
			idVec2 accelTimes;
			accelTimes.x = src.ParseFloat();
			src.ExpectTokenString( "," );
			accelTimes.y = src.ParseFloat();

			evaluator->InitAccelDecelEvaluation( accelTimes.x, accelTimes.y );
		} else if( token.Length() > 8 ) {
			evaluator->InitTableEvaluation( token.c_str() + 8 );
		}
	}
}

/*
============
sdUIRadialMenu::Script_GetItemTransitionVec4Result
============
*/
void sdUIRadialMenu::Script_GetItemTransitionVec4Result( sdUIFunctionStack& stack ) {
	float	property;
	idVec4	defaultValue;
	float	page;
	float	item;

	stack.Pop( property );
	stack.Pop( defaultValue );
	stack.Pop( item );	
	stack.Pop( page );

	if( property < RTP_FORECOLOR || property >= RTP_PROPERTY_MAX ) {
		gameLocal.Error( "GetItemTransitionVec4Result: '%s' property index '%i' out of bounds", name.GetValue().c_str(), idMath::Ftoi( property ) );
		stack.Push( defaultValue );
		return;
	}

	radialItem_t* radialItem = GetSafeItem(  page, item );
	if( radialItem == NULL ) {
		stack.Push( defaultValue );
		return;
	}

	vec4Evaluator_t* evaluator = radialItem->transition.GetEvaluator( idMath::Ftoi( property ), false );

	if( evaluator == NULL || !evaluator->IsInitialized() ) {
		stack.Push( defaultValue );
		return;
	}
	idVec4 result = evaluator->Evaluate( GetUI()->GetCurrentTime() );
	stack.Push( result );
}


/*
============
sdUIRadialMenu::Script_ClearTransitions
============
*/
void sdUIRadialMenu::Script_ClearTransitions( sdUIFunctionStack& stack ) {
	float item;
	float page;

	stack.Pop( item );
	stack.Pop( page );

	if( page >= pages.Num() ) {
		gameLocal.Warning( "ClearTransitions: '%s' page '%i' out of bounds", name.GetValue().c_str(), idMath::Ftoi( page ) );
		return;
	}

	int iItem = idMath::Ftoi( item );

	if( page < 0.0f ) {
		// clear all columns
		for( int i = 0; i < pages.Num(); i++ ) {
			radialPage_t& page = pages[ i ];

			if( iItem < 0 ) {
				for( int trans = 0; trans < page.items.Num(); trans++ ) {
					ClearTransition( page.items[ trans ].transition );
				}				
			} else {
				ClearTransition( page.items[ iItem ].transition );
			}
		}
	} else {
		radialPage_t& radialPage = pages[ page ];
		if( iItem < 0 ) {
			for( int trans = 0; trans < radialPage.items.Num(); trans++ ) {
				ClearTransition( radialPage.items[ trans ].transition );				
			}			
		} else if( iItem < radialPage.items.Num() ) {
			ClearTransition( radialPage.items[ iItem ].transition );
		}
	}
}


/*
============
sdUIRadialMenu::ClearTransition
============
*/
void sdUIRadialMenu::ClearTransition( sdTransition& transition ) {
	static const idVec4 colorInvisible( 0.0f, 0.0f, 0.0f, 0.0f );
	transition.backColor.InitConstant( colorInvisible );
	transition.foreColor.InitConstant( colorWhite );
	transition.FreeEvaluators();
}
/*
============
sdUIRadialMenu::GetEvaluator
============
*/
sdUIRadialMenu::vec4Evaluator_t* sdUIRadialMenu::sdTransition::GetEvaluator( int index, bool allowCreate ) {
	switch( index ) {
		case RTP_FORECOLOR:
			return &foreColor;
		case RTP_BACKCOLOR:
			return &backColor;
		default:
			if( evaluators == NULL ) {
				if( !allowCreate ) {
					return NULL;
				}
				evaluators = vec4EvaluatorListAllocator.Alloc();
				evaluators->SetNum( MAX_VEC4_EVALUATORS );
			}
			return &(*evaluators)[ index ];
	}
}

/*
============
sdUIRadialMenu::MoveToFirstEnabledItem
============
*/
void sdUIRadialMenu::MoveToFirstEnabledItem( int index ) {
	if( currentPage < 0 || currentPage >= pages.Num() ) {
		currentItem = -1.0f;
		return;
	}	
	currentItem = index;
	/* jrad - allow selection of disabled items to improve usability (muscle-memory)
	int item = idMath::Ftoi( currentItem );	
	radialPage_t& page = pages[ idMath::Ftoi( currentPage ) ];

	if( page.items.Num() == 0 ) {
		return;
	}

	if( item < 0 || item >= page.items.Num() ) {
		item = 0;
	}
	
	if( item >= page.items.Num() ) {
		return;
	}

	// see if the current item is available
	page.items[ item ].Update();
	if( page.items[ item ].flags.enabled ) {
		currentItem = item;
		return;
	}

	// find the next item that's available
	for ( int i = 0; i < page.items.Num(); i++ ) {
		page.items[ i ].Update();
		if( page.items[ i ].flags.enabled ) {
			currentItem = i;
			break;
		}
	}
	currentItem = -1.0f;
	*/
}


/*
============
sdUIRadialMenu::OnValidateDrawStyle
============
*/
bool sdUIRadialMenu::OnValidateDrawStyle( const float newValue ) {
	int iValue = idMath::Ftoi( newValue );
	return ( iValue >= DS_INVALID && iValue < DS_MAX );
}


/*
============
sdUIRadialMenu::ApplyLayout
============
*/
void sdUIRadialMenu::ApplyLayout() {	
	if( windowState.recalculateLayout ) {
		int textWidth;
		int textHeight;
		radialPage_t* newPage = GetSafePage( idMath::Ftoi( currentPage ) );
		if( newPage == NULL ) {
			assert( 0 );
			return;
		}
		
		ActivateFont( true );
		sdBounds2D screenBounds( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT );

		for( int i = 0; i < newPage->items.Num(); i++ ) {
			radialItem_t& item = newPage->items[ i ];
			deviceContext->GetTextDimensions( item.title->GetText(), screenBounds, GetDrawTextFlags(), cachedFontHandle, fontSize, textWidth, textHeight );
			item.size.Set( textWidth, textHeight );
			newPage->maxSize.x = Max( idMath::Ftoi( newPage->maxSize.x ), textWidth );
			newPage->maxSize.y = Max( idMath::Ftoi( newPage->maxSize.y ), textHeight );
		}
	}
	sdUIWindow::ApplyLayout();
}

/*
============
sdUIRadialMenu::OnDrawStyleChanged
============
*/
void sdUIRadialMenu::OnDrawStyleChanged( const float oldValue, const float newValue ) {
	MakeLayoutDirty();
}