////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu.c
//
//	Copyright (c) 1999, WildTangent, Inc.; All rights reserved.
//
//	API to manage menus.
//
//	History
//	-------
//
//	Peter Siamidis	07/08/98	Created.
//
////////////////////////////////////////////////////////////////////////////////////////
#define	WIN32_LEAN_AND_MEAN
#pragma warning ( disable : 4201 4214 )
#include <windows.h>
#pragma warning ( default : 4201 4214 )
#include <string.h>
#include <assert.h>
#include "Genesis.h"
#include "Ram.h"
#include "Text.h"
#include "MenuItem.h"


#define MENU_ITEMCHECKED_ACTIVE_STRING ("x ")
#define MENU_SELECTED_BORDER (24)		// selected menu item will stay in a box that the menu height, trimmed 
										// by this many pixels on the top and bottom
////////////////////////////////////////////////////////////////////////////////////////
//	Structs
////////////////////////////////////////////////////////////////////////////////////////

// generic menu item
typedef struct tag_MenuItem_T
{

	// adjacent menu items
	struct tag_MenuItem_T	*Next;
	struct tag_MenuItem_T	*Prev;

	// data
	int32			Identifier;	// unique menu item identifier
	Menu_ItemType	ItemType;	// what type of item it is
	int32			MaxWidth;	// max item width
	int32			MaxHeight;	// max item height
	void			*Data;		// item data

} MenuItem_T;

// menu
typedef struct
{
	geEngine	*Engine;				// engine in which menu will be drawn
	int32		Width;					// menu width
	int32		Top,Bottom;				// menu top and bottom (bottom-top = height)
	int32		ItemWidth, ItemHeight;	// dimensions of all menu items
	int32		x, y;					// menu location
	int32		ItemCount;				// how many items are in the menu
	int32		Identifier;				// numeric menu identifier
	MenuItem_T	*Head;					// head of the menu
	MenuItem_T	*Current;				// current active menu item
	int32		MinimumSelectedY;		// minimum allowed y value for top of selected menu item
	int32		MaximumSelectedY;		// maximum allowed y value for bottom of selected menu item
} Menu_T;



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_ToggleItem()
//
//	Toggle a menu item.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_ToggleItem(
	Menu_T		*Menu,			// menu to search through
	int32		Identifier )	// toggle to be toggled
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemToggle_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemToggle );
			Data = (MenuItemToggle_T *)CurItem->Data;
			assert( Data != NULL );

			// toggle the item
			Data->ActiveItem = !Data->ActiveItem;

			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the string in question was not found
	return GE_FALSE;

} // Menu_ToggleItem()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_FlagString()
//
//	Marks a string item for change or no change.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_FlagString(
	Menu_T		*Menu,		// menu to search through
	int32		Identifier,	// string to be marked for change
	geBoolean	Flag )		// new setting
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemString_T	*Data;
			int32				Size;

			// get item data
			assert( CurItem->ItemType == Menu_ItemString );
			Data = (MenuItemString_T *)CurItem->Data;
			assert( Data != NULL );

			// mark for change
			Data->AwaitingInput = Flag;

			Size = strlen(Data->StringData);

			if (Flag)
			{
				if (Size + 2 < MENU_MAXSTRINGSIZE)
				{
					Data->StringData[Size] = 0x40;
					Data->StringData[Size+1] = 0;
				}
			}
			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the string in question was not found
	return GE_FALSE;

} // Menu_FlagString()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_FlagField()
//
//	Marks a field for change or no change.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_FlagField(
	Menu_T		*Menu,		// menu to search through
	int32		Identifier,	// field to be marked for change
	geBoolean	Flag )		// new setting
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemField_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemField );
			Data = (MenuItemField_T *)CurItem->Data;
			assert( Data != NULL );

			// mark for change
			Data->AwaitingChange = Flag;

			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the field in question was not found
	return GE_FALSE;

} // Menu_FlagField()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_SetFieldText()
//
//	Sets a fields text data.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_SetFieldText(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier,		// field whose text we want to set
	char	*NewText )		// text to set in field text data
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( ( Menu == NULL ) || ( NewText == NULL ) )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemField_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemField );
			Data = (MenuItemField_T *)CurItem->Data;
			assert( Data != NULL );

			// save new field text
			strcpy( Data->FieldTextData, NewText );
			Data->FieldTextDataLength = strlen( Data->FieldTextData );

			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the field in question was not found
	return GE_FALSE;

} // Menu_SetFieldText()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_SetStringText()
//
//	Sets a string items data.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_SetStringText(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier,		// field whose text we want to set
	char	*NewText )		// text to set in string data
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( ( Menu == NULL ) || ( NewText == NULL ) )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemString_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemString );
			Data = (MenuItemString_T *)CurItem->Data;
			assert( Data != NULL );

			// save new string text
			strcpy( Data->StringData, NewText );
			Data->StringDataLength = strlen( Data->StringData );

			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the string in question was not found
	return GE_FALSE;

} // Menu_SetStringText()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_GetStringText()
//
//	Gets a string items data.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_GetStringText(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier,		// field whose text we want to set
	char	*NewText )		// text to set in string data
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( ( Menu == NULL ) || ( NewText == NULL ) )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemString_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemString );
			Data = (MenuItemString_T *)CurItem->Data;
			assert( Data != NULL );

			// save new string text
			strcpy(NewText, Data->StringData);
			Data->StringDataLength = strlen( Data->StringData );

			// return slider percentage
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the string in question was not found
	return GE_FALSE;

} // Menu_GetStringText()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_GetIdentifier()
//
//	Gets a menus identifier.
//
////////////////////////////////////////////////////////////////////////////////////////
int32 Menu_GetIdentifier(
	Menu_T	*Menu )		// menu whose identifier we want
{

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return -1;
	}

	// return identifier
	return Menu->Identifier;

} // Menu_GetIdentifier()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_GetSliderPercent()
//
//	Get what percentage a slider is set at.
//
////////////////////////////////////////////////////////////////////////////////////////
float Menu_GetSliderPercent(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier )	// slider whose percentage we want
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return -1.0f;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemSlider_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemSlider );
			Data = (MenuItemSlider_T *)CurItem->Data;
			assert( Data != NULL );

			// return slider percentage
			return Data->Percent;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the slider in question was not found
	return -1.0f;

} // Menu_GetSliderPercent()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_SetSliderText()
//
////////////////////////////////////////////////////////////////////////////////////////
void Menu_SetSliderText(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier, 
    char * NewText)
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return;// -1.0f;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{
			// locals
			MenuItemSlider_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemSlider );
			Data = (MenuItemSlider_T *)CurItem->Data;
			assert( Data != NULL );

            strcpy(Data->Text, NewText);
            Data->TextLength = strlen(NewText);

			return;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the slider in question was not found
	return;

} // Menu_GetSliderPercent()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_SetSliderPercent()
//
//	Set what percentage a slider is set at.
//
////////////////////////////////////////////////////////////////////////////////////////
void Menu_SetSliderPercent(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier, 
    float Percent)
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return;// -1.0f;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its percentage
		if ( CurItem->Identifier == Identifier )
		{
			// locals
			MenuItemSlider_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemSlider );
			Data = (MenuItemSlider_T *)CurItem->Data;
			assert( Data != NULL );

            Data->Percent = Percent;

			return;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the slider in question was not found
	return;

} // Menu_SetSliderPercent()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_GetItemSize()
//
//	Gets how many bytes an item requires.
//
////////////////////////////////////////////////////////////////////////////////////////
static int32 Menu_GetItemSize(
	Menu_ItemType	ItemType )		// item whose size we want
{

	// return item size
	switch ( ItemType )
	{
		case Menu_ItemText:
		{
			return sizeof( MenuItemText_T );
		}

		case Menu_ItemSlider:
		{
			return sizeof( MenuItemSlider_T );
		}

		case Menu_ItemField:
		{
			return sizeof( MenuItemField_T );
		}

		case Menu_ItemString:
		{
			return sizeof( MenuItemString_T );
		}

		case Menu_ItemGraphic:
		{
			return sizeof( MenuItemGraphic_T );
		}

		case Menu_ItemToggle:
		{
			return sizeof( MenuItemToggle_T );
		}

		case Menu_ItemChecked:
		{
			return sizeof( MenuItemChecked_T );
		}
	}

	// if we got to here then a size was not found
	assert( 0 );
	return 0;

} //Menu_GetItemSize()


////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_GetCheckedData()
//
//	Get extra data associated with menu item 
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_GetCheckedData(
	Menu_T	*Menu,			// menu to search through
	int32	Identifier,
	int32  *UserData )	// store the data here
{

	// locals	
	MenuItem_T	*CurItem;

	// fail if we have bad data
	if ( Menu == NULL || UserData == NULL )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// search all items
	CurItem = Menu->Head;
	while ( CurItem != NULL )
	{
		
		// if its a match then get its data
		if ( CurItem->Identifier == Identifier )
		{

			// locals
			MenuItemChecked_T	*Data;

			// get item data
			assert( CurItem->ItemType == Menu_ItemChecked );
			Data = (MenuItemChecked_T *)CurItem->Data;
			assert( Data != NULL );

			*UserData = Data->UserData;
			return GE_TRUE;
		}

		// go to next item
		CurItem = CurItem->Next;
	}

	// if we got to here then the checked item in question was not found
	return GE_FALSE;

} // Menu_GetSliderPercent()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_Create()
//
//	Create a new menu.
//
////////////////////////////////////////////////////////////////////////////////////////
Menu_T * Menu_Create(
	geEngine	*Engine,		// engine in which menu exists
	int32		Width,			// menu width
	int32		Top,			// top of menu
	int32		Bottom,			// bottom of menu  (bottom-top = menu height)
	int32		x,				// x position
	int32		y,				// y position
	int32		Identifier )	// menu identifier
{

	// locals
	Menu_T	*Menu;

	// fail if we have bad data
	if (	( Engine == NULL ) ||
			( Width <= 0 ) ||
			( Top < 0 ) ||
			( Bottom < Top ) )
	{
		assert( 0 );
		return NULL;
	}

	// allocate new menu struct
	Menu = geRam_Allocate( sizeof( *Menu ) );
	if ( Menu == NULL )
	{
		return NULL;
	}
	memset( Menu, 0, sizeof( *Menu ) );

	// save passed data
	Menu->Engine = Engine;
	Menu->Width = Width;
	//Menu->Height = Height;
	Menu->Top = Top;
	Menu->Bottom = Bottom;
	Menu->x = x;
	Menu->y = y;
	Menu->Identifier = Identifier;

	// return new menu pointer
	return Menu;

} // Menu_Create()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_Destroy()
//
//	Destroy a menu.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_Destroy(
	Menu_T	**Menu )		// menu to destroy
{

	// locals
	MenuItem_T	*CurMenuItem;
	MenuItem_T	*NextMenuItem;

	// fail if we have bad data
	if ( *Menu == NULL )
	{
		return GE_FALSE;
	}

	// free all items
	CurMenuItem = ( *Menu )->Head;
	while ( CurMenuItem != NULL )
	{
		NextMenuItem = CurMenuItem->Next;
		geRam_Free( CurMenuItem->Data );
		geRam_Free( CurMenuItem );
		CurMenuItem = NextMenuItem;
	}

	// destroy the menu itself
	geRam_Free( *Menu );
	*Menu = NULL;

	// all done
	return GE_TRUE;

} // Menu_Destroy()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_AddItem()
//
//	Add an item to a menu.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_AddItem(
	Menu_T				*Menu,		// menu to add item to
	Menu_ItemType		ItemType,	// what type of item to add
	int32				Identifier,	// unique item identifier
	void				*Data )		// item data
{

	// locals
	MenuItem_T	*Item;
	int32		ItemSize;

	// fail if we have bad data
	if (	( Menu == NULL ) ||
			( Identifier <= 0 ) ||
			( Data == NULL ) )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// determine item size
	ItemSize = Menu_GetItemSize( ItemType );
	if ( ItemSize <= 0 )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// allocate generic menu item data
	Item = (MenuItem_T *)geRam_Allocate( sizeof( *Item ) );
	if ( Item == NULL )
	{
		return GE_FALSE;
	}
	memset( Item, 0, sizeof( *Item ) );

	// allocate specific menu item data
	Item->Data = geRam_Allocate( ItemSize );
	if ( Item->Data == NULL )
	{
		geRam_Free( Item );
		return GE_FALSE;
	}
	memset( Item->Data, 0, ItemSize );

	// save passed data
	Item->Identifier = Identifier;
	Item->ItemType = ItemType;
	memcpy( Item->Data, Data, ItemSize );

	// save items max dimensions
	switch ( ItemType )
	{

		case Menu_ItemText:
		{
			
			// locals
			MenuItemText_T	*TextData;
			int32			Size;

			// get item data
			TextData = (MenuItemText_T *)Data;

			// set max item width
			Size = Text_GetWidth( TextData->NormalFont );
			if ( Text_GetWidth( TextData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( TextData->SelectFont );
			}
			Item->MaxWidth = Size * TextData->TextLength;

			// set max item height
			Size = Text_GetHeight( TextData->NormalFont );
			if ( Text_GetHeight( TextData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( TextData->SelectFont );
			}
			Item->MaxHeight = Size;
			break;
		}

		case Menu_ItemSlider:
		{
			
			// locals
			MenuItemSlider_T	*SliderData;
			int32				TextWidth;
			int32				TextHeight;
			int32				SliderWidth;
			int32				SliderHeight;
			int32				Size;

			// get item data
			SliderData = (MenuItemSlider_T *)Data;

			// get text width
			Size = Text_GetWidth( SliderData->NormalFont );
			if ( Text_GetWidth( SliderData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( SliderData->SelectFont );
			}
			TextWidth = Size * SliderData->TextLength;

			// get text height
			Size = Text_GetHeight( SliderData->NormalFont );
			if ( Text_GetHeight( SliderData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( SliderData->SelectFont );
			}
			TextHeight = Size;

			// get slider width and height //undone, hardcoded
			SliderWidth = 128;// geGetTextureWidth( SliderData->Range );
			SliderHeight = 14;// geGetTextureHeight( SliderData->Bar );

			// set max width and height
			Item->MaxWidth = TextWidth + SliderWidth;
			Item->MaxHeight = ( TextHeight > SliderHeight ) ? TextHeight : SliderHeight;
			break;
		}

		case Menu_ItemField:
		{

			// locals
			MenuItemField_T	*FieldData;
			int32			Size;

			// get item data
			FieldData = (MenuItemField_T *)Data;

			// get text width
			Size = Text_GetWidth( FieldData->NormalFont );
			if ( Text_GetWidth( FieldData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( FieldData->SelectFont );
			}
			Item->MaxWidth = Size * ( FieldData->FieldNameLength + FieldData->FieldTextDataLength );

			// get text height
			Size = Text_GetHeight( FieldData->NormalFont );
			if ( Text_GetHeight( FieldData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( FieldData->SelectFont );
			}
			Item->MaxHeight = Size;
			break;
		}

		case Menu_ItemString:
		{
			
			// locals
			MenuItemString_T	*StringData;
			int32				Size;

			// get item data
			StringData = (MenuItemString_T *)Data;
			assert( StringData != NULL );

			// set max item width
			Size = Text_GetWidth( StringData->NormalFont );
			if ( Text_GetWidth( StringData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( StringData->SelectFont );
			}
			Item->MaxWidth = Size * ( StringData->StringLabelLength + StringData->StringDataLength );

			// set max item height
			Size = Text_GetHeight( StringData->NormalFont );
			if ( Text_GetHeight( StringData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( StringData->SelectFont );
			}
			Item->MaxHeight = Size;
			break;
		}

		case Menu_ItemGraphic:
		{
			// not supported untill we get a function that gives us the
			// dimensions of a texture
			Item->MaxWidth = 1;
			Item->MaxHeight = 1;
			break;
		}

		case Menu_ItemToggle:
		{
			
			// locals
			MenuItemToggle_T	*ToggleData;
			int32				Size;

			// get item data
			ToggleData = (MenuItemToggle_T *)Data;
			assert( ToggleData != NULL );

			// set max item width
			Size = Text_GetWidth( ToggleData->NormalFont );
			if ( Text_GetWidth( ToggleData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( ToggleData->SelectFont );
			}
			Item->MaxWidth = Size * ( ToggleData->ToggleLabelLength + ToggleData->ToggleData1Length );

			// set max item height
			Size = Text_GetHeight( ToggleData->NormalFont );
			if ( Text_GetHeight( ToggleData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( ToggleData->SelectFont );
			}
			Item->MaxHeight = Size;
			break;
		}

		case Menu_ItemChecked:
		{
			
			// locals
			MenuItemChecked_T	*CheckedData;
			int32				Size;

			// get item data
			CheckedData = (MenuItemChecked_T *)Data;
			assert( CheckedData != NULL );

			// set max item width
			Size = Text_GetWidth( CheckedData->NormalFont );
			if ( Text_GetWidth( CheckedData->SelectFont ) > Size )
			{
				Size = Text_GetWidth( CheckedData->SelectFont );
			}
			Item->MaxWidth = Size * ( CheckedData->LabelLength );

			// set max item height
			Size = Text_GetHeight( CheckedData->NormalFont );
			if ( Text_GetHeight( CheckedData->SelectFont ) > Size )
			{
				Size = Text_GetHeight( CheckedData->SelectFont );
			}
			Item->MaxHeight = Size;
			break;
		}

		default:
		{
			assert( 0 );
			geRam_Free( Item );
			return GE_FALSE;
		}
	}

	// bail if the item sizes are bad
	if ( ( Item->MaxWidth <= 0 ) || ( Item->MaxHeight <= 0 ) )
	{
		assert( 0 );
		geRam_Free( Item );
		return GE_FALSE;
	}

	// make menu head...
	if ( Menu->Current == NULL )
	{
		Menu->Head = Menu->Current = Item;
		Menu->ItemCount = 1;
	}
	// ...or just append item
	else
	{

		// find the end of the items
		Menu->Current = Menu->Head;
		while ( Menu->Current->Next != NULL )
		{
			Menu->Current = Menu->Current->Next;
		}

		// append this item
		Menu->Current->Next = Item;
		Item->Prev = Menu->Current;
		Menu->ItemCount++;
		Menu->Current = Menu->Head;
	}

	// adjust size taken up by all menu items
	Menu->ItemHeight += Item->MaxHeight;
	Menu->ItemWidth = ( Menu->ItemWidth < Item->MaxWidth ) ? Item->MaxWidth : Menu->ItemWidth;

	Menu->MaximumSelectedY = Menu->Bottom- MENU_SELECTED_BORDER;
	Menu->MinimumSelectedY = Menu->Top + MENU_SELECTED_BORDER;
	
	// all done
	return GE_TRUE;

} // Menu_AddItem()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_Draw()
//
//	Draw a new menu.
//
////////////////////////////////////////////////////////////////////////////////////////
geBoolean Menu_Draw(
	Menu_T	*Menu )		// menu to draw
{

	// locals
	MenuItem_T	*Item;
	int32		x, y;
	int32		TestY;

	// fail if we have bad data
	if ( Menu == NULL )
	{
		assert( 0 );
		return GE_FALSE;
	}

	// get head of menu
	Item = Menu->Head;
	if ( Item == NULL )
	{
		return GE_FALSE;
	}

	// set starting coordinates
	x = ( Menu->Width / 2 );
	y = ( (Menu->Bottom+Menu->Top) / 2 ) - ( Menu->ItemHeight / 2 );


	// assumes only one item is selected at a time.
	TestY = y;
	while ( Item != NULL )
	{
		if (Menu->Current == Item)
			break;
		TestY += Item->MaxHeight;
		Item=Item->Next;
	}

	if (TestY < Menu->MinimumSelectedY)
		{
			y += Menu->MinimumSelectedY-TestY;
		}
	if (TestY + Item->MaxHeight > Menu->MaximumSelectedY)
		{
			y -= TestY + Item->MaxHeight - Menu->MaximumSelectedY;
		}
			

	Item = Menu->Head;
	// draw all items
	while ( Item != NULL )
	{
		if ( y + Item->MaxHeight > Menu->Bottom)
			break;

		// draw item based on its type
		switch ( Item->ItemType )
		{

			case Menu_ItemText:
			{

				// locals
				MenuItemText_T	*Data;
				FontType		Font;

				// get item data
				Data = (MenuItemText_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// draw text
				Text_Out( Data->Text, Font, x, y, Style_Center );

				y += Item->MaxHeight;
				break;
			}

			case Menu_ItemSlider:
			{

				// locals
				MenuItemSlider_T	*Data;
				FontType			Font;
				int32				RangeWidth, RangeHeight;
				int32				BarWidth, BarHeight;
				int32				SliderX, SliderY;

				// get item data
				Data = (MenuItemSlider_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// draw text
				Text_Out( Data->Text, Font, x, y, Style_RightJustify );

				// get slider dimensions //undone hardcoded
				RangeHeight = 14;// geGetTextureHeight( Data->Range );
				RangeWidth = 128 - Data->Slack;// geGetTextureWidth( Data->Range );
				BarWidth = 16;// geGetTextureWidth( Data->Bar );
				BarHeight = 14;// geGetTextureHeight( Data->Bar );

				// draw slider
				geEngine_DrawBitmap(Menu->Engine, Data->Range, NULL, x, y - ( RangeHeight / 2 ) );

				// draw slider bar
				SliderX = x + ( Data->Slack / 2 ) + (int32)( Data->Percent * (float)RangeWidth ) - ( BarWidth / 2 );
				SliderY = y - ( BarHeight / 2 );
				geEngine_DrawBitmap( Menu->Engine, Data->Bar, NULL, SliderX, SliderY );
				y += Item->MaxHeight;
				break;
			}

			case Menu_ItemField:
			{

				// locals
				MenuItemField_T	*Data;
				FontType		Font;

				// get item data
				Data = (MenuItemField_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// output data fields
				Text_Out( Data->FieldName, Font, x, y, Style_RightJustify );
				if ( Data->AwaitingChange == GE_FALSE )
				{
					Text_Out( Data->FieldTextData, Font, x, y, Style_LeftJustify );
				}
				else
				{
					Text_Out( "PRESS NEW KEY", Font, x, y, Style_LeftJustify );
				}
				y += Item->MaxHeight;
				break;
			}

			case Menu_ItemString:
			{

				// locals
				MenuItemString_T	*Data;
				FontType			Font;

				// get item data
				Data = (MenuItemString_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// output data fields
				Text_Out( Data->StringLabel, Font, x, y, Style_RightJustify );
				Text_Out( Data->StringData, Font, x, y, Style_LeftJustify );
				y += Item->MaxHeight;
				break;
			}

			case Menu_ItemGraphic:
			{

				// locals
				MenuItemGraphic_T	*Data;

				// get item data
				Data = (MenuItemGraphic_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}
				
				// draw graphic
				geEngine_DrawBitmap( Menu->Engine, Data->Art, NULL, Data->x, Data->y );
				break;
			}

			case Menu_ItemToggle:
			{

				// locals
				MenuItemToggle_T	*Data;
				FontType			Font;

				// get item data
				Data = (MenuItemToggle_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// output data fields
				Text_Out( Data->ToggleLabel, Font, x, y, Style_RightJustify );
				if ( Data->ActiveItem == 0 )
				{
					Text_Out( Data->ToggleData1, Font, x, y, Style_LeftJustify );
				}
				else
				{
					Text_Out( Data->ToggleData2, Font, x, y, Style_LeftJustify );
				}
				y += Item->MaxHeight;
				break;
			}
		case Menu_ItemChecked:
			{

				// locals
				MenuItemChecked_T	*Data;
				FontType			Font;
				
				// get item data
				Data = (MenuItemChecked_T *)Item->Data;
				if ( Data == NULL )
				{
					assert( 0 );
					break;
				}

				// choose font
				if ( Menu->Current != Item )
				{
					Font = Data->NormalFont;
				}
				else
				{
					Font = Data->SelectFont;
				}

				// output data fields
				Text_Out( Data->Label, Font, Data->LabelPosition, y, Style_LeftJustify );
				if ( Data->ActiveItem == 1 )
				{
					Text_Out( MENU_ITEMCHECKED_ACTIVE_STRING, Font, Data->LabelPosition, y, Style_RightJustify );
				}
				y += Item->MaxHeight;
				break;
			}

		}

		// get next item
		Item = Item->Next;
	}

	// all done
	return GE_TRUE;

} // Menu_Draw()



////////////////////////////////////////////////////////////////////////////////////////
//
//	Menu_Key()
//
//	Pass a keystroke to a menu.
//
////////////////////////////////////////////////////////////////////////////////////////
int32 Menu_Key(
	Menu_T	*Menu,	// menu to receive the keystroke
	int32	Key )	// input keystroke
{

	// fail if we have invalid data
	if ( Menu == NULL )
	{
		assert( 0 );
		return -1;
	}

	// decide what to do based on keystroke type
	switch( Key )
	{

		// up arrow
		case VK_UP:
		{

			// pick item above as curently selected one...
			if ( Menu->Current->Prev != NULL )
			{
				Menu->Current = Menu->Current->Prev;
			}
			// ...or wrap around to the bottom of the list
			else
			{
				while ( Menu->Current->Next != NULL )
				{
					Menu->Current = Menu->Current->Next;
				}
			}
		
			while (Menu->Current->Identifier == 0xffff)
			{
				// pick item above as curently selected one...
				if ( Menu->Current->Prev != NULL )
				{
					Menu->Current = Menu->Current->Prev;
				}
				// ...or wrap around to the bottom of the list
				else
				{
					while ( Menu->Current->Next != NULL )
					{
						Menu->Current = Menu->Current->Next;
					}
				}
			}
			break;
		}

		// down arrow
		case VK_DOWN:
		{

			// pick item below as curently selected one...
			if ( Menu->Current->Next != NULL )
			{
				Menu->Current = Menu->Current->Next;
			}
			// ... or wrap around to the top of the list
			else
			{
				Menu->Current = Menu->Head;
			}
	
			while (Menu->Current->Identifier == 0xffff)
			{
				if ( Menu->Current->Next != NULL )
				{
					Menu->Current = Menu->Current->Next;
				}
				else
				{
					Menu->Current = Menu->Head;
				}
			}

			break;
		}

		// left arrow
		case VK_LEFT:
		{

			// adjust a slider...
			if ( Menu->Current->ItemType == Menu_ItemSlider )
			{

				// locals
				MenuItemSlider_T	*Data;

				// get item data
				Data = (MenuItemSlider_T *)Menu->Current->Data;
				assert( Data != NULL );

				//Data->Percent -= 0.05f;
				Data->Percent -= Data->Increment;
				if ( Data->Percent < 0.01f )
				{
					Data->Percent = 0.0f;
				}
			}
			break;
		}

		// right arrow
		case VK_RIGHT:
		{

			// adjust a slider...
			if ( Menu->Current->ItemType == Menu_ItemSlider )
			{

				// locals
				MenuItemSlider_T	*Data;

				// get item data
				Data = (MenuItemSlider_T *)Menu->Current->Data;
				assert( Data != NULL );

				//Data->Percent += 0.05f;
                Data->Percent += Data->Increment;
				if ( Data->Percent > 0.99f )
				{
					Data->Percent = 1.0f;
				}
			}
			break;
		}
	}

	// return id of currently selected item
	return Menu->Current->Identifier;

} // Menu_Key()