diff options
Diffstat (limited to 'src/ui/ui_shared.c')
| -rw-r--r-- | src/ui/ui_shared.c | 8083 |
1 files changed, 8083 insertions, 0 deletions
diff --git a/src/ui/ui_shared.c b/src/ui/ui_shared.c new file mode 100644 index 0000000..7822f93 --- /dev/null +++ b/src/ui/ui_shared.c @@ -0,0 +1,8083 @@ +/* +=========================================================================== +Copyright (C) 1999-2005 Id Software, Inc. +Copyright (C) 2000-2009 Darklegion Development + +This file is part of Tremulous. + +Tremulous is free software; you can redistribute it +and/or modify it under the terms of the GNU General Public License as +published by the Free Software Foundation; either version 2 of the License, +or (at your option) any later version. + +Tremulous is distributed in the hope that it will be +useful, but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with Tremulous; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +=========================================================================== +*/ + +#include "ui_shared.h" + +#define SCROLL_TIME_START 500 +#define SCROLL_TIME_ADJUST 150 +#define SCROLL_TIME_ADJUSTOFFSET 40 +#define SCROLL_TIME_FLOOR 20 + +typedef struct scrollInfo_s +{ + int nextScrollTime; + int nextAdjustTime; + int adjustValue; + int scrollKey; + float xStart; + float yStart; + itemDef_t *item; + qboolean scrollDir; +} +scrollInfo_t; + +static scrollInfo_t scrollInfo; + +// prevent compiler warnings +void voidFunction( void *var ) +{ + return; +} + +qboolean voidFunction2( itemDef_t *var1, int var2 ) +{ + return qfalse; +} + +static CaptureFunc *captureFunc = voidFunction; +static int captureFuncExpiry = 0; +static void *captureData = NULL; +static itemDef_t *itemCapture = NULL; // item that has the mouse captured ( if any ) + +displayContextDef_t *DC = NULL; + +static qboolean g_waitingForKey = qfalse; +static qboolean g_editingField = qfalse; + +static itemDef_t *g_bindItem = NULL; +static itemDef_t *g_editItem = NULL; +static itemDef_t *g_comboBoxItem = NULL; + +menuDef_t Menus[MAX_MENUS]; // defined menus +int menuCount = 0; // how many + +menuDef_t *menuStack[MAX_OPEN_MENUS]; +int openMenuCount = 0; + +#define DOUBLE_CLICK_DELAY 300 +static int lastListBoxClickTime = 0; + +itemDataType_t Item_DataType( itemDef_t *item ); +void Item_RunScript( itemDef_t *item, const char *s ); +void Item_SetupKeywordHash( void ); +static ID_INLINE qboolean Item_IsEditField( itemDef_t *item ); +static ID_INLINE qboolean Item_IsListBox( itemDef_t *item ); +static void Item_ListBox_SetStartPos( itemDef_t *item, int startPos ); +void Menu_SetupKeywordHash( void ); +int BindingIDFromName( const char *name ); +qboolean Item_Bind_HandleKey( itemDef_t *item, int key, qboolean down ); +itemDef_t *Menu_SetPrevCursorItem( menuDef_t *menu ); +itemDef_t *Menu_SetNextCursorItem( menuDef_t *menu ); +static qboolean Menu_OverActiveItem( menuDef_t *menu, float x, float y ); + +/* +=============== +UI_InstallCaptureFunc +=============== +*/ +void UI_InstallCaptureFunc( CaptureFunc *f, void *data, int timeout ) +{ + captureFunc = f; + captureData = data; + + if( timeout > 0 ) + captureFuncExpiry = DC->realTime + timeout; + else + captureFuncExpiry = 0; +} + +/* +=============== +UI_RemoveCaptureFunc +=============== +*/ +void UI_RemoveCaptureFunc( void ) +{ + captureFunc = voidFunction; + captureData = NULL; + captureFuncExpiry = 0; +} + +#ifdef CGAME +#define MEM_POOL_SIZE 128 * 1024 +#else +#define MEM_POOL_SIZE 1024 * 1024 +#endif + +static char UI_memoryPool[MEM_POOL_SIZE]; +static int allocPoint, outOfMemory; + +/* +=============== +UI_Alloc +=============== +*/ +void *UI_Alloc( int size ) +{ + char *p; + + if( allocPoint + size > MEM_POOL_SIZE ) + { + outOfMemory = qtrue; + + if( DC->Print ) + DC->Print( "UI_Alloc: Failure. Out of memory!\n" ); + + //DC->trap_Print(S_COLOR_YELLOW"WARNING: UI Out of Memory!\n"); + return NULL; + } + + p = &UI_memoryPool[ allocPoint ]; + + allocPoint += ( size + 15 ) & ~15; + + return p; +} + +/* +=============== +UI_InitMemory +=============== +*/ +void UI_InitMemory( void ) +{ + allocPoint = 0; + outOfMemory = qfalse; +} + +qboolean UI_OutOfMemory( ) +{ + return outOfMemory; +} + + + + + +#define HASH_TABLE_SIZE 2048 +/* +================ +return a hash value for the string +================ +*/ +static long hashForString( const char *str ) +{ + int i; + long hash; + char letter; + + hash = 0; + i = 0; + + while( str[i] != '\0' ) + { + letter = tolower( str[i] ); + hash += ( long )( letter ) * ( i + 119 ); + i++; + } + + hash &= ( HASH_TABLE_SIZE - 1 ); + return hash; +} + +typedef struct stringDef_s +{ + struct stringDef_s *next; + const char *str; +} + +stringDef_t; + +static int strPoolIndex = 0; +static char strPool[STRING_POOL_SIZE]; + +static int strHandleCount = 0; +static stringDef_t *strHandle[HASH_TABLE_SIZE]; + +// Make a copy of a string for later use. Can safely be called on the +// same string repeatedly. Redundant on string literals or global +// constants. +const char *String_Alloc( const char *p ) +{ + int len; + long hash; + stringDef_t *str, *last; + + if( p == NULL ) + return NULL; + + if( *p == 0 ) + return ""; + + hash = hashForString( p ); + + str = strHandle[hash]; + + while( str ) + { + if( strcmp( p, str->str ) == 0 ) + return str->str; + + str = str->next; + } + + len = strlen( p ); + + if( len + strPoolIndex + 1 < STRING_POOL_SIZE ) + { + int ph = strPoolIndex; + strcpy( &strPool[strPoolIndex], p ); + strPoolIndex += len + 1; + + str = strHandle[hash]; + last = str; + + while( str && str->next ) + { + last = str; + str = str->next; + } + + str = UI_Alloc( sizeof( stringDef_t ) ); + str->next = NULL; + str->str = &strPool[ph]; + + if( last ) + last->next = str; + else + strHandle[hash] = str; + + return &strPool[ph]; + } + else + { + Com_Error( ERR_DROP, "String_Alloc( %s ): string pool full!", p ); + return NULL; // not that we return at all + } +} + +void String_Report( void ) +{ + float f; + Com_Printf( "Memory/String Pool Info\n" ); + Com_Printf( "----------------\n" ); + f = strPoolIndex; + f /= STRING_POOL_SIZE; + f *= 100; + Com_Printf( "String Pool is %.1f%% full, %i bytes out of %i used.\n", f, strPoolIndex, STRING_POOL_SIZE ); + f = allocPoint; + f /= MEM_POOL_SIZE; + f *= 100; + Com_Printf( "Memory Pool is %.1f%% full, %i bytes out of %i used.\n", f, allocPoint, MEM_POOL_SIZE ); +} + +/* +================= +String_Init +================= +*/ +void String_Init( void ) +{ + int i; + + for( i = 0; i < HASH_TABLE_SIZE; i++ ) + strHandle[ i ] = 0; + + strHandleCount = 0; + + strPoolIndex = 0; + + menuCount = 0; + + openMenuCount = 0; + + UI_InitMemory( ); + + Item_SetupKeywordHash( ); + + Menu_SetupKeywordHash( ); + + if( DC && DC->getBindingBuf ) + Controls_GetConfig( ); +} + +/* +================= +PC_SourceWarning +================= +*/ +void PC_SourceWarning( int handle, char *format, ... ) +{ + int line; + char filename[128]; + va_list argptr; + static char string[4096]; + + va_start( argptr, format ); + Q_vsnprintf( string, sizeof( string ), format, argptr ); + va_end( argptr ); + + filename[0] = '\0'; + line = 0; + trap_Parse_SourceFileAndLine( handle, filename, &line ); + + Com_Printf( S_COLOR_YELLOW "WARNING: %s, line %d: %s\n", filename, line, string ); +} + +/* +================= +PC_SourceError +================= +*/ +void PC_SourceError( int handle, char *format, ... ) +{ + int line; + char filename[128]; + va_list argptr; + static char string[4096]; + + va_start( argptr, format ); + Q_vsnprintf( string, sizeof( string ), format, argptr ); + va_end( argptr ); + + filename[0] = '\0'; + line = 0; + trap_Parse_SourceFileAndLine( handle, filename, &line ); + + Com_Printf( S_COLOR_RED "ERROR: %s, line %d: %s\n", filename, line, string ); +} + +/* +================= +LerpColor +================= +*/ +void LerpColor( vec4_t a, vec4_t b, vec4_t c, float t ) +{ + int i; + + // lerp and clamp each component + + for( i = 0; i < 4; i++ ) + { + c[i] = a[i] + t * ( b[i] - a[i] ); + + if( c[i] < 0 ) + c[i] = 0; + else if( c[i] > 1.0 ) + c[i] = 1.0; + } +} + +/* +================= +Float_Parse +================= +*/ +qboolean Float_Parse( char **p, float *f ) +{ + char *token; + token = COM_ParseExt( p, qfalse ); + + if( token && token[0] != 0 ) + { + *f = atof( token ); + return qtrue; + } + else + return qfalse; +} + +#define MAX_EXPR_ELEMENTS 32 + +typedef enum +{ + EXPR_OPERATOR, + EXPR_VALUE +} +exprType_t; + +typedef struct exprToken_s +{ + exprType_t type; + union + { + char op; + float val; + } u; +} +exprToken_t; + +typedef struct exprList_s +{ + exprToken_t l[ MAX_EXPR_ELEMENTS ]; + int f, b; +} +exprList_t; + +/* +================= +OpPrec + +Return a value reflecting operator precedence +================= +*/ +static ID_INLINE int OpPrec( char op ) +{ + switch( op ) + { + case '*': + return 4; + + case '/': + return 3; + + case '+': + return 2; + + case '-': + return 1; + + case '(': + return 0; + + default: + return -1; + } +} + +/* +================= +PC_Expression_Parse +================= +*/ +static qboolean PC_Expression_Parse( int handle, float *f ) +{ + pc_token_t token; + int unmatchedParentheses = 0; + exprList_t stack, fifo; + exprToken_t value; + qboolean expectingNumber = qtrue; + +#define FULL( a ) ( a.b >= ( MAX_EXPR_ELEMENTS - 1 ) ) +#define EMPTY( a ) ( a.f > a.b ) + +#define PUSH_VAL( a, v ) \ + { \ + if( FULL( a ) ) \ + return qfalse; \ + a.b++; \ + a.l[ a.b ].type = EXPR_VALUE; \ + a.l[ a.b ].u.val = v; \ + } + +#define PUSH_OP( a, o ) \ + { \ + if( FULL( a ) ) \ + return qfalse; \ + a.b++; \ + a.l[ a.b ].type = EXPR_OPERATOR; \ + a.l[ a.b ].u.op = o; \ + } + +#define POP_STACK( a ) \ + { \ + if( EMPTY( a ) ) \ + return qfalse; \ + value = a.l[ a.b ]; \ + a.b--; \ + } + +#define PEEK_STACK_OP( a ) ( a.l[ a.b ].u.op ) +#define PEEK_STACK_VAL( a ) ( a.l[ a.b ].u.val ) + +#define POP_FIFO( a ) \ + { \ + if( EMPTY( a ) ) \ + return qfalse; \ + value = a.l[ a.f ]; \ + a.f++; \ + } + + stack.f = fifo.f = 0; + stack.b = fifo.b = -1; + + while( trap_Parse_ReadToken( handle, &token ) ) + { + if( !unmatchedParentheses && token.string[ 0 ] == ')' ) + break; + + // Special case to catch negative numbers + if( expectingNumber && token.string[ 0 ] == '-' ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + token.floatvalue = -token.floatvalue; + } + + if( token.type == TT_NUMBER ) + { + if( !expectingNumber ) + return qfalse; + + expectingNumber = !expectingNumber; + + PUSH_VAL( fifo, token.floatvalue ); + } + else + { + switch( token.string[ 0 ] ) + { + case '(': + unmatchedParentheses++; + PUSH_OP( stack, '(' ); + break; + + case ')': + unmatchedParentheses--; + + if( unmatchedParentheses < 0 ) + return qfalse; + + while( !EMPTY( stack ) && PEEK_STACK_OP( stack ) != '(' ) + { + POP_STACK( stack ); + PUSH_OP( fifo, value.u.op ); + } + + // Pop the '(' + POP_STACK( stack ); + + break; + + case '*': + case '/': + case '+': + case '-': + if( expectingNumber ) + return qfalse; + + expectingNumber = !expectingNumber; + + if( EMPTY( stack ) ) + { + PUSH_OP( stack, token.string[ 0 ] ); + } + else + { + while( !EMPTY( stack ) && OpPrec( token.string[ 0 ] ) < OpPrec( PEEK_STACK_OP( stack ) ) ) + { + POP_STACK( stack ); + PUSH_OP( fifo, value.u.op ); + } + + PUSH_OP( stack, token.string[ 0 ] ); + } + + break; + + default: + // Unknown token + return qfalse; + } + } + } + + while( !EMPTY( stack ) ) + { + POP_STACK( stack ); + PUSH_OP( fifo, value.u.op ); + } + + while( !EMPTY( fifo ) ) + { + POP_FIFO( fifo ); + + if( value.type == EXPR_VALUE ) + { + PUSH_VAL( stack, value.u.val ); + } + else if( value.type == EXPR_OPERATOR ) + { + char op = value.u.op; + float operand1, operand2, result; + + POP_STACK( stack ); + operand2 = value.u.val; + POP_STACK( stack ); + operand1 = value.u.val; + + switch( op ) + { + case '*': + result = operand1 * operand2; + break; + + case '/': + result = operand1 / operand2; + break; + + case '+': + result = operand1 + operand2; + break; + + case '-': + result = operand1 - operand2; + break; + + default: + Com_Error( ERR_FATAL, "Unknown operator '%c' in postfix string", op ); + return qfalse; + } + + PUSH_VAL( stack, result ); + } + } + + POP_STACK( stack ); + + *f = value.u.val; + + return qtrue; + +#undef FULL +#undef EMPTY +#undef PUSH_VAL +#undef PUSH_OP +#undef POP_STACK +#undef PEEK_STACK_OP +#undef PEEK_STACK_VAL +#undef POP_FIFO +} + +/* +================= +PC_Float_Parse +================= +*/ +qboolean PC_Float_Parse( int handle, float *f ) +{ + pc_token_t token; + int negative = qfalse; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( token.string[ 0 ] == '(' ) + return PC_Expression_Parse( handle, f ); + + if( token.string[0] == '-' ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + negative = qtrue; + } + + if( token.type != TT_NUMBER ) + { + PC_SourceError( handle, "expected float but found %s\n", token.string ); + return qfalse; + } + + if( negative ) + * f = -token.floatvalue; + else + *f = token.floatvalue; + + return qtrue; +} + +/* +================= +Color_Parse +================= +*/ +qboolean Color_Parse( char **p, vec4_t *c ) +{ + int i; + float f; + + for( i = 0; i < 4; i++ ) + { + if( !Float_Parse( p, &f ) ) + return qfalse; + + ( *c )[i] = f; + } + + return qtrue; +} + +/* +================= +PC_Color_Parse +================= +*/ +qboolean PC_Color_Parse( int handle, vec4_t *c ) +{ + int i; + float f; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + ( *c )[i] = f; + } + + return qtrue; +} + +/* +================= +Int_Parse +================= +*/ +qboolean Int_Parse( char **p, int *i ) +{ + char *token; + token = COM_ParseExt( p, qfalse ); + + if( token && token[0] != 0 ) + { + *i = atoi( token ); + return qtrue; + } + else + return qfalse; +} + +/* +================= +PC_Int_Parse +================= +*/ +qboolean PC_Int_Parse( int handle, int *i ) +{ + pc_token_t token; + int negative = qfalse; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( token.string[ 0 ] == '(' ) + { + float f; + + if( PC_Expression_Parse( handle, &f ) ) + { + *i = ( int )f; + return qtrue; + } + else + return qfalse; + } + + if( token.string[0] == '-' ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + negative = qtrue; + } + + if( token.type != TT_NUMBER ) + { + PC_SourceError( handle, "expected integer but found %s\n", token.string ); + return qfalse; + } + + *i = token.intvalue; + + if( negative ) + * i = - *i; + + return qtrue; +} + +/* +================= +Rect_Parse +================= +*/ +qboolean Rect_Parse( char **p, rectDef_t *r ) +{ + if( Float_Parse( p, &r->x ) ) + { + if( Float_Parse( p, &r->y ) ) + { + if( Float_Parse( p, &r->w ) ) + { + if( Float_Parse( p, &r->h ) ) + return qtrue; + } + } + } + + return qfalse; +} + +/* +================= +PC_Rect_Parse +================= +*/ +qboolean PC_Rect_Parse( int handle, rectDef_t *r ) +{ + if( PC_Float_Parse( handle, &r->x ) ) + { + if( PC_Float_Parse( handle, &r->y ) ) + { + if( PC_Float_Parse( handle, &r->w ) ) + { + if( PC_Float_Parse( handle, &r->h ) ) + return qtrue; + } + } + } + + return qfalse; +} + +/* +================= +String_Parse +================= +*/ +qboolean String_Parse( char **p, const char **out ) +{ + char *token; + + token = COM_ParseExt( p, qfalse ); + + if( token && token[0] != 0 ) + { + *( out ) = String_Alloc( token ); + return qtrue; + } + + return qfalse; +} + +/* +================= +PC_String_Parse +================= +*/ +qboolean PC_String_Parse( int handle, const char **out ) +{ + pc_token_t token; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + *( out ) = String_Alloc( token.string ); + + return qtrue; +} + +/* +================= +PC_Script_Parse +================= +*/ +qboolean PC_Script_Parse( int handle, const char **out ) +{ + char script[1024]; + pc_token_t token; + + memset( script, 0, sizeof( script ) ); + // scripts start with { and have ; separated command lists.. commands are command, arg.. + // basically we want everything between the { } as it will be interpreted at run time + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( Q_stricmp( token.string, "{" ) != 0 ) + return qfalse; + + while( 1 ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( Q_stricmp( token.string, "}" ) == 0 ) + { + *out = String_Alloc( script ); + return qtrue; + } + + if( token.string[1] != '\0' ) + Q_strcat( script, 1024, va( "\"%s\"", token.string ) ); + else + Q_strcat( script, 1024, token.string ); + + Q_strcat( script, 1024, " " ); + } + + return qfalse; +} + +// display, window, menu, item code +// + +/* +================== +Init_Display + +Initializes the display with a structure to all the drawing routines +================== +*/ +void Init_Display( displayContextDef_t *dc ) +{ + DC = dc; +} + + + +// type and style painting + +void GradientBar_Paint( rectDef_t *rect, vec4_t color ) +{ + // gradient bar takes two paints + DC->setColor( color ); + DC->drawHandlePic( rect->x, rect->y, rect->w, rect->h, DC->Assets.gradientBar ); + DC->setColor( NULL ); +} + + +/* +================== +Window_Init + +Initializes a window structure ( windowDef_t ) with defaults +================== +*/ +void Window_Init( Window *w ) +{ + memset( w, 0, sizeof( windowDef_t ) ); + w->borderSize = 1; + w->foreColor[0] = w->foreColor[1] = w->foreColor[2] = w->foreColor[3] = 1.0; + w->cinematic = -1; +} + +void Fade( int *flags, float *f, float clamp, int *nextTime, int offsetTime, qboolean bFlags, float fadeAmount ) +{ + if( *flags & ( WINDOW_FADINGOUT | WINDOW_FADINGIN ) ) + { + if( DC->realTime > *nextTime ) + { + *nextTime = DC->realTime + offsetTime; + + if( *flags & WINDOW_FADINGOUT ) + { + *f -= fadeAmount; + + if( bFlags && *f <= 0.0 ) + *flags &= ~( WINDOW_FADINGOUT | WINDOW_VISIBLE ); + } + else + { + *f += fadeAmount; + + if( *f >= clamp ) + { + *f = clamp; + + if( bFlags ) + *flags &= ~WINDOW_FADINGIN; + } + } + } + } +} + + + +static void Window_Paint( Window *w, float fadeAmount, float fadeClamp, float fadeCycle ) +{ + vec4_t color; + rectDef_t fillRect = w->rect; + + + if( DC->getCVarValue( "ui_developer" ) ) + { + color[0] = color[1] = color[2] = color[3] = 1; + DC->drawRect( w->rect.x, w->rect.y, w->rect.w, w->rect.h, 1, color ); + } + + if( w == NULL || ( w->style == 0 && w->border == 0 ) ) + return; + + if( w->border != 0 ) + { + fillRect.x += w->borderSize; + fillRect.y += w->borderSize; + fillRect.w -= w->borderSize + 1; + fillRect.h -= w->borderSize + 1; + } + + if( w->style == WINDOW_STYLE_FILLED ) + { + // box, but possible a shader that needs filled + + if( w->background ) + { + Fade( &w->flags, &w->backColor[3], fadeClamp, &w->nextTime, fadeCycle, qtrue, fadeAmount ); + DC->setColor( w->backColor ); + DC->drawHandlePic( fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background ); + DC->setColor( NULL ); + } + else + DC->fillRect( fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->backColor ); + } + else if( w->style == WINDOW_STYLE_GRADIENT ) + { + GradientBar_Paint( &fillRect, w->backColor ); + // gradient bar + } + else if( w->style == WINDOW_STYLE_SHADER ) + { + if( w->flags & WINDOW_FORECOLORSET ) + DC->setColor( w->foreColor ); + + DC->drawHandlePic( fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background ); + DC->setColor( NULL ); + } + else if( w->style == WINDOW_STYLE_CINEMATIC ) + { + if( w->cinematic == -1 ) + { + w->cinematic = DC->playCinematic( w->cinematicName, fillRect.x, fillRect.y, fillRect.w, fillRect.h ); + + if( w->cinematic == -1 ) + w->cinematic = -2; + } + + if( w->cinematic >= 0 ) + { + DC->runCinematicFrame( w->cinematic ); + DC->drawCinematic( w->cinematic, fillRect.x, fillRect.y, fillRect.w, fillRect.h ); + } + } +} + +static void Border_Paint( Window *w ) +{ + if( w == NULL || ( w->style == 0 && w->border == 0 ) ) + return; + + if( w->border == WINDOW_BORDER_FULL ) + { + // full + DC->drawRect( w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, w->borderColor ); + } + else if( w->border == WINDOW_BORDER_HORZ ) + { + // top/bottom + DC->setColor( w->borderColor ); + DC->drawTopBottom( w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize ); + DC->setColor( NULL ); + } + else if( w->border == WINDOW_BORDER_VERT ) + { + // left right + DC->setColor( w->borderColor ); + DC->drawSides( w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize ); + DC->setColor( NULL ); + } + else if( w->border == WINDOW_BORDER_KCGRADIENT ) + { + // this is just two gradient bars along each horz edge + rectDef_t r = w->rect; + r.h = w->borderSize; + GradientBar_Paint( &r, w->borderColor ); + r.y = w->rect.y + w->rect.h - 1; + GradientBar_Paint( &r, w->borderColor ); + } +} + + +void Item_SetScreenCoords( itemDef_t *item, float x, float y ) +{ + if( item == NULL ) + return; + + if( item->window.border != 0 ) + { + x += item->window.borderSize; + y += item->window.borderSize; + } + + item->window.rect.x = x + item->window.rectClient.x; + item->window.rect.y = y + item->window.rectClient.y; + item->window.rect.w = item->window.rectClient.w; + item->window.rect.h = item->window.rectClient.h; + + // force the text rects to recompute + item->textRect.w = 0; + item->textRect.h = 0; +} + +// FIXME: consolidate this with nearby stuff +void Item_UpdatePosition( itemDef_t *item ) +{ + float x, y; + menuDef_t *menu; + + if( item == NULL || item->parent == NULL ) + return; + + menu = item->parent; + + x = menu->window.rect.x; + y = menu->window.rect.y; + + if( menu->window.border != 0 ) + { + x += menu->window.borderSize; + y += menu->window.borderSize; + } + + Item_SetScreenCoords( item, x, y ); + +} + +// menus +void Menu_UpdatePosition( menuDef_t *menu ) +{ + int i; + float x, y; + + if( menu == NULL ) + return; + + x = menu->window.rect.x; + y = menu->window.rect.y; + + if( menu->window.border != 0 ) + { + x += menu->window.borderSize; + y += menu->window.borderSize; + } + + for( i = 0; i < menu->itemCount; i++ ) + Item_SetScreenCoords( menu->items[i], x, y ); +} + +static void Menu_AspectiseRect( int bias, Rectangle *rect ) +{ + switch( bias ) + { + case ALIGN_LEFT: + rect->x *= DC->aspectScale; + rect->w *= DC->aspectScale; + break; + + case ALIGN_CENTER: + rect->x = ( rect->x * DC->aspectScale ) + + ( 320.0f - ( 320.0f * DC->aspectScale ) ); + rect->w *= DC->aspectScale; + break; + + case ALIGN_RIGHT: + rect->x = 640.0f - ( ( 640.0f - rect->x ) * DC->aspectScale ); + rect->w *= DC->aspectScale; + break; + + default: + + case ASPECT_NONE: + break; + } +} + +void Menu_AspectCompensate( menuDef_t *menu ) +{ + int i; + + if( menu->window.aspectBias != ASPECT_NONE ) + { + Menu_AspectiseRect( menu->window.aspectBias, &menu->window.rect ); + + for( i = 0; i < menu->itemCount; i++ ) + { + menu->items[ i ]->window.rectClient.x *= DC->aspectScale; + menu->items[ i ]->window.rectClient.w *= DC->aspectScale; + menu->items[ i ]->textalignx *= DC->aspectScale; + } + } + else + { + for( i = 0; i < menu->itemCount; i++ ) + { + Menu_AspectiseRect( menu->items[ i ]->window.aspectBias, + &menu->items[ i ]->window.rectClient ); + + if( menu->items[ i ]->window.aspectBias != ASPECT_NONE ) + menu->items[ i ]->textalignx *= DC->aspectScale; + } + } +} + +void Menu_PostParse( menuDef_t *menu ) +{ + int i, j; + + if( menu == NULL ) + return; + + if( menu->fullScreen ) + { + menu->window.rect.x = 0; + menu->window.rect.y = 0; + menu->window.rect.w = 640; + menu->window.rect.h = 480; + } + + Menu_AspectCompensate( menu ); + Menu_UpdatePosition( menu ); + + // Push lists to the end of the array as they can potentially be drawn on top + // of other elements + for( i = 0; i < menu->itemCount; i++ ) + { + itemDef_t *item = menu->items[ i ]; + + if( Item_IsListBox( item ) ) + { + for( j = i; j < menu->itemCount - 1; j++ ) + menu->items[ j ] = menu->items[ j + 1 ]; + + menu->items[ j ] = item; + } + } +} + +itemDef_t *Menu_ClearFocus( menuDef_t *menu ) +{ + int i; + itemDef_t *ret = NULL; + + if( menu == NULL ) + return NULL; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( menu->items[i]->window.flags & WINDOW_HASFOCUS ) + ret = menu->items[i]; + + menu->items[i]->window.flags &= ~WINDOW_HASFOCUS; + + if( menu->items[i]->leaveFocus ) + Item_RunScript( menu->items[i], menu->items[i]->leaveFocus ); + } + + return ret; +} + +qboolean IsVisible( int flags ) +{ + return ( flags & WINDOW_VISIBLE && !( flags & WINDOW_FADINGOUT ) ); +} + +qboolean Rect_ContainsPoint( rectDef_t *rect, float x, float y ) +{ + if( rect ) + { + if( x > rect->x && x < rect->x + rect->w && y > rect->y && y < rect->y + rect->h ) + return qtrue; + } + + return qfalse; +} + +int Menu_ItemsMatchingGroup( menuDef_t *menu, const char *name ) +{ + int i; + int count = 0; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( Q_stricmp( menu->items[i]->window.name, name ) == 0 || + ( menu->items[i]->window.group && Q_stricmp( menu->items[i]->window.group, name ) == 0 ) ) + { + count++; + } + } + + return count; +} + +itemDef_t *Menu_GetMatchingItemByNumber( menuDef_t *menu, int index, const char *name ) +{ + int i; + int count = 0; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( Q_stricmp( menu->items[i]->window.name, name ) == 0 || + ( menu->items[i]->window.group && Q_stricmp( menu->items[i]->window.group, name ) == 0 ) ) + { + if( count == index ) + return menu->items[i]; + + count++; + } + } + + return NULL; +} + + + +void Script_SetColor( itemDef_t *item, char **args ) +{ + const char *name; + int i; + float f; + vec4_t *out; + // expecting type of color to set and 4 args for the color + + if( String_Parse( args, &name ) ) + { + out = NULL; + + if( Q_stricmp( name, "backcolor" ) == 0 ) + { + out = &item->window.backColor; + item->window.flags |= WINDOW_BACKCOLORSET; + } + else if( Q_stricmp( name, "forecolor" ) == 0 ) + { + out = &item->window.foreColor; + item->window.flags |= WINDOW_FORECOLORSET; + } + else if( Q_stricmp( name, "bordercolor" ) == 0 ) + out = &item->window.borderColor; + + if( out ) + { + for( i = 0; i < 4; i++ ) + { + if( !Float_Parse( args, &f ) ) + return; + + ( *out )[i] = f; + } + } + } +} + +void Script_SetAsset( itemDef_t *item, char **args ) +{ + const char *name; + // expecting name to set asset to + + if( String_Parse( args, &name ) ) + { + // check for a model + + if( item->type == ITEM_TYPE_MODEL ) + {} + + } + +} + +void Script_SetBackground( itemDef_t *item, char **args ) +{ + const char *name; + // expecting name to set asset to + + if( String_Parse( args, &name ) ) + item->window.background = DC->registerShaderNoMip( name ); +} + + + + +itemDef_t *Menu_FindItemByName( menuDef_t *menu, const char *p ) +{ + int i; + + if( menu == NULL || p == NULL ) + return NULL; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( Q_stricmp( p, menu->items[i]->window.name ) == 0 ) + return menu->items[i]; + } + + return NULL; +} + +void Script_SetItemColor( itemDef_t *item, char **args ) +{ + const char *itemname; + const char *name; + vec4_t color; + int i; + vec4_t *out; + // expecting type of color to set and 4 args for the color + + if( String_Parse( args, &itemname ) && String_Parse( args, &name ) ) + { + itemDef_t * item2; + int j; + int count = Menu_ItemsMatchingGroup( item->parent, itemname ); + + if( !Color_Parse( args, &color ) ) + return; + + for( j = 0; j < count; j++ ) + { + item2 = Menu_GetMatchingItemByNumber( item->parent, j, itemname ); + + if( item2 != NULL ) + { + out = NULL; + + if( Q_stricmp( name, "backcolor" ) == 0 ) + out = &item2->window.backColor; + else if( Q_stricmp( name, "forecolor" ) == 0 ) + { + out = &item2->window.foreColor; + item2->window.flags |= WINDOW_FORECOLORSET; + } + else if( Q_stricmp( name, "bordercolor" ) == 0 ) + out = &item2->window.borderColor; + + if( out ) + { + for( i = 0; i < 4; i++ ) + ( *out )[i] = color[i]; + } + } + } + } +} + + +void Menu_ShowItemByName( menuDef_t *menu, const char *p, qboolean bShow ) +{ + itemDef_t * item; + int i; + int count = Menu_ItemsMatchingGroup( menu, p ); + + for( i = 0; i < count; i++ ) + { + item = Menu_GetMatchingItemByNumber( menu, i, p ); + + if( item != NULL ) + { + if( bShow ) + item->window.flags |= WINDOW_VISIBLE; + else + { + item->window.flags &= ~WINDOW_VISIBLE; + // stop cinematics playing in the window + + if( item->window.cinematic >= 0 ) + { + DC->stopCinematic( item->window.cinematic ); + item->window.cinematic = -1; + } + } + } + } +} + +void Menu_FadeItemByName( menuDef_t *menu, const char *p, qboolean fadeOut ) +{ + itemDef_t * item; + int i; + int count = Menu_ItemsMatchingGroup( menu, p ); + + for( i = 0; i < count; i++ ) + { + item = Menu_GetMatchingItemByNumber( menu, i, p ); + + if( item != NULL ) + { + if( fadeOut ) + { + item->window.flags |= ( WINDOW_FADINGOUT | WINDOW_VISIBLE ); + item->window.flags &= ~WINDOW_FADINGIN; + } + else + { + item->window.flags |= ( WINDOW_VISIBLE | WINDOW_FADINGIN ); + item->window.flags &= ~WINDOW_FADINGOUT; + } + } + } +} + +menuDef_t *Menus_FindByName( const char *p ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + { + if( Q_stricmp( Menus[i].window.name, p ) == 0 ) + return & Menus[i]; + } + + return NULL; +} + +static void Menu_RunCloseScript( menuDef_t *menu ) +{ + if( menu && menu->window.flags & WINDOW_VISIBLE && menu->onClose ) + { + itemDef_t item; + item.parent = menu; + Item_RunScript( &item, menu->onClose ); + } +} + +static void Menus_Close( menuDef_t *menu ) +{ + if( menu != NULL ) + { + Menu_RunCloseScript( menu ); + menu->window.flags &= ~( WINDOW_VISIBLE | WINDOW_HASFOCUS ); + + if( openMenuCount > 0 ) + openMenuCount--; + + if( openMenuCount > 0 ) + Menus_Activate( menuStack[ openMenuCount - 1 ] ); + } +} + +void Menus_CloseByName( const char *p ) +{ + Menus_Close( Menus_FindByName( p ) ); +} + +void Menus_CloseAll( void ) +{ + int i; + + // Close any menus on the stack first + if( openMenuCount > 0 ) + { + for( i = openMenuCount; i > 0; i-- ) + Menus_Close( menuStack[ i ] ); + + openMenuCount = 0; + } + + // Close all other menus + for( i = 0; i < menuCount; i++ ) + Menus_Close( &Menus[ i ] ); + + g_editingField = qfalse; + g_waitingForKey = qfalse; + g_comboBoxItem = NULL; +} + + +void Script_Show( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menu_ShowItemByName( item->parent, name, qtrue ); +} + +void Script_Hide( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menu_ShowItemByName( item->parent, name, qfalse ); +} + +void Script_FadeIn( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menu_FadeItemByName( item->parent, name, qfalse ); +} + +void Script_FadeOut( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menu_FadeItemByName( item->parent, name, qtrue ); +} + + + +void Script_Open( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menus_ActivateByName( name ); +} + +void Script_ConditionalOpen( itemDef_t *item, char **args ) +{ + const char *cvar; + const char *name1; + const char *name2; + float val; + + if( String_Parse( args, &cvar ) && String_Parse( args, &name1 ) && String_Parse( args, &name2 ) ) + { + val = DC->getCVarValue( cvar ); + + if( val == 0.0f ) + Menus_ActivateByName( name2 ); + else + Menus_ActivateByName( name1 ); + } +} + +void Script_Close( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + Menus_CloseByName( name ); +} + +void Menu_TransitionItemByName( menuDef_t *menu, const char *p, rectDef_t rectFrom, rectDef_t rectTo, + int time, float amt ) +{ + itemDef_t *item; + int i; + int count = Menu_ItemsMatchingGroup( menu, p ); + + for( i = 0; i < count; i++ ) + { + item = Menu_GetMatchingItemByNumber( menu, i, p ); + + if( item != NULL ) + { + item->window.flags |= ( WINDOW_INTRANSITION | WINDOW_VISIBLE ); + item->window.offsetTime = time; + memcpy( &item->window.rectClient, &rectFrom, sizeof( rectDef_t ) ); + memcpy( &item->window.rectEffects, &rectTo, sizeof( rectDef_t ) ); + item->window.rectEffects2.x = abs( rectTo.x - rectFrom.x ) / amt; + item->window.rectEffects2.y = abs( rectTo.y - rectFrom.y ) / amt; + item->window.rectEffects2.w = abs( rectTo.w - rectFrom.w ) / amt; + item->window.rectEffects2.h = abs( rectTo.h - rectFrom.h ) / amt; + Item_UpdatePosition( item ); + } + } +} + + +void Script_Transition( itemDef_t *item, char **args ) +{ + const char *name; + rectDef_t rectFrom, rectTo; + int time; + float amt; + + if( String_Parse( args, &name ) ) + { + if( Rect_Parse( args, &rectFrom ) && Rect_Parse( args, &rectTo ) && + Int_Parse( args, &time ) && Float_Parse( args, &amt ) ) + { + Menu_TransitionItemByName( item->parent, name, rectFrom, rectTo, time, amt ); + } + } +} + + +void Menu_OrbitItemByName( menuDef_t *menu, const char *p, float x, float y, float cx, float cy, int time ) +{ + itemDef_t *item; + int i; + int count = Menu_ItemsMatchingGroup( menu, p ); + + for( i = 0; i < count; i++ ) + { + item = Menu_GetMatchingItemByNumber( menu, i, p ); + + if( item != NULL ) + { + item->window.flags |= ( WINDOW_ORBITING | WINDOW_VISIBLE ); + item->window.offsetTime = time; + item->window.rectEffects.x = cx; + item->window.rectEffects.y = cy; + item->window.rectClient.x = x; + item->window.rectClient.y = y; + Item_UpdatePosition( item ); + } + } +} + + +void Script_Orbit( itemDef_t *item, char **args ) +{ + const char *name; + float cx, cy, x, y; + int time; + + if( String_Parse( args, &name ) ) + { + if( Float_Parse( args, &x ) && Float_Parse( args, &y ) && + Float_Parse( args, &cx ) && Float_Parse( args, &cy ) && Int_Parse( args, &time ) ) + { + Menu_OrbitItemByName( item->parent, name, x, y, cx, cy, time ); + } + } +} + + + +void Script_SetFocus( itemDef_t *item, char **args ) +{ + const char *name; + itemDef_t *focusItem; + + if( String_Parse( args, &name ) ) + { + focusItem = Menu_FindItemByName( item->parent, name ); + + if( focusItem && !( focusItem->window.flags & WINDOW_DECORATION ) ) + { + Menu_ClearFocus( item->parent ); + focusItem->window.flags |= WINDOW_HASFOCUS; + + if( focusItem->onFocus ) + Item_RunScript( focusItem, focusItem->onFocus ); + + // Edit fields get activated too + if( Item_IsEditField( focusItem ) ) + { + g_editingField = qtrue; + g_editItem = focusItem; + } + + if( DC->Assets.itemFocusSound ) + DC->startLocalSound( DC->Assets.itemFocusSound, CHAN_LOCAL_SOUND ); + } + } +} + +void Script_Reset( itemDef_t *item, char **args ) +{ + const char *name; + itemDef_t *resetItem; + + if( String_Parse( args, &name ) ) + { + resetItem = Menu_FindItemByName( item->parent, name ); + + if( resetItem ) + { + if( Item_IsListBox( resetItem ) ) + { + resetItem->cursorPos = DC->feederInitialise( resetItem->feederID ); + Item_ListBox_SetStartPos( resetItem, 0 ); + DC->feederSelection( resetItem->feederID, resetItem->cursorPos ); + } + } + } +} + +void Script_SetPlayerModel( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + DC->setCVar( "team_model", name ); +} + +void Script_SetPlayerHead( itemDef_t *item, char **args ) +{ + const char *name; + + if( String_Parse( args, &name ) ) + DC->setCVar( "team_headmodel", name ); +} + +void Script_SetCvar( itemDef_t *item, char **args ) +{ + const char *cvar, *val; + + if( String_Parse( args, &cvar ) && String_Parse( args, &val ) ) + DC->setCVar( cvar, val ); + +} + +void Script_Exec( itemDef_t *item, char **args ) +{ + const char *val; + + if( String_Parse( args, &val ) ) + DC->executeText( EXEC_APPEND, va( "%s ; ", val ) ); +} + +void Script_Play( itemDef_t *item, char **args ) +{ + const char *val; + + if( String_Parse( args, &val ) ) + DC->startLocalSound( DC->registerSound( val, qfalse ), CHAN_LOCAL_SOUND ); +} + +void Script_playLooped( itemDef_t *item, char **args ) +{ + const char *val; + + if( String_Parse( args, &val ) ) + { + DC->stopBackgroundTrack(); + DC->startBackgroundTrack( val, val ); + } +} + +static ID_INLINE float UI_EmoticonHeight( fontInfo_t *font, float scale ) +{ + return font->glyphs[ (int)'[' ].height * scale * font->glyphScale; +} + +static ID_INLINE float UI_EmoticonWidth( fontInfo_t *font, float scale ) +{ + return UI_EmoticonHeight( font, scale ) * DC->aspectScale; +} + +void UI_EscapeEmoticons( char *dest, const char *src, int destsize ) +{ + int len; + qboolean escaped; + + for( ; *src && destsize > 1; src++, destsize-- ) + { + if( UI_Text_IsEmoticon( src, &escaped, &len, NULL, NULL ) && !escaped ) + { + *dest++ = '['; + destsize--; + } + + *dest++ = *src; + } + + *dest++ = '\0'; +} + +qboolean UI_Text_IsEmoticon( const char *s, qboolean *escaped, + int *length, qhandle_t *h, int *width ) +{ + const char *p = s; + char emoticon[ MAX_EMOTICON_NAME_LEN ]; + int i; + + if( *p != '[' ) + return qfalse; + p++; + + if( *p == '[' ) + { + *escaped = qtrue; + p++; + } + else + *escaped = qfalse; + + for( *length = 0; p[ *length ] != ']'; ( *length )++ ) + { + if( !p[ *length ] || *length == MAX_EMOTICON_NAME_LEN - 1 ) + return qfalse; + + emoticon[ *length ] = p[ *length ]; + } + emoticon[ *length ] = '\0'; + + for( i = 0; i < DC->Assets.emoticonCount; i++ ) + if( !Q_stricmp( DC->Assets.emoticons[ i ].name, emoticon ) ) + break; + + if( i == DC->Assets.emoticonCount ) + return qfalse; + + if( h ) + *h = DC->Assets.emoticons[ i ].shader; + if( width ) + *width = DC->Assets.emoticons[ i ].width; + + ( *length ) += 2; + + if( *escaped ) + ( *length )++; + + return qtrue; +} + +static float UI_Parse_Indent( const char **text ) +{ + char indentWidth[ 32 ]; + char *indentWidthPtr; + const char *p = *text; + int numDigits; + float pixels; + + while( isdigit( *p ) || *p == '.' ) + p++; + + if( *p != INDENT_MARKER ) + return 0.0f; + + numDigits = ( p - *text ); + + if( numDigits > sizeof( indentWidth ) - 1 ) + return 0.0f; + + strncpy( indentWidth, *text, numDigits ); + + indentWidth[ numDigits ] = '\0'; + indentWidthPtr = indentWidth; + + if( !Float_Parse( &indentWidthPtr, &pixels ) ) + return 0.0f; + + (*text) += ( numDigits + 1 ); + + return pixels; +} + +static ID_INLINE fontInfo_t *UI_FontForScale( float scale ) +{ + if( scale <= DC->smallFontScale ) + return &DC->Assets.smallFont; + else if( scale >= DC->bigFontScale ) + return &DC->Assets.bigFont; + else + return &DC->Assets.textFont; +} + +float UI_Char_Width( const char **text, float scale ) +{ + glyphInfo_t *glyph; + fontInfo_t *font; + int emoticonLen; + qboolean emoticonEscaped; + int emoticonWidth; + + if( text && *text ) + { + if( Q_IsColorString( *text ) ) + { + *text += 2; + return 0.0f; + } + + if( **text == INDENT_MARKER ) + { + (*text)++; + return 0.0f; + } + + font = UI_FontForScale( scale ); + + if( UI_Text_IsEmoticon( *text, &emoticonEscaped, &emoticonLen, + NULL, &emoticonWidth ) ) + { + if( emoticonEscaped ) + (*text)++; + else + { + *text += emoticonLen; + return emoticonWidth * UI_EmoticonWidth( font, scale ); + } + } + + (*text)++; + + glyph = &font->glyphs[ (int)**text ]; + return glyph->xSkip * DC->aspectScale * scale * font->glyphScale; + } + + return 0.0f; +} + +float UI_Text_Width( const char *text, float scale ) +{ + float out; + const char *s = text; + float indentWidth = 0.0f; + + out = 0.0f; + + if( text ) + { + indentWidth = UI_Parse_Indent( &s ); + + while( *s ) + out += UI_Char_Width( &s, scale ); + } + + return out + indentWidth; +} + +float UI_Text_Height( const char *text, float scale ) +{ + float max; + glyphInfo_t *glyph; + float useScale; + const char *s = text; + fontInfo_t *font = UI_FontForScale( scale ); + + useScale = scale * font->glyphScale; + max = 0; + + if( text ) + { + while( s && *s ) + { + if( Q_IsColorString( s ) ) + { + s += 2; + continue; + } + else + { + glyph = &font->glyphs[( int )*s]; + + if( max < glyph->height ) + max = glyph->height; + + s++; + } + } + } + + return max * useScale; +} + +float UI_Text_EmWidth( float scale ) +{ + return UI_Text_Width( "M", scale ); +} + +float UI_Text_EmHeight( float scale ) +{ + return UI_Text_Height( "M", scale ); +} + + +/* +================ +UI_AdjustFrom640 + +Adjusted for resolution and screen aspect ratio +================ +*/ +void UI_AdjustFrom640( float *x, float *y, float *w, float *h ) +{ + *x *= DC->xscale; + *y *= DC->yscale; + *w *= DC->xscale; + *h *= DC->yscale; +} + +/* +================ +UI_SetClipRegion +================= +*/ +void UI_SetClipRegion( float x, float y, float w, float h ) +{ + vec4_t clip; + + UI_AdjustFrom640( &x, &y, &w, &h ); + + clip[ 0 ] = x; + clip[ 1 ] = y; + clip[ 2 ] = x + w; + clip[ 3 ] = y + h; + + trap_R_SetClipRegion( clip ); +} + +/* +================ +UI_ClearClipRegion +================= +*/ +void UI_ClearClipRegion( void ) +{ + trap_R_SetClipRegion( NULL ); +} + +static void UI_Text_PaintChar( float x, float y, float scale, + glyphInfo_t *glyph, float size ) +{ + float w, h; + + w = glyph->imageWidth; + h = glyph->imageHeight; + + if( size > 0.0f ) + { + float half = size * 0.5f * scale; + x -= half; + y -= half; + w += size; + h += size; + } + + w *= ( DC->aspectScale * scale ); + h *= scale; + y -= ( glyph->top * scale ); + UI_AdjustFrom640( &x, &y, &w, &h ); + + DC->drawStretchPic( x, y, w, h, + glyph->s, + glyph->t, + glyph->s2, + glyph->t2, + glyph->glyph ); +} + +static void UI_Text_Paint_Generic( float x, float y, float scale, float gapAdjust, + const char *text, vec4_t color, int style, + int limit, float *maxX, + int cursorPos, char cursor ) +{ + const char *s = text; + int len; + int count = 0; + vec4_t newColor; + fontInfo_t *font = UI_FontForScale( scale ); + glyphInfo_t *glyph; + float useScale; + qhandle_t emoticonHandle = 0; + float emoticonH, emoticonW; + qboolean emoticonEscaped; + int emoticonLen = 0; + int emoticonWidth; + int cursorX = -1; + + if( !text ) + return; + + useScale = scale * font->glyphScale; + + emoticonH = UI_EmoticonHeight( font, scale ); + emoticonW = UI_EmoticonWidth( font, scale ); + + len = strlen( text ); + if( limit > 0 && len > limit ) + len = limit; + + DC->setColor( color ); + memcpy( &newColor[0], &color[0], sizeof( vec4_t ) ); + + x += UI_Parse_Indent( &s ); + + while( s && *s && count < len ) + { + const char *t = s; + float charWidth = UI_Char_Width( &t, scale ); + glyph = &font->glyphs[ (int)*s ]; + + if( maxX && charWidth + x > *maxX ) + { + *maxX = 0; + break; + } + + if( cursorPos < 0 ) + { + if( Q_IsColorString( s ) ) + { + memcpy( newColor, g_color_table[ColorIndex( *( s+1 ) )], + sizeof( newColor ) ); + newColor[3] = color[3]; + DC->setColor( newColor ); + s += 2; + continue; + } + + if( *s == INDENT_MARKER ) + { + s++; + continue; + } + + if( UI_Text_IsEmoticon( s, &emoticonEscaped, &emoticonLen, + &emoticonHandle, &emoticonWidth ) ) + { + if( emoticonEscaped ) + s++; + else + { + float yadj = useScale * glyph->top; + + DC->setColor( NULL ); + DC->drawHandlePic( x, y - yadj, + ( emoticonW * emoticonWidth ), + emoticonH, + emoticonHandle ); + DC->setColor( newColor ); + x += ( emoticonW * emoticonWidth ) + gapAdjust; + s += emoticonLen; + count += emoticonWidth; + continue; + } + } + } + + if( style == ITEM_TEXTSTYLE_SHADOWED || + style == ITEM_TEXTSTYLE_SHADOWEDMORE ) + { + int ofs; + + if( style == ITEM_TEXTSTYLE_SHADOWED ) + ofs = 1; + else + ofs = 2; + colorBlack[3] = newColor[3]; + DC->setColor( colorBlack ); + UI_Text_PaintChar( x + ofs, y + ofs, useScale, glyph, 0.0f ); + DC->setColor( newColor ); + colorBlack[3] = 1.0f; + } + else if( style == ITEM_TEXTSTYLE_NEON ) + { + vec4_t glow; + + memcpy( &glow[0], &newColor[0], sizeof( vec4_t ) ); + glow[ 3 ] *= 0.2f; + + DC->setColor( glow ); + UI_Text_PaintChar( x, y, useScale, glyph, 6.0f ); + UI_Text_PaintChar( x, y, useScale, glyph, 4.0f ); + DC->setColor( newColor ); + UI_Text_PaintChar( x, y, useScale, glyph, 2.0f ); + + DC->setColor( colorWhite ); + } + + UI_Text_PaintChar( x, y, useScale, glyph, 0.0f ); + + if( count == cursorPos ) + cursorX = x; + + x += ( glyph->xSkip * DC->aspectScale * useScale ) + gapAdjust; + s++; + count++; + + } + + if( maxX ) + *maxX = x; + + // paint cursor + if( cursorPos >= 0 ) + { + if( cursorPos == len ) + cursorX = x; + + if( cursorX >= 0 && !( ( DC->realTime / BLINK_DIVISOR ) & 1 ) ) + { + glyph = &font->glyphs[ (int)cursor ]; + UI_Text_PaintChar( cursorX, y, useScale, glyph, 0.0f ); + } + } + + DC->setColor( NULL ); +} + +void UI_Text_Paint_Limit( float *maxX, float x, float y, float scale, + vec4_t color, const char *text, float adjust, int limit ) +{ + UI_Text_Paint_Generic( x, y, scale, adjust, + text, color, ITEM_TEXTSTYLE_NORMAL, + limit, maxX, -1, 0 ); +} + +void UI_Text_Paint( float x, float y, float scale, vec4_t color, const char *text, + float adjust, int limit, int style ) +{ + UI_Text_Paint_Generic( x, y, scale, adjust, + text, color, style, + limit, NULL, -1, 0 ); +} + +void UI_Text_PaintWithCursor( float x, float y, float scale, vec4_t color, const char *text, + int cursorPos, char cursor, int limit, int style ) +{ + UI_Text_Paint_Generic( x, y, scale, 0.0, + text, color, style, + limit, NULL, cursorPos, cursor ); +} + +commandDef_t commandList[] = + { + {"close", &Script_Close}, // menu + {"conditionalopen", &Script_ConditionalOpen}, // menu + {"exec", &Script_Exec}, // group/name + {"fadein", &Script_FadeIn}, // group/name + {"fadeout", &Script_FadeOut}, // group/name + {"hide", &Script_Hide}, // group/name + {"open", &Script_Open}, // menu + {"orbit", &Script_Orbit}, // group/name + {"play", &Script_Play}, // group/name + {"playlooped", &Script_playLooped}, // group/name + {"reset", &Script_Reset}, // resets the state of the item argument + {"setasset", &Script_SetAsset}, // works on this + {"setbackground", &Script_SetBackground}, // works on this + {"setcolor", &Script_SetColor}, // works on this + {"setcvar", &Script_SetCvar}, // group/name + {"setfocus", &Script_SetFocus}, // sets this background color to team color + {"setitemcolor", &Script_SetItemColor}, // group/name + {"setplayerhead", &Script_SetPlayerHead}, // sets this background color to team color + {"setplayermodel", &Script_SetPlayerModel}, // sets this background color to team color + {"show", &Script_Show}, // group/name + {"transition", &Script_Transition}, // group/name + }; + +static size_t scriptCommandCount = sizeof( commandList ) / sizeof( commandDef_t ); + +// despite what lcc thinks, we do not get cmdcmp here +static int commandComp( const void *a, const void *b ) +{ + return Q_stricmp( (const char *)a, ((commandDef_t *)b)->name ); +} + +void Item_RunScript( itemDef_t *item, const char *s ) +{ + char script[1024], *p; + commandDef_t *cmd; + memset( script, 0, sizeof( script ) ); + + if( item && s && s[0] ) + { + Q_strcat( script, 1024, s ); + p = script; + + while( 1 ) + { + const char *command; + // expect command then arguments, ; ends command, NULL ends script + + if( !String_Parse( &p, &command ) ) + return; + + if( command[0] == ';' && command[1] == '\0' ) + continue; + + cmd = bsearch( command, commandList, scriptCommandCount, + sizeof( commandDef_t ), commandComp ); + if( cmd ) + cmd->handler( item, &p ); + else + // not in our auto list, pass to handler + DC->runScript( &p ); + } + } +} + + +qboolean Item_EnableShowViaCvar( itemDef_t *item, int flag ) +{ + char script[1024], *p; + memset( script, 0, sizeof( script ) ); + + if( item && item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest ) + { + char buff[1024]; + DC->getCVarString( item->cvarTest, buff, sizeof( buff ) ); + + Q_strcat( script, 1024, item->enableCvar ); + p = script; + + while( 1 ) + { + const char *val; + // expect value then ; or NULL, NULL ends list + + if( !String_Parse( &p, &val ) ) + return ( item->cvarFlags & flag ) ? qfalse : qtrue; + + if( val[0] == ';' && val[1] == '\0' ) + continue; + + // enable it if any of the values are true + if( item->cvarFlags & flag ) + { + if( Q_stricmp( buff, val ) == 0 ) + return qtrue; + } + else + { + // disable it if any of the values are true + + if( Q_stricmp( buff, val ) == 0 ) + return qfalse; + } + + } + + return ( item->cvarFlags & flag ) ? qfalse : qtrue; + } + + return qtrue; +} + + +// will optionaly set focus to this item +qboolean Item_SetFocus( itemDef_t *item, float x, float y ) +{ + int i; + itemDef_t *oldFocus; + sfxHandle_t *sfx = &DC->Assets.itemFocusSound; + qboolean playSound = qfalse; + menuDef_t *parent; + // sanity check, non-null, not a decoration and does not already have the focus + + if( item == NULL || item->window.flags & WINDOW_DECORATION || + item->window.flags & WINDOW_HASFOCUS || !( item->window.flags & WINDOW_VISIBLE ) ) + { + return qfalse; + } + + parent = ( menuDef_t* )item->parent; + + // items can be enabled and disabled based on cvars + + if( item->cvarFlags & ( CVAR_ENABLE | CVAR_DISABLE ) && !Item_EnableShowViaCvar( item, CVAR_ENABLE ) ) + return qfalse; + + if( item->cvarFlags & ( CVAR_SHOW | CVAR_HIDE ) && !Item_EnableShowViaCvar( item, CVAR_SHOW ) ) + return qfalse; + + oldFocus = Menu_ClearFocus( item->parent ); + + if( item->type == ITEM_TYPE_TEXT ) + { + rectDef_t r; + r = item->textRect; + r.y -= r.h; + + if( Rect_ContainsPoint( &r, x, y ) ) + { + item->window.flags |= WINDOW_HASFOCUS; + + if( item->focusSound ) + sfx = &item->focusSound; + + playSound = qtrue; + } + else + { + if( oldFocus ) + { + oldFocus->window.flags |= WINDOW_HASFOCUS; + + if( oldFocus->onFocus ) + Item_RunScript( oldFocus, oldFocus->onFocus ); + } + } + } + else + { + item->window.flags |= WINDOW_HASFOCUS; + + if( item->onFocus ) + Item_RunScript( item, item->onFocus ); + + if( item->focusSound ) + sfx = &item->focusSound; + + playSound = qtrue; + } + + if( playSound && sfx ) + DC->startLocalSound( *sfx, CHAN_LOCAL_SOUND ); + + for( i = 0; i < parent->itemCount; i++ ) + { + if( parent->items[i] == item ) + { + parent->cursorItem = i; + break; + } + } + + return qtrue; +} + +static float Item_ListBox_HeightForNumItems( itemDef_t *item, int numItems ) +{ + listBoxDef_t *listPtr = item->typeData.list; + + return ( listPtr->elementHeight * numItems ) + 2.0f; +} + +static int Item_ListBox_NumItemsForItemHeight( itemDef_t *item ) +{ + listBoxDef_t *listPtr = item->typeData.list; + + if( item->type == ITEM_TYPE_COMBOBOX ) + return listPtr->dropItems; + else + return ( ( item->window.rect.h - 2.0f ) / listPtr->elementHeight ); +} + +int Item_ListBox_MaxScroll( itemDef_t *item ) +{ + int total = DC->feederCount( item->feederID ); + int max = total - Item_ListBox_NumItemsForItemHeight( item ); + + if( max < 0 ) + return 0; + + return max; +} + +static float oldComboBoxY; +static float oldComboBoxH; + +static qboolean Item_ComboBox_MaybeCastToListBox( itemDef_t *item ) +{ + listBoxDef_t *listPtr = item->typeData.list; + qboolean cast = g_comboBoxItem != NULL && + ( item->type == ITEM_TYPE_COMBOBOX ); + + if( cast ) + { + oldComboBoxY = item->window.rect.y; + oldComboBoxH = item->window.rect.h; + + item->window.rect.y += item->window.rect.h; + item->window.rect.h = Item_ListBox_HeightForNumItems( item, listPtr->dropItems ); + item->type = ITEM_TYPE_LISTBOX; + } + + return cast; +} + +static void Item_ComboBox_MaybeUnCastFromListBox( itemDef_t *item, qboolean unCast ) +{ + if( unCast ) + { + item->window.rect.y = oldComboBoxY; + item->window.rect.h = oldComboBoxH; + item->type = ITEM_TYPE_COMBOBOX; + } +} + +static void Item_ListBox_SetStartPos( itemDef_t *item, int startPos ) +{ + listBoxDef_t *listPtr = item->typeData.list; + int total = DC->feederCount( item->feederID ); + int max = Item_ListBox_MaxScroll( item ); + + if( startPos < 0 ) + listPtr->startPos = 0; + else if( startPos > max ) + listPtr->startPos = max; + else + listPtr->startPos = startPos; + + listPtr->endPos = listPtr->startPos + MIN( ( total - listPtr->startPos ), + Item_ListBox_NumItemsForItemHeight( item ) ); +} + +float Item_ListBox_ThumbPosition( itemDef_t *item ) +{ + float max, pos, size; + float startPos = (float)item->typeData.list->startPos; + + max = Item_ListBox_MaxScroll( item ); + size = SCROLLBAR_SLIDER_HEIGHT( item ); + + if( max > 0.0f ) + pos = ( size - SCROLLBAR_ARROW_HEIGHT ) / max; + else + pos = 0.0f; + + pos *= startPos; + + return SCROLLBAR_SLIDER_Y( item ) + pos; +} + +float Item_ListBox_ThumbDrawPosition( itemDef_t *item ) +{ + if( itemCapture == item ) + { + float min = SCROLLBAR_SLIDER_Y( item ); + float max = min + SCROLLBAR_SLIDER_HEIGHT( item ) - SCROLLBAR_ARROW_HEIGHT; + float halfThumbSize = SCROLLBAR_ARROW_HEIGHT / 2.0f; + + if( DC->cursory >= min + halfThumbSize && DC->cursory <= max + halfThumbSize ) + return DC->cursory - halfThumbSize; + } + + return Item_ListBox_ThumbPosition( item ); +} + +float Item_Slider_ThumbPosition( itemDef_t *item ) +{ + float value, range, x; + editFieldDef_t *editDef = item->typeData.edit; + + if( item->text ) + x = item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET; + else + x = item->window.rect.x; + + if( editDef == NULL && item->cvar ) + return x; + + value = DC->getCVarValue( item->cvar ); + + if( value < editDef->minVal ) + value = editDef->minVal; + else if( value > editDef->maxVal ) + value = editDef->maxVal; + + range = editDef->maxVal - editDef->minVal; + value -= editDef->minVal; + value /= range; + value *= SLIDER_WIDTH; + x += value; + + return x; +} + +static float Item_Slider_VScale( itemDef_t *item ) +{ + if( SLIDER_THUMB_HEIGHT > item->window.rect.h ) + return item->window.rect.h / SLIDER_THUMB_HEIGHT; + else + return 1.0f; +} + +int Item_Slider_OverSlider( itemDef_t *item, float x, float y ) +{ + rectDef_t r; + float vScale = Item_Slider_VScale( item ); + + r.x = Item_Slider_ThumbPosition( item ) - ( SLIDER_THUMB_WIDTH / 2 ); + r.y = item->textRect.y - item->textRect.h + + ( ( item->textRect.h - ( SLIDER_THUMB_HEIGHT * vScale ) ) / 2.0f ); + r.w = SLIDER_THUMB_WIDTH; + r.h = SLIDER_THUMB_HEIGHT * vScale; + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_THUMB; + + return 0; +} + +int Item_ListBox_OverLB( itemDef_t *item, float x, float y ) +{ + rectDef_t r; + int thumbstart; + int count; + + count = DC->feederCount( item->feederID ); + + r.x = SCROLLBAR_SLIDER_X( item ); + r.y = SCROLLBAR_Y( item ); + r.w = SCROLLBAR_ARROW_WIDTH; + r.h = SCROLLBAR_ARROW_HEIGHT; + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_UPARROW; + + r.y = SCROLLBAR_SLIDER_Y( item ) + SCROLLBAR_SLIDER_HEIGHT( item ); + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_DOWNARROW; + + thumbstart = Item_ListBox_ThumbPosition( item ); + r.y = thumbstart; + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_THUMB; + + r.y = SCROLLBAR_SLIDER_Y( item ); + r.h = thumbstart - r.y; + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_PGUP; + + r.y = thumbstart + SCROLLBAR_ARROW_HEIGHT; + r.h = ( SCROLLBAR_SLIDER_Y( item ) + SCROLLBAR_SLIDER_HEIGHT( item ) ) - r.y; + + if( Rect_ContainsPoint( &r, x, y ) ) + return WINDOW_LB_PGDN; + + return 0; +} + + +void Item_ListBox_MouseEnter( itemDef_t *item, float x, float y ) +{ + rectDef_t r; + listBoxDef_t *listPtr = item->typeData.list; + int listBoxFlags = ( WINDOW_LB_UPARROW | WINDOW_LB_DOWNARROW | WINDOW_LB_THUMB | + WINDOW_LB_PGUP | WINDOW_LB_PGDN ); + int total = DC->feederCount( item->feederID ); + + item->window.flags &= ~listBoxFlags; + item->window.flags |= Item_ListBox_OverLB( item, x, y ); + + if( !( item->window.flags & listBoxFlags ) ) + { + r.x = SCROLLBAR_X( item ); + r.y = SCROLLBAR_Y( item ); + r.w = SCROLLBAR_W( item ); + r.h = listPtr->elementHeight * + MIN( Item_ListBox_NumItemsForItemHeight( item ), total ); + + if( Rect_ContainsPoint( &r, x, y ) ) + { + listPtr->cursorPos = (int)( ( y - r.y ) / listPtr->elementHeight ) + listPtr->startPos; + + if( listPtr->cursorPos >= listPtr->endPos ) + listPtr->cursorPos = listPtr->endPos - 1; + } + else + listPtr->cursorPos = -1; + } +} + +void Item_MouseEnter( itemDef_t *item, float x, float y ) +{ + rectDef_t r; + + if( item ) + { + r = item->textRect; + r.y -= r.h; + // in the text rect? + + // items can be enabled and disabled based on cvars + + if( item->cvarFlags & ( CVAR_ENABLE | CVAR_DISABLE ) && !Item_EnableShowViaCvar( item, CVAR_ENABLE ) ) + return; + + if( item->cvarFlags & ( CVAR_SHOW | CVAR_HIDE ) && !Item_EnableShowViaCvar( item, CVAR_SHOW ) ) + return; + + if( Rect_ContainsPoint( &r, x, y ) ) + { + if( !( item->window.flags & WINDOW_MOUSEOVERTEXT ) ) + { + Item_RunScript( item, item->mouseEnterText ); + item->window.flags |= WINDOW_MOUSEOVERTEXT; + } + + if( !( item->window.flags & WINDOW_MOUSEOVER ) ) + { + Item_RunScript( item, item->mouseEnter ); + item->window.flags |= WINDOW_MOUSEOVER; + } + + } + else + { + // not in the text rect + + if( item->window.flags & WINDOW_MOUSEOVERTEXT ) + { + // if we were + Item_RunScript( item, item->mouseExitText ); + item->window.flags &= ~WINDOW_MOUSEOVERTEXT; + } + + if( !( item->window.flags & WINDOW_MOUSEOVER ) ) + { + Item_RunScript( item, item->mouseEnter ); + item->window.flags |= WINDOW_MOUSEOVER; + } + + if( item->type == ITEM_TYPE_LISTBOX ) + Item_ListBox_MouseEnter( item, x, y ); + } + } +} + +void Item_MouseLeave( itemDef_t *item ) +{ + if( item ) + { + if( item->window.flags & WINDOW_MOUSEOVERTEXT ) + { + Item_RunScript( item, item->mouseExitText ); + item->window.flags &= ~WINDOW_MOUSEOVERTEXT; + } + + Item_RunScript( item, item->mouseExit ); + item->window.flags &= ~( WINDOW_LB_DOWNARROW | WINDOW_LB_UPARROW ); + } +} + +itemDef_t *Menu_HitTest( menuDef_t *menu, float x, float y ) +{ + int i; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( Rect_ContainsPoint( &menu->items[i]->window.rect, x, y ) ) + return menu->items[i]; + } + + return NULL; +} + +void Item_SetMouseOver( itemDef_t *item, qboolean focus ) +{ + if( item ) + { + if( focus ) + item->window.flags |= WINDOW_MOUSEOVER; + else + item->window.flags &= ~WINDOW_MOUSEOVER; + } +} + + +qboolean Item_OwnerDraw_HandleKey( itemDef_t *item, int key ) +{ + if( item && DC->ownerDrawHandleKey ) + return DC->ownerDrawHandleKey( item->window.ownerDraw, key ); + + return qfalse; +} + +qboolean Item_ListBox_HandleKey( itemDef_t *item, int key, qboolean down, qboolean force ) +{ + listBoxDef_t *listPtr = item->typeData.list; + int count = DC->feederCount( item->feederID ); + int viewmax; + + if( force || ( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) && + item->window.flags & WINDOW_HASFOCUS ) ) + { + viewmax = Item_ListBox_NumItemsForItemHeight( item ); + + switch( key ) + { + case K_MOUSE1: + case K_MOUSE2: + if( item->window.flags & WINDOW_LB_UPARROW ) + Item_ListBox_SetStartPos( item, listPtr->startPos - 1 ); + else if( item->window.flags & WINDOW_LB_DOWNARROW ) + Item_ListBox_SetStartPos( item, listPtr->startPos + 1 ); + else if( item->window.flags & WINDOW_LB_PGUP ) + Item_ListBox_SetStartPos( item, listPtr->startPos - viewmax ); + else if( item->window.flags & WINDOW_LB_PGDN ) + Item_ListBox_SetStartPos( item, listPtr->startPos + viewmax ); + else if( item->window.flags & WINDOW_LB_THUMB ) + break; // Handled by capture function + else + { + // Select an item + qboolean runDoubleClick = qfalse; + + // Mouse isn't over an item + if( listPtr->cursorPos < 0 ) + break; + + if( item->cursorPos != listPtr->cursorPos ) + { + item->cursorPos = listPtr->cursorPos; + DC->feederSelection( item->feederID, item->cursorPos ); + } + + runDoubleClick = DC->realTime < lastListBoxClickTime && listPtr->doubleClick; + lastListBoxClickTime = DC->realTime + DOUBLE_CLICK_DELAY; + + // Made a selection, so close combobox + if( g_comboBoxItem != NULL ) + { + if( listPtr->doubleClick ) + runDoubleClick = qtrue; + + g_comboBoxItem = NULL; + } + + if( runDoubleClick ) + Item_RunScript( item, listPtr->doubleClick ); + } + + break; + + case K_MWHEELUP: + Item_ListBox_SetStartPos( item, listPtr->startPos - 1 ); + break; + + case K_MWHEELDOWN: + Item_ListBox_SetStartPos( item, listPtr->startPos + 1 ); + break; + + case K_ENTER: + // Invoke the doubleClick handler when enter is pressed + if( listPtr->doubleClick ) + Item_RunScript( item, listPtr->doubleClick ); + + break; + + case K_PGUP: + case K_KP_PGUP: + if( !listPtr->notselectable ) + { + listPtr->cursorPos -= viewmax; + + if( listPtr->cursorPos < 0 ) + listPtr->cursorPos = 0; + + if( listPtr->cursorPos < listPtr->startPos ) + Item_ListBox_SetStartPos( item, listPtr->cursorPos ); + + if( listPtr->cursorPos >= listPtr->startPos + viewmax ) + Item_ListBox_SetStartPos( item, listPtr->cursorPos - viewmax + 1 ); + + item->cursorPos = listPtr->cursorPos; + DC->feederSelection( item->feederID, item->cursorPos ); + } + else + Item_ListBox_SetStartPos( item, listPtr->startPos - viewmax ); + + break; + + case K_PGDN: + case K_KP_PGDN: + if( !listPtr->notselectable ) + { + listPtr->cursorPos += viewmax; + + if( listPtr->cursorPos < listPtr->startPos ) + Item_ListBox_SetStartPos( item, listPtr->cursorPos ); + + if( listPtr->cursorPos >= count ) + listPtr->cursorPos = count - 1; + + if( listPtr->cursorPos >= listPtr->startPos + viewmax ) + Item_ListBox_SetStartPos( item, listPtr->cursorPos - viewmax + 1 ); + + item->cursorPos = listPtr->cursorPos; + DC->feederSelection( item->feederID, item->cursorPos ); + } + else + Item_ListBox_SetStartPos( item, listPtr->startPos + viewmax ); + + break; + + default: + // Not handled + return qfalse; + } + + return qtrue; + } + + return qfalse; +} + +qboolean Item_ComboBox_HandleKey( itemDef_t *item, int key, qboolean down, qboolean force ) +{ + if( g_comboBoxItem != NULL ) + { + qboolean result; + + qboolean cast = Item_ComboBox_MaybeCastToListBox( item ); + result = Item_ListBox_HandleKey( item, key, down, force ); + Item_ComboBox_MaybeUnCastFromListBox( item, cast ); + + if( !result ) + g_comboBoxItem = NULL; + + return result; + } + else + { + if( force || ( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) && + item->window.flags & WINDOW_HASFOCUS ) ) + { + if( key == K_MOUSE1 || key == K_MOUSE2 ) + { + g_comboBoxItem = item; + + return qtrue; + } + } + } + + return qfalse; +} + +qboolean Item_YesNo_HandleKey( itemDef_t *item, int key ) +{ + if( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) && + item->window.flags & WINDOW_HASFOCUS && item->cvar ) + { + if( key == K_MOUSE1 || key == K_ENTER || key == K_MOUSE2 || key == K_MOUSE3 ) + { + DC->setCVar( item->cvar, va( "%i", !DC->getCVarValue( item->cvar ) ) ); + return qtrue; + } + } + + return qfalse; + +} + +int Item_Multi_CountSettings( itemDef_t *item ) +{ + if( item->typeData.multi == NULL ) + return 0; + + return item->typeData.multi->count; +} + +int Item_Multi_FindCvarByValue( itemDef_t *item ) +{ + char buff[1024]; + float value = 0; + int i; + multiDef_t *multiPtr = item->typeData.multi; + + if( multiPtr ) + { + if( multiPtr->strDef ) + DC->getCVarString( item->cvar, buff, sizeof( buff ) ); + else + value = DC->getCVarValue( item->cvar ); + + for( i = 0; i < multiPtr->count; i++ ) + { + if( multiPtr->strDef ) + { + if( Q_stricmp( buff, multiPtr->cvarStr[i] ) == 0 ) + return i; + } + else + { + if( multiPtr->cvarValue[i] == value ) + return i; + } + } + } + + return 0; +} + +const char *Item_Multi_Setting( itemDef_t *item ) +{ + char buff[1024]; + float value = 0; + int i; + multiDef_t *multiPtr = item->typeData.multi; + + if( multiPtr ) + { + if( multiPtr->strDef ) + DC->getCVarString( item->cvar, buff, sizeof( buff ) ); + else + value = DC->getCVarValue( item->cvar ); + + for( i = 0; i < multiPtr->count; i++ ) + { + if( multiPtr->strDef ) + { + if( Q_stricmp( buff, multiPtr->cvarStr[i] ) == 0 ) + return multiPtr->cvarList[i]; + } + else + { + if( multiPtr->cvarValue[i] == value ) + return multiPtr->cvarList[i]; + } + } + } + + return ""; +} + +qboolean Item_Cycle_HandleKey( itemDef_t *item, int key ) +{ + cycleDef_t *cyclePtr = item->typeData.cycle; + qboolean mouseOver = Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ); + int count = DC->feederCount( item->feederID ); + + if( cyclePtr ) + { + if( item->window.flags & WINDOW_HASFOCUS ) + { + if( ( mouseOver && key == K_MOUSE1 ) || + key == K_ENTER || key == K_RIGHTARROW || key == K_DOWNARROW ) + { + if( count > 0 ) + cyclePtr->cursorPos = ( cyclePtr->cursorPos + 1 ) % count; + + DC->feederSelection( item->feederID, cyclePtr->cursorPos ); + + return qtrue; + } + else if( ( mouseOver && key == K_MOUSE2 ) || + key == K_LEFTARROW || key == K_UPARROW ) + { + if( count > 0 ) + cyclePtr->cursorPos = ( count + cyclePtr->cursorPos - 1 ) % count; + + DC->feederSelection( item->feederID, cyclePtr->cursorPos ); + + return qtrue; + } + } + } + + return qfalse; +} + +qboolean Item_Multi_HandleKey( itemDef_t *item, int key ) +{ + qboolean mouseOver = Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ); + int max = Item_Multi_CountSettings( item ); + qboolean changed = qfalse; + + if( item->typeData.multi ) + { + if( item->window.flags & WINDOW_HASFOCUS && item->cvar && max > 0 ) + { + int current; + + if( ( mouseOver && key == K_MOUSE1 ) || + key == K_ENTER || key == K_RIGHTARROW || key == K_DOWNARROW ) + { + current = ( Item_Multi_FindCvarByValue( item ) + 1 ) % max; + changed = qtrue; + } + else if( ( mouseOver && key == K_MOUSE2 ) || + key == K_LEFTARROW || key == K_UPARROW ) + { + current = ( Item_Multi_FindCvarByValue( item ) + max - 1 ) % max; + changed = qtrue; + } + + if( changed ) + { + if( item->typeData.multi->strDef ) + DC->setCVar( item->cvar, item->typeData.multi->cvarStr[current] ); + else + { + float value = item->typeData.multi->cvarValue[current]; + + if( ( ( float )( ( int ) value ) ) == value ) + DC->setCVar( item->cvar, va( "%i", ( int ) value ) ); + else + DC->setCVar( item->cvar, va( "%f", value ) ); + } + + return qtrue; + } + } + } + + return qfalse; +} + +#define MIN_FIELD_WIDTH 10 +#define EDIT_CURSOR_WIDTH 10 + +static void Item_TextField_CalcPaintOffset( itemDef_t *item, char *buff ) +{ + editFieldDef_t *editPtr = item->typeData.edit; + + if( item->cursorPos < editPtr->paintOffset ) + editPtr->paintOffset = item->cursorPos; + else + { + // If there is a maximum field width + + if( editPtr->maxFieldWidth > 0 ) + { + // If the cursor is at the end of the string, maximise the amount of the + // string that's visible + + if( buff[ item->cursorPos + 1 ] == '\0' ) + { + while( UI_Text_Width( &buff[ editPtr->paintOffset ], item->textscale ) <= + ( editPtr->maxFieldWidth - EDIT_CURSOR_WIDTH ) && editPtr->paintOffset > 0 ) + editPtr->paintOffset--; + } + + buff[ item->cursorPos + 1 ] = '\0'; + + // Shift paintOffset so that the cursor is visible + + while( UI_Text_Width( &buff[ editPtr->paintOffset ], item->textscale ) > + ( editPtr->maxFieldWidth - EDIT_CURSOR_WIDTH ) ) + editPtr->paintOffset++; + } + } +} + +qboolean Item_TextField_HandleKey( itemDef_t *item, int key ) +{ + char buff[1024]; + int len; + itemDef_t *newItem = NULL; + editFieldDef_t *editPtr = item->typeData.edit; + qboolean releaseFocus = qtrue; + + if( item->cvar ) + { + Com_Memset( buff, 0, sizeof( buff ) ); + DC->getCVarString( item->cvar, buff, sizeof( buff ) ); + len = strlen( buff ); + + if( len < item->cursorPos ) + item->cursorPos = len; + + if( editPtr->maxChars && len > editPtr->maxChars ) + len = editPtr->maxChars; + + if( key & K_CHAR_FLAG ) + { + key &= ~K_CHAR_FLAG; + + if( key == 'h' - 'a' + 1 ) + { + // ctrl-h is backspace + + if( item->cursorPos > 0 ) + { + memmove( &buff[item->cursorPos - 1], &buff[item->cursorPos], len + 1 - item->cursorPos ); + item->cursorPos--; + } + + DC->setCVar( item->cvar, buff ); + } + else if( key < 32 || !item->cvar ) + { + // Ignore any non printable chars + releaseFocus = qfalse; + goto exit; + } + else if( item->type == ITEM_TYPE_NUMERICFIELD && ( key < '0' || key > '9' ) ) + { + // Ignore non-numeric characters + releaseFocus = qfalse; + goto exit; + } + else + { + if( !DC->getOverstrikeMode() ) + { + if( ( len == MAX_EDITFIELD - 1 ) || ( editPtr->maxChars && len >= editPtr->maxChars ) ) + { + // Reached maximum field length + releaseFocus = qfalse; + goto exit; + } + + memmove( &buff[item->cursorPos + 1], &buff[item->cursorPos], len + 1 - item->cursorPos ); + } + else + { + // Reached maximum field length + if( editPtr->maxChars && item->cursorPos >= editPtr->maxChars ) + { + releaseFocus = qfalse; + goto exit; + } + } + + buff[ item->cursorPos ] = key; + + DC->setCVar( item->cvar, buff ); + + if( item->cursorPos < len + 1 ) + item->cursorPos++; + } + } + else + { + switch( key ) + { + case K_DEL: + case K_KP_DEL: + if( item->cursorPos < len ) + { + memmove( buff + item->cursorPos, buff + item->cursorPos + 1, len - item->cursorPos ); + DC->setCVar( item->cvar, buff ); + } + + break; + + case K_RIGHTARROW: + case K_KP_RIGHTARROW: + if( item->cursorPos < len ) + item->cursorPos++; + + break; + + case K_LEFTARROW: + case K_KP_LEFTARROW: + if( item->cursorPos > 0 ) + item->cursorPos--; + + break; + + case K_HOME: + case K_KP_HOME: + item->cursorPos = 0; + + break; + + case K_END: + case K_KP_END: + item->cursorPos = len; + + break; + + case K_INS: + case K_KP_INS: + DC->setOverstrikeMode( !DC->getOverstrikeMode() ); + + break; + + case K_TAB: + case K_DOWNARROW: + case K_KP_DOWNARROW: + case K_UPARROW: + case K_KP_UPARROW: + // Ignore these keys from the say field + if( item->type == ITEM_TYPE_SAYFIELD ) + break; + + newItem = Menu_SetNextCursorItem( item->parent ); + + if( newItem && Item_IsEditField( newItem ) ) + { + g_editItem = newItem; + } + else + { + releaseFocus = qtrue; + goto exit; + } + + break; + + case K_MOUSE1: + case K_MOUSE2: + case K_MOUSE3: + case K_MOUSE4: + // Ignore these buttons from the say field + if( item->type == ITEM_TYPE_SAYFIELD ) + break; + // FALLTHROUGH + case K_ENTER: + case K_KP_ENTER: + case K_ESCAPE: + releaseFocus = qtrue; + goto exit; + + default: + break; + } + } + + releaseFocus = qfalse; + } + +exit: + Item_TextField_CalcPaintOffset( item, buff ); + + return !releaseFocus; +} + +static void _Scroll_ListBox_AutoFunc( scrollInfo_t *si ) +{ + if( DC->realTime > si->nextScrollTime ) + { + // need to scroll which is done by simulating a click to the item + // this is done a bit sideways as the autoscroll "knows" that the item is a listbox + // so it calls it directly + Item_ListBox_HandleKey( si->item, si->scrollKey, qtrue, qfalse ); + + si->nextScrollTime = DC->realTime + si->adjustValue; + } + + if( DC->realTime > si->nextAdjustTime ) + { + si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST; + + if( si->adjustValue > SCROLL_TIME_FLOOR ) + si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET; + } +} + +static void Scroll_ListBox_AutoFunc( void *p ) +{ + scrollInfo_t *si = ( scrollInfo_t* )p; + + qboolean cast = Item_ComboBox_MaybeCastToListBox( si->item ); + _Scroll_ListBox_AutoFunc( si ); + Item_ComboBox_MaybeUnCastFromListBox( si->item, cast ); +} + +static void _Scroll_ListBox_ThumbFunc( scrollInfo_t *si ) +{ + rectDef_t r; + int pos, max; + + if( DC->cursory != si->yStart ) + { + r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_ARROW_WIDTH - 1; + r.y = si->item->window.rect.y + SCROLLBAR_ARROW_HEIGHT + 1; + r.w = SCROLLBAR_ARROW_WIDTH; + r.h = si->item->window.rect.h - ( SCROLLBAR_ARROW_HEIGHT * 2 ) - 2; + max = Item_ListBox_MaxScroll( si->item ); + // + pos = ( DC->cursory - r.y - SCROLLBAR_ARROW_HEIGHT / 2 ) * max / ( r.h - SCROLLBAR_ARROW_HEIGHT ); + + if( pos < 0 ) + pos = 0; + else if( pos > max ) + pos = max; + + Item_ListBox_SetStartPos( si->item, pos ); + si->yStart = DC->cursory; + } + + if( DC->realTime > si->nextScrollTime ) + { + // need to scroll which is done by simulating a click to the item + // this is done a bit sideways as the autoscroll "knows" that the item is a listbox + // so it calls it directly + Item_ListBox_HandleKey( si->item, si->scrollKey, qtrue, qfalse ); + + si->nextScrollTime = DC->realTime + si->adjustValue; + } + + if( DC->realTime > si->nextAdjustTime ) + { + si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST; + + if( si->adjustValue > SCROLL_TIME_FLOOR ) + si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET; + } +} + +static void Scroll_ListBox_ThumbFunc( void *p ) +{ + scrollInfo_t *si = ( scrollInfo_t* )p; + + qboolean cast = Item_ComboBox_MaybeCastToListBox( si->item ); + _Scroll_ListBox_ThumbFunc( si ); + Item_ComboBox_MaybeUnCastFromListBox( si->item, cast ); +} + +static void Scroll_Slider_ThumbFunc( void *p ) +{ + float x, value, cursorx; + scrollInfo_t *si = ( scrollInfo_t* )p; + + if( si->item->text ) + x = si->item->textRect.x + si->item->textRect.w + ITEM_VALUE_OFFSET; + else + x = si->item->window.rect.x; + + cursorx = DC->cursorx; + + if( cursorx < x ) + cursorx = x; + else if( cursorx > x + SLIDER_WIDTH ) + cursorx = x + SLIDER_WIDTH; + + value = cursorx - x; + value /= SLIDER_WIDTH; + value *= si->item->typeData.edit->maxVal - si->item->typeData.edit->minVal; + value += si->item->typeData.edit->minVal; + DC->setCVar( si->item->cvar, va( "%f", value ) ); +} + +void Item_StartCapture( itemDef_t *item, int key ) +{ + int flags; + + // Don't allow captureFunc to be overridden + + if( captureFunc != voidFunction ) + return; + + switch( item->type ) + { + case ITEM_TYPE_LISTBOX: + case ITEM_TYPE_COMBOBOX: + { + qboolean cast = Item_ComboBox_MaybeCastToListBox( item ); + flags = Item_ListBox_OverLB( item, DC->cursorx, DC->cursory ); + Item_ComboBox_MaybeUnCastFromListBox( item, cast ); + + if( flags & ( WINDOW_LB_UPARROW | WINDOW_LB_DOWNARROW ) ) + { + scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START; + scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST; + scrollInfo.adjustValue = SCROLL_TIME_START; + scrollInfo.scrollKey = key; + scrollInfo.scrollDir = ( flags & WINDOW_LB_UPARROW ) ? qtrue : qfalse; + scrollInfo.item = item; + UI_InstallCaptureFunc( Scroll_ListBox_AutoFunc, &scrollInfo, 0 ); + itemCapture = item; + } + else if( flags & WINDOW_LB_THUMB ) + { + scrollInfo.scrollKey = key; + scrollInfo.item = item; + scrollInfo.xStart = DC->cursorx; + scrollInfo.yStart = DC->cursory; + UI_InstallCaptureFunc( Scroll_ListBox_ThumbFunc, &scrollInfo, 0 ); + itemCapture = item; + } + + break; + } + + case ITEM_TYPE_SLIDER: + { + flags = Item_Slider_OverSlider( item, DC->cursorx, DC->cursory ); + + if( flags & WINDOW_LB_THUMB ) + { + scrollInfo.scrollKey = key; + scrollInfo.item = item; + scrollInfo.xStart = DC->cursorx; + scrollInfo.yStart = DC->cursory; + UI_InstallCaptureFunc( Scroll_Slider_ThumbFunc, &scrollInfo, 0 ); + itemCapture = item; + } + + break; + } + } +} + +void Item_StopCapture( itemDef_t *item ) +{ +} + +qboolean Item_Slider_HandleKey( itemDef_t *item, int key, qboolean down ) +{ + float x, value, width; + + if( item->window.flags & WINDOW_HASFOCUS && item->cvar && + Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) ) + { + if( item->typeData.edit && ( key == K_ENTER || + key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) + { + rectDef_t testRect; + width = SLIDER_WIDTH; + + if( item->text ) + x = item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET; + else + x = item->window.rect.x; + + testRect = item->window.rect; + value = ( float )SLIDER_THUMB_WIDTH / 2; + testRect.x = x - value; + testRect.w = SLIDER_WIDTH + value; + + if( Rect_ContainsPoint( &testRect, DC->cursorx, DC->cursory ) ) + { + value = ( float )( DC->cursorx - x ) / width; + value *= ( item->typeData.edit->maxVal - item->typeData.edit->minVal ); + value += item->typeData.edit->minVal; + DC->setCVar( item->cvar, va( "%f", value ) ); + return qtrue; + } + } + } + + return qfalse; +} + + +qboolean Item_HandleKey( itemDef_t *item, int key, qboolean down ) +{ + if( itemCapture ) + { + Item_StopCapture( itemCapture ); + itemCapture = NULL; + UI_RemoveCaptureFunc( ); + } + else + { + if( down && ( key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) + Item_StartCapture( item, key ); + } + + if( !down ) + return qfalse; + + // Edit fields are handled specially + if( Item_IsEditField( item ) ) + return qfalse; + + switch( item->type ) + { + case ITEM_TYPE_BUTTON: + return qfalse; + + case ITEM_TYPE_RADIOBUTTON: + return qfalse; + + case ITEM_TYPE_CHECKBOX: + return qfalse; + + case ITEM_TYPE_CYCLE: + return Item_Cycle_HandleKey( item, key ); + + case ITEM_TYPE_LISTBOX: + return Item_ListBox_HandleKey( item, key, down, qfalse ); + + case ITEM_TYPE_COMBOBOX: + return Item_ComboBox_HandleKey( item, key, down, qfalse ); + + case ITEM_TYPE_YESNO: + return Item_YesNo_HandleKey( item, key ); + + case ITEM_TYPE_MULTI: + return Item_Multi_HandleKey( item, key ); + + case ITEM_TYPE_OWNERDRAW: + return Item_OwnerDraw_HandleKey( item, key ); + + case ITEM_TYPE_BIND: + return Item_Bind_HandleKey( item, key, down ); + + case ITEM_TYPE_SLIDER: + return Item_Slider_HandleKey( item, key, down ); + + default: + return qfalse; + } +} + +void Item_Action( itemDef_t *item ) +{ + if( item ) + Item_RunScript( item, item->action ); +} + +itemDef_t *Menu_SetPrevCursorItem( menuDef_t *menu ) +{ + qboolean wrapped = qfalse; + int oldCursor = menu->cursorItem; + + if( menu->cursorItem < 0 ) + { + menu->cursorItem = menu->itemCount - 1; + wrapped = qtrue; + } + + while( menu->cursorItem > -1 ) + { + menu->cursorItem--; + + if( menu->cursorItem < 0 && !wrapped ) + { + wrapped = qtrue; + menu->cursorItem = menu->itemCount - 1; + } + + if( Item_SetFocus( menu->items[menu->cursorItem], DC->cursorx, DC->cursory ) ) + { + Menu_HandleMouseMove( menu, menu->items[menu->cursorItem]->window.rect.x + 1, + menu->items[menu->cursorItem]->window.rect.y + 1 ); + return menu->items[menu->cursorItem]; + } + } + + menu->cursorItem = oldCursor; + return NULL; + +} + +itemDef_t *Menu_SetNextCursorItem( menuDef_t *menu ) +{ + qboolean wrapped = qfalse; + int oldCursor = menu->cursorItem; + + + if( menu->cursorItem == -1 ) + { + menu->cursorItem = 0; + wrapped = qtrue; + } + + while( menu->cursorItem < menu->itemCount ) + { + menu->cursorItem++; + + if( menu->cursorItem >= menu->itemCount && !wrapped ) + { + wrapped = qtrue; + menu->cursorItem = 0; + } + + if( Item_SetFocus( menu->items[menu->cursorItem], DC->cursorx, DC->cursory ) ) + { + Menu_HandleMouseMove( menu, menu->items[menu->cursorItem]->window.rect.x + 1, + menu->items[menu->cursorItem]->window.rect.y + 1 ); + return menu->items[menu->cursorItem]; + } + + } + + menu->cursorItem = oldCursor; + return NULL; +} + +static void Window_CloseCinematic( windowDef_t *window ) +{ + if( window->style == WINDOW_STYLE_CINEMATIC && window->cinematic >= 0 ) + { + DC->stopCinematic( window->cinematic ); + window->cinematic = -1; + } +} + +static void Menu_CloseCinematics( menuDef_t *menu ) +{ + if( menu ) + { + int i; + Window_CloseCinematic( &menu->window ); + + for( i = 0; i < menu->itemCount; i++ ) + { + Window_CloseCinematic( &menu->items[i]->window ); + + if( menu->items[i]->type == ITEM_TYPE_OWNERDRAW ) + DC->stopCinematic( 0 - menu->items[i]->window.ownerDraw ); + } + } +} + +static void Display_CloseCinematics( void ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + Menu_CloseCinematics( &Menus[i] ); +} + +void Menus_Activate( menuDef_t *menu ) +{ + int i; + qboolean onTopOfMenuStack = qfalse; + + if( openMenuCount > 0 && menuStack[ openMenuCount - 1 ] == menu ) + onTopOfMenuStack = qtrue; + + menu->window.flags |= ( WINDOW_HASFOCUS | WINDOW_VISIBLE ); + + // If being opened for the first time + if( !onTopOfMenuStack ) + { + if( menu->onOpen ) + { + itemDef_t item; + item.parent = menu; + Item_RunScript( &item, menu->onOpen ); + } + + if( menu->soundName && *menu->soundName ) + DC->startBackgroundTrack( menu->soundName, menu->soundName ); + + Display_CloseCinematics( ); + + Menu_HandleMouseMove( menu, DC->cursorx, DC->cursory ); // force the item under the cursor to focus + + for( i = 0; i < menu->itemCount; i++ ) // reset selection in listboxes when opened + { + if( Item_IsListBox( menu->items[ i ] ) ) + { + menu->items[ i ]->cursorPos = DC->feederInitialise( menu->items[ i ]->feederID ); + Item_ListBox_SetStartPos( menu->items[ i ], 0 ); + DC->feederSelection( menu->items[ i ]->feederID, menu->items[ i ]->cursorPos ); + } + else if( menu->items[ i ]->type == ITEM_TYPE_CYCLE ) + { + menu->items[ i ]->typeData.cycle->cursorPos = + DC->feederInitialise( menu->items[ i ]->feederID ); + } + + } + + if( openMenuCount < MAX_OPEN_MENUS ) + menuStack[ openMenuCount++ ] = menu; + } +} + +qboolean Menus_ReplaceActive( menuDef_t *menu ) +{ + int i; + menuDef_t *active; + + if( openMenuCount < 1 ) + return qfalse; + + active = menuStack[ openMenuCount - 1 ]; + + if( !( active->window.flags & WINDOW_HASFOCUS ) || + !( active->window.flags & WINDOW_VISIBLE ) ) + { + return qfalse; + } + + if( menu == active ) + return qfalse; + + if( menu->itemCount != active->itemCount ) + { + Com_Printf( S_COLOR_YELLOW + "WARNING: Menus_ReplaceActive: expecting %i menu items, found %i\n", + menu->itemCount, active->itemCount); + return qfalse; + } + + for( i = 0; i < menu->itemCount; i++ ) + { + if( menu->items[ i ]->type != active->items[ i ]->type ) + { + Com_Printf( S_COLOR_YELLOW + "WARNING: Menus_ReplaceActive: type mismatch on item %i\n", i + 1 ); + return qfalse; + } + } + + active->window.flags &= ~( WINDOW_FADINGOUT | WINDOW_VISIBLE ); + menu->window.flags |= ( WINDOW_HASFOCUS | WINDOW_VISIBLE ); + + menuStack[ openMenuCount - 1 ] = menu; + if( menu->onOpen ) + { + itemDef_t item; + item.parent = menu; + Item_RunScript( &item, menu->onOpen ); + } + + // set the cursor position on the new menu to match the active one + for( i = 0; i < menu->itemCount; i++ ) + { + menu->items[ i ]->cursorPos = active->items[ i ]->cursorPos; + menu->items[ i ]->feederID = active->items[ i ]->feederID; + switch( Item_DataType( menu->items[ i ] ) ) + { + case TYPE_LIST: + menu->items[ i ]->typeData.list->startPos = + active->items[ i ]->typeData.list->startPos; + menu->items[ i ]->typeData.list->cursorPos = + active->items[ i ]->typeData.list->cursorPos; + break; + case TYPE_COMBO: + menu->items[ i ]->typeData.cycle->cursorPos = + active->items[ i ]->typeData.cycle->cursorPos; + break; + default: + break; + } + } + return qtrue; +} + +int Display_VisibleMenuCount( void ) +{ + int i, count; + count = 0; + + for( i = 0; i < menuCount; i++ ) + { + if( Menus[i].window.flags & ( WINDOW_FORCED | WINDOW_VISIBLE ) ) + count++; + } + + return count; +} + +void Menus_HandleOOBClick( menuDef_t *menu, int key, qboolean down ) +{ + if( menu ) + { + int i; + // basically the behaviour we are looking for is if there are windows in the stack.. see if + // the cursor is within any of them.. if not close them otherwise activate them and pass the + // key on.. force a mouse move to activate focus and script stuff + + if( down && menu->window.flags & WINDOW_OOB_CLICK ) + Menus_Close( menu ); + + for( i = 0; i < menuCount; i++ ) + { + if( Menu_OverActiveItem( &Menus[i], DC->cursorx, DC->cursory ) ) + { + Menus_Close( menu ); + Menus_Activate( &Menus[i] ); + Menu_HandleMouseMove( &Menus[i], DC->cursorx, DC->cursory ); + Menu_HandleKey( &Menus[i], key, down ); + } + } + + if( Display_VisibleMenuCount() == 0 ) + { + if( DC->Pause ) + DC->Pause( qfalse ); + } + + Display_CloseCinematics(); + } +} + +static rectDef_t *Item_CorrectedTextRect( itemDef_t *item ) +{ + static rectDef_t rect; + memset( &rect, 0, sizeof( rectDef_t ) ); + + if( item ) + { + rect = item->textRect; + + if( rect.w ) + rect.y -= rect.h; + } + + return ▭ +} + +void Menu_HandleKey( menuDef_t *menu, int key, qboolean down ) +{ + int i; + itemDef_t *item = NULL; + qboolean inHandler = qfalse; + + inHandler = qtrue; + + if( g_waitingForKey && down ) + { + Item_Bind_HandleKey( g_bindItem, key, down ); + inHandler = qfalse; + return; + } + + if( g_editingField && down ) + { + if( !Item_TextField_HandleKey( g_editItem, key ) ) + { + g_editingField = qfalse; + Item_RunScript( g_editItem, g_editItem->onTextEntry ); + g_editItem = NULL; + inHandler = qfalse; + return; + } + else + { + Item_RunScript( g_editItem, g_editItem->onCharEntry ); + } + } + + if( menu == NULL ) + { + inHandler = qfalse; + return; + } + + // see if the mouse is within the window bounds and if so is this a mouse click + if( down && !( menu->window.flags & WINDOW_POPUP ) && + !Rect_ContainsPoint( &menu->window.rect, DC->cursorx, DC->cursory ) ) + { + static qboolean inHandleKey = qfalse; + + if( !inHandleKey && ( key == K_MOUSE1 || key == K_MOUSE2 || key == K_MOUSE3 ) ) + { + inHandleKey = qtrue; + Menus_HandleOOBClick( menu, key, down ); + inHandleKey = qfalse; + inHandler = qfalse; + return; + } + } + + if( g_comboBoxItem == NULL ) + { + // get the item with focus + for( i = 0; i < menu->itemCount; i++ ) + { + if( menu->items[i]->window.flags & WINDOW_HASFOCUS ) + item = menu->items[i]; + } + } + else + item = g_comboBoxItem; + + if( item != NULL ) + { + if( Item_HandleKey( item, key, down ) ) + { + Item_Action( item ); + inHandler = qfalse; + return; + } + } + + if( !down ) + { + inHandler = qfalse; + return; + } + + // default handling + switch( key ) + { + case K_F12: + if( DC->getCVarValue( "developer" ) ) + DC->executeText( EXEC_APPEND, "screenshot\n" ); + + break; + + case K_KP_UPARROW: + case K_UPARROW: + Menu_SetPrevCursorItem( menu ); + break; + + case K_ESCAPE: + if( !g_waitingForKey && menu->onESC ) + { + itemDef_t it; + it.parent = menu; + Item_RunScript( &it, menu->onESC ); + } + + break; + + case K_TAB: + case K_KP_DOWNARROW: + case K_DOWNARROW: + Menu_SetNextCursorItem( menu ); + break; + + case K_MOUSE1: + case K_MOUSE2: + if( item ) + { + if( item->type == ITEM_TYPE_TEXT ) + { + if( Rect_ContainsPoint( Item_CorrectedTextRect( item ), DC->cursorx, DC->cursory ) ) + Item_Action( item ); + } + else if( Item_IsEditField( item ) ) + { + if( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) ) + { + char buffer[ MAX_STRING_CHARS ] = { 0 }; + + if( item->cvar ) + DC->getCVarString( item->cvar, buffer, sizeof( buffer ) ); + + item->cursorPos = strlen( buffer ); + + Item_TextField_CalcPaintOffset( item, buffer ); + + g_editingField = qtrue; + + g_editItem = item; + } + } + else + { + if( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) ) + Item_Action( item ); + } + } + + break; + + case K_JOY1: + case K_JOY2: + case K_JOY3: + case K_JOY4: + case K_AUX1: + case K_AUX2: + case K_AUX3: + case K_AUX4: + case K_AUX5: + case K_AUX6: + case K_AUX7: + case K_AUX8: + case K_AUX9: + case K_AUX10: + case K_AUX11: + case K_AUX12: + case K_AUX13: + case K_AUX14: + case K_AUX15: + case K_AUX16: + break; + + case K_KP_ENTER: + case K_ENTER: + if( item ) + { + if( Item_IsEditField( item ) ) + { + char buffer[ MAX_STRING_CHARS ] = { 0 }; + + if( item->cvar ) + DC->getCVarString( item->cvar, buffer, sizeof( buffer ) ); + + item->cursorPos = strlen( buffer ); + + Item_TextField_CalcPaintOffset( item, buffer ); + + g_editingField = qtrue; + + g_editItem = item; + } + else + Item_Action( item ); + } + + break; + } + + inHandler = qfalse; +} + +void ToWindowCoords( float *x, float *y, windowDef_t *window ) +{ + if( window->border != 0 ) + { + *x += window->borderSize; + *y += window->borderSize; + } + + *x += window->rect.x; + *y += window->rect.y; +} + +void Rect_ToWindowCoords( rectDef_t *rect, windowDef_t *window ) +{ + ToWindowCoords( &rect->x, &rect->y, window ); +} + +void Item_SetTextExtents( itemDef_t *item, const char *text ) +{ + const char *textPtr = ( text ) ? text : item->text; + qboolean cvarContent; + + // It's hard to make a policy on what should be aligned statically and what + // should be aligned dynamically; there are reasonable cases for both. If + // it continues to be a problem then there should probably be an item keyword + // for it; but for the moment only adjusting the alignment of ITEM_TYPE_TEXT + // seems to suffice. + cvarContent = ( item->cvar && item->textalignment != ALIGN_LEFT && + item->type == ITEM_TYPE_TEXT ); + + if( textPtr == NULL ) + return; + + // as long as the item isn't dynamic content (ownerdraw or cvar), this + // keeps us from computing the widths and heights more than once + if( item->textRect.w == 0.0f || cvarContent || ( item->type == ITEM_TYPE_OWNERDRAW && + item->textalignment != ALIGN_LEFT ) ) + { + float originalWidth = 0.0f; + + if( item->textalignment == ALIGN_CENTER || item->textalignment == ALIGN_RIGHT ) + { + if( cvarContent ) + { + char buff[ MAX_CVAR_VALUE_STRING ]; + DC->getCVarString( item->cvar, buff, sizeof( buff ) ); + originalWidth = UI_Text_Width( item->text, item->textscale ) + + UI_Text_Width( buff, item->textscale ); + } + else + originalWidth = UI_Text_Width( item->text, item->textscale ); + } + + item->textRect.w = UI_Text_Width( textPtr, item->textscale ); + item->textRect.h = UI_Text_Height( textPtr, item->textscale ); + + if( item->textvalignment == VALIGN_BOTTOM ) + item->textRect.y = item->textaligny + item->window.rect.h; + else if( item->textvalignment == VALIGN_CENTER ) + item->textRect.y = item->textaligny + ( ( item->textRect.h + item->window.rect.h ) / 2.0f ); + else if( item->textvalignment == VALIGN_TOP ) + item->textRect.y = item->textaligny + item->textRect.h; + + if( item->textalignment == ALIGN_LEFT ) + item->textRect.x = item->textalignx; + else if( item->textalignment == ALIGN_CENTER ) + item->textRect.x = item->textalignx + ( ( item->window.rect.w - originalWidth ) / 2.0f ); + else if( item->textalignment == ALIGN_RIGHT ) + item->textRect.x = item->textalignx + item->window.rect.w - originalWidth; + + ToWindowCoords( &item->textRect.x, &item->textRect.y, &item->window ); + } +} + +void Item_TextColor( itemDef_t *item, vec4_t *newColor ) +{ + vec4_t lowLight; + menuDef_t *parent = ( menuDef_t* )item->parent; + + Fade( &item->window.flags, &item->window.foreColor[3], parent->fadeClamp, + &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount ); + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else if( item->textStyle == ITEM_TEXTSTYLE_BLINK && !( ( DC->realTime / BLINK_DIVISOR ) & 1 ) ) + { + lowLight[0] = 0.8 * item->window.foreColor[0]; + lowLight[1] = 0.8 * item->window.foreColor[1]; + lowLight[2] = 0.8 * item->window.foreColor[2]; + lowLight[3] = 0.8 * item->window.foreColor[3]; + LerpColor( item->window.foreColor, lowLight, *newColor, 0.5 + 0.5 * sin( DC->realTime / PULSE_DIVISOR ) ); + } + else + { + memcpy( newColor, &item->window.foreColor, sizeof( vec4_t ) ); + // items can be enabled and disabled based on cvars + } + + if( item->enableCvar != NULL && *item->enableCvar && item->cvarTest != NULL && *item->cvarTest ) + { + if( item->cvarFlags & ( CVAR_ENABLE | CVAR_DISABLE ) && !Item_EnableShowViaCvar( item, CVAR_ENABLE ) ) + memcpy( newColor, &parent->disableColor, sizeof( vec4_t ) ); + } +} + +static void SkipColorCodes( const char **text, char *lastColor ) +{ + while( Q_IsColorString( *text ) ) + { + lastColor[ 0 ] = (*text)[ 0 ]; + lastColor[ 1 ] = (*text)[ 1 ]; + (*text) += 2; + } +} + +static void SkipWhiteSpace( const char **text, char *lastColor ) +{ + while( **text ) + { + SkipColorCodes( text, lastColor ); + + if( **text != '\n' && isspace( **text ) ) + (*text)++; + else + break; + } +} + +const char *Item_Text_Wrap( const char *text, float scale, float width ) +{ + static char out[ 8192 ] = ""; + char *paint = out; + char c[ 3 ] = ""; + const char *p; + const char *eos; + float indentWidth = 0.0f; + + if( !text ) + return NULL; + + p = text; + eos = p + strlen( p ); + + if( ( eos - p ) >= sizeof( out ) ) + return NULL; + + *paint = '\0'; + + while( *p ) + { + float textWidth = 0.0f; + const char *eol = p; + const char *q = p; + float testWidth = width - indentWidth; + + SkipColorCodes( &q, c ); + + while( q && textWidth < testWidth ) + { + qboolean previousCharIsSpace = qfalse; + + // Remaining string is too short to wrap + if( q >= eos ) + { + eol = eos; + break; + } + + if( q > p && *q == INDENT_MARKER ) + { + indentWidth = textWidth; + eol = p; + } + + // Some color escapes might still be present + SkipColorCodes( &q, c ); + + // Manual line break + if( *q == '\n' ) + { + eol = q + 1; + break; + } + + if( !previousCharIsSpace && isspace( *q ) ) + eol = q; + + textWidth += UI_Char_Width( &q, scale ); + } + + // No split has taken place, so just split mid-word + if( eol == p ) + eol = q; + + // Note that usage of strcat and strlen is deliberately being + // avoided here as it becomes surprisingly expensive on larger + // blocks of text + + // Copy text + strncpy( paint, p, eol - p ); + paint += ( eol - p ); + *paint = '\0'; + + p = eol; + + if( paint - out > 0 && *( paint - 1 ) == '\n' ) + { + // The line is deliberately broken, clear the color and + // any current indent + c[ 0 ] = '\0'; + indentWidth = 0.0f; + } + else + { + // Add a \n if it's not there already + *paint++ = '\n'; + *paint = '\0'; + + // Insert a pixel indent on the next line + if( indentWidth > 0.0f ) + { + char *indentMarkerText = va( "%f%c", indentWidth, INDENT_MARKER ); + int indentMarkerTextLength = strlen( indentMarkerText ); + + strncpy( paint, indentMarkerText, indentMarkerTextLength ); + paint += indentMarkerTextLength; + *paint = '\0'; + } + + // Skip leading whitespace on next line and save the + // last color code + SkipWhiteSpace( &p, c ); + } + + if( c[ 0 ] ) + { + *paint++ = c[ 0 ]; + *paint++ = c[ 1 ]; + *paint = '\0'; + } + } + + return out; +} + +#define MAX_WRAP_CACHE 16 +#define MAX_WRAP_LINES 32 +#define MAX_WRAP_TEXT 512 + +typedef struct +{ + char text[ MAX_WRAP_TEXT * MAX_WRAP_LINES ]; //FIXME: augment with hash? + rectDef_t rect; + float scale; + char lines[ MAX_WRAP_LINES ][ MAX_WRAP_TEXT ]; + float lineCoords[ MAX_WRAP_LINES ][ 2 ]; + int numLines; +} + +wrapCache_t; + +static wrapCache_t wrapCache[ MAX_WRAP_CACHE ]; +static int cacheWriteIndex = 0; +static int cacheReadIndex = 0; +static int cacheReadLineNum = 0; + +static void UI_CreateCacheEntry( const char *text, rectDef_t *rect, float scale ) +{ + wrapCache_t *cacheEntry = &wrapCache[ cacheWriteIndex ]; + + Q_strncpyz( cacheEntry->text, text, sizeof( cacheEntry->text ) ); + cacheEntry->rect.x = rect->x; + cacheEntry->rect.y = rect->y; + cacheEntry->rect.w = rect->w; + cacheEntry->rect.h = rect->h; + cacheEntry->scale = scale; + cacheEntry->numLines = 0; +} + +static void UI_AddCacheEntryLine( const char *text, float x, float y ) +{ + wrapCache_t *cacheEntry = &wrapCache[ cacheWriteIndex ]; + + if( cacheEntry->numLines >= MAX_WRAP_LINES ) + return; + + Q_strncpyz( cacheEntry->lines[ cacheEntry->numLines ], text, + sizeof( cacheEntry->lines[ 0 ] ) ); + + cacheEntry->lineCoords[ cacheEntry->numLines ][ 0 ] = x; + + cacheEntry->lineCoords[ cacheEntry->numLines ][ 1 ] = y; + + cacheEntry->numLines++; +} + +static void UI_FinishCacheEntry( void ) +{ + cacheWriteIndex = ( cacheWriteIndex + 1 ) % MAX_WRAP_CACHE; +} + +static qboolean UI_CheckWrapCache( const char *text, rectDef_t *rect, float scale ) +{ + int i; + + for( i = 0; i < MAX_WRAP_CACHE; i++ ) + { + wrapCache_t *cacheEntry = &wrapCache[ i ]; + + if( strcmp( text, cacheEntry->text ) ) + continue; + + if( rect->x != cacheEntry->rect.x || + rect->y != cacheEntry->rect.y || + rect->w != cacheEntry->rect.w || + rect->h != cacheEntry->rect.h ) + continue; + + if( cacheEntry->scale != scale ) + continue; + + // This is a match + cacheReadIndex = i; + + cacheReadLineNum = 0; + + return qtrue; + } + + // No match - wrap isn't cached + return qfalse; +} + +static qboolean UI_NextWrapLine( const char **text, float *x, float *y ) +{ + wrapCache_t *cacheEntry = &wrapCache[ cacheReadIndex ]; + + if( cacheReadLineNum >= cacheEntry->numLines ) + return qfalse; + + *text = cacheEntry->lines[ cacheReadLineNum ]; + + *x = cacheEntry->lineCoords[ cacheReadLineNum ][ 0 ]; + + *y = cacheEntry->lineCoords[ cacheReadLineNum ][ 1 ]; + + cacheReadLineNum++; + + return qtrue; +} + +void Item_Text_Wrapped_Paint( itemDef_t *item ) +{ + char text[ 1024 ]; + const char *p, *textPtr; + float x, y, w, h; + vec4_t color; + qboolean useWrapCache = (qboolean)DC->getCVarValue( "ui_textWrapCache" ); + + if( item->text == NULL ) + { + if( item->cvar == NULL ) + return; + else + { + DC->getCVarString( item->cvar, text, sizeof( text ) ); + textPtr = text; + } + } + else + textPtr = item->text; + + if( *textPtr == '\0' ) + return; + + Item_TextColor( item, &color ); + + // Check if this block is cached + if( useWrapCache && UI_CheckWrapCache( textPtr, &item->window.rect, item->textscale ) ) + { + while( UI_NextWrapLine( &p, &x, &y ) ) + { + UI_Text_Paint( x, y, item->textscale, color, + p, 0, 0, item->textStyle ); + } + } + else + { + char buff[ 1024 ]; + float fontHeight = UI_Text_EmHeight( item->textscale ); + const float lineSpacing = fontHeight * 0.4f; + float lineHeight = fontHeight + lineSpacing; + float textHeight; + int textLength; + int paintLines, totalLines, lineNum = 0; + float paintY; + int i; + + if( useWrapCache ) + UI_CreateCacheEntry( textPtr, &item->window.rect, item->textscale ); + + x = item->window.rect.x + item->textalignx; + y = item->window.rect.y + item->textaligny; + w = item->window.rect.w - ( 2.0f * item->textalignx ); + h = item->window.rect.h - ( 2.0f * item->textaligny ); + + textPtr = Item_Text_Wrap( textPtr, item->textscale, w ); + textLength = strlen( textPtr ); + + // Count lines + totalLines = 0; + + for( i = 0; i < textLength; i++ ) + { + if( textPtr[ i ] == '\n' ) + totalLines++; + } + + paintLines = ( int )floor( ( h + lineSpacing ) / lineHeight ); + + if( paintLines > totalLines ) + paintLines = totalLines; + + textHeight = ( paintLines * lineHeight ) - lineSpacing; + + switch( item->textvalignment ) + { + default: + + case VALIGN_BOTTOM: + paintY = y + ( h - textHeight ); + break; + + case VALIGN_CENTER: + paintY = y + ( ( h - textHeight ) / 2.0f ); + break; + + case VALIGN_TOP: + paintY = y; + break; + } + + p = textPtr; + + for( i = 0, lineNum = 0; i < textLength && lineNum < paintLines; i++ ) + { + int lineLength = &textPtr[ i ] - p; + + if( lineLength >= sizeof( buff ) - 1 ) + break; + + if( textPtr[ i ] == '\n' || textPtr[ i ] == '\0' ) + { + itemDef_t lineItem; + + memset( &lineItem, 0, sizeof( itemDef_t ) ); + strncpy( buff, p, lineLength ); + buff[ lineLength ] = '\0'; + p = &textPtr[ i + 1 ]; + + lineItem.type = ITEM_TYPE_TEXT; + lineItem.textscale = item->textscale; + lineItem.textStyle = item->textStyle; + lineItem.text = buff; + lineItem.textalignment = item->textalignment; + lineItem.textvalignment = VALIGN_TOP; + lineItem.textalignx = 0.0f; + lineItem.textaligny = 0.0f; + + lineItem.textRect.w = 0.0f; + lineItem.textRect.h = 0.0f; + lineItem.window.rect.x = x; + lineItem.window.rect.y = paintY + ( lineNum * lineHeight ); + lineItem.window.rect.w = w; + lineItem.window.rect.h = lineHeight; + lineItem.window.border = item->window.border; + lineItem.window.borderSize = item->window.borderSize; + + if( DC->getCVarValue( "ui_developer" ) ) + { + vec4_t color; + color[ 0 ] = color[ 2 ] = color[ 3 ] = 1.0f; + color[ 1 ] = 0.0f; + DC->drawRect( lineItem.window.rect.x, lineItem.window.rect.y, + lineItem.window.rect.w, lineItem.window.rect.h, 1, color ); + } + + Item_SetTextExtents( &lineItem, buff ); + UI_Text_Paint( lineItem.textRect.x, lineItem.textRect.y, + lineItem.textscale, color, buff, 0, 0, + lineItem.textStyle ); + + if( useWrapCache ) + UI_AddCacheEntryLine( buff, lineItem.textRect.x, lineItem.textRect.y ); + + lineNum++; + } + } + + if( useWrapCache ) + UI_FinishCacheEntry( ); + } +} + +/* +============== +UI_DrawTextBlock +============== +*/ +void UI_DrawTextBlock( rectDef_t *rect, float text_x, float text_y, vec4_t color, + float scale, int textalign, int textvalign, + int textStyle, const char *text ) +{ + static menuDef_t dummyParent; + static itemDef_t textItem; + + textItem.text = text; + + textItem.parent = &dummyParent; + memcpy( textItem.window.foreColor, color, sizeof( vec4_t ) ); + textItem.window.flags = 0; + + textItem.window.rect.x = rect->x; + textItem.window.rect.y = rect->y; + textItem.window.rect.w = rect->w; + textItem.window.rect.h = rect->h; + textItem.window.border = 0; + textItem.window.borderSize = 0.0f; + textItem.textRect.x = 0.0f; + textItem.textRect.y = 0.0f; + textItem.textRect.w = 0.0f; + textItem.textRect.h = 0.0f; + textItem.textalignment = textalign; + textItem.textvalignment = textvalign; + textItem.textalignx = text_x; + textItem.textaligny = text_y; + textItem.textscale = scale; + textItem.textStyle = textStyle; + + // Utilise existing wrap code + Item_Text_Wrapped_Paint( &textItem ); +} + +void Item_Text_Paint( itemDef_t *item ) +{ + char text[1024]; + const char *textPtr; + vec4_t color; + + if( item->window.flags & WINDOW_WRAPPED ) + { + Item_Text_Wrapped_Paint( item ); + return; + } + + if( item->text == NULL ) + { + if( item->cvar == NULL ) + return; + else + { + DC->getCVarString( item->cvar, text, sizeof( text ) ); + textPtr = text; + } + } + else + textPtr = item->text; + + // this needs to go here as it sets extents for cvar types as well + Item_SetTextExtents( item, textPtr ); + + if( *textPtr == '\0' ) + return; + + Item_TextColor( item, &color ); + + UI_Text_Paint( item->textRect.x, item->textRect.y, item->textscale, color, textPtr, 0, 0, item->textStyle ); +} + + + +void Item_TextField_Paint( itemDef_t *item ) +{ + char buff[1024]; + vec4_t newColor; + int offset = ( item->text && *item->text ) ? ITEM_VALUE_OFFSET : 0; + menuDef_t *parent = ( menuDef_t* )item->parent; + editFieldDef_t *editPtr = item->typeData.edit; + char cursor = DC->getOverstrikeMode() ? '|' : '_'; + qboolean editing = ( item->window.flags & WINDOW_HASFOCUS && g_editingField ); + const int cursorWidth = editing ? EDIT_CURSOR_WIDTH : 0; + + //FIXME: causes duplicate printing if item->text is not set (NULL) + Item_Text_Paint( item ); + + buff[0] = '\0'; + + if( item->cvar ) + DC->getCVarString( item->cvar, buff, sizeof( buff ) ); + + // maxFieldWidth hasn't been set, so use the item's rect + if( editPtr->maxFieldWidth == 0 ) + { + editPtr->maxFieldWidth = item->window.rect.w - + ( item->textRect.w + offset + ( item->textRect.x - item->window.rect.x ) ); + + if( editPtr->maxFieldWidth < MIN_FIELD_WIDTH ) + editPtr->maxFieldWidth = MIN_FIELD_WIDTH; + } + + if( !editing ) + editPtr->paintOffset = 0; + + // Shorten string to max viewable + while( UI_Text_Width( buff + editPtr->paintOffset, item->textscale ) > + ( editPtr->maxFieldWidth - cursorWidth ) && strlen( buff ) > 0 ) + buff[ strlen( buff ) - 1 ] = '\0'; + + parent = ( menuDef_t* )item->parent; + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + if( editing ) + { + UI_Text_PaintWithCursor( item->textRect.x + item->textRect.w + offset, + item->textRect.y, item->textscale, newColor, + buff + editPtr->paintOffset, + item->cursorPos - editPtr->paintOffset, + cursor, editPtr->maxPaintChars, item->textStyle ); + } + else + { + UI_Text_Paint( item->textRect.x + item->textRect.w + offset, + item->textRect.y, item->textscale, newColor, + buff + editPtr->paintOffset, 0, + editPtr->maxPaintChars, item->textStyle ); + } + +} + +void Item_YesNo_Paint( itemDef_t *item ) +{ + vec4_t newColor; + float value; + int offset; + menuDef_t *parent = ( menuDef_t* )item->parent; + + value = ( item->cvar ) ? DC->getCVarValue( item->cvar ) : 0; + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + offset = ( item->text && *item->text ) ? ITEM_VALUE_OFFSET : 0; + + if( item->text ) + { + Item_Text_Paint( item ); + UI_Text_Paint( item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textscale, + newColor, ( value != 0 ) ? "Yes" : "No", 0, 0, item->textStyle ); + } + else + UI_Text_Paint( item->textRect.x, item->textRect.y, item->textscale, newColor, ( value != 0 ) ? "Yes" : "No", 0, 0, item->textStyle ); +} + +void Item_Multi_Paint( itemDef_t *item ) +{ + vec4_t newColor; + const char *text = ""; + menuDef_t *parent = ( menuDef_t* )item->parent; + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + text = Item_Multi_Setting( item ); + + if( item->text ) + { + Item_Text_Paint( item ); + UI_Text_Paint( item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET, item->textRect.y, + item->textscale, newColor, text, 0, 0, item->textStyle ); + } + else + UI_Text_Paint( item->textRect.x, item->textRect.y, item->textscale, newColor, text, 0, 0, item->textStyle ); +} + +void Item_Cycle_Paint( itemDef_t *item ) +{ + vec4_t newColor; + const char *text = ""; + menuDef_t *parent = (menuDef_t *)item->parent; + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + if( item->typeData.cycle ) + text = DC->feederItemText( item->feederID, item->typeData.cycle->cursorPos, + 0, NULL ); + + if( item->text ) + { + Item_Text_Paint( item ); + UI_Text_Paint( item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET, item->textRect.y, + item->textscale, newColor, text, 0, 0, item->textStyle ); + } + else + UI_Text_Paint( item->textRect.x, item->textRect.y, item->textscale, newColor, text, 0, 0, item->textStyle ); +} + + +typedef struct +{ + char *command; + int id; + int defaultbind1; + int defaultbind2; + int bind1; + int bind2; +} +bind_t; + +typedef struct +{ + char *name; + float defaultvalue; + float value; +} +configcvar_t; + + +static bind_t g_bindings[] = + { + { "+scores", K_TAB, -1, -1, -1 }, + { "+button2", K_ENTER, -1, -1, -1 }, + { "+speed", K_SHIFT, -1, -1, -1 }, + { "+button6", 'z', -1, -1, -1 }, // human dodging + { "+button8", 'x', -1, -1, -1 }, + { "+forward", K_UPARROW, -1, -1, -1 }, + { "+back", K_DOWNARROW, -1, -1, -1 }, + { "+moveleft", ',', -1, -1, -1 }, + { "+moveright", '.', -1, -1, -1 }, + { "+moveup", K_SPACE, -1, -1, -1 }, + { "+movedown", 'c', -1, -1, -1 }, + { "+left", K_LEFTARROW, -1, -1, -1 }, + { "+right", K_RIGHTARROW, -1, -1, -1 }, + { "+strafe", K_ALT, -1, -1, -1 }, + { "+lookup", K_PGDN, -1, -1, -1 }, + { "+lookdown", K_DEL, -1, -1, -1 }, + { "+mlook", '/', -1, -1, -1 }, + { "centerview", K_END, -1, -1, -1 }, + { "+zoom", -1, -1, -1, -1 }, + { "weapon 1", '1', -1, -1, -1 }, + { "weapon 2", '2', -1, -1, -1 }, + { "weapon 3", '3', -1, -1, -1 }, + { "weapon 4", '4', -1, -1, -1 }, + { "weapon 5", '5', -1, -1, -1 }, + { "weapon 6", '6', -1, -1, -1 }, + { "weapon 7", '7', -1, -1, -1 }, + { "weapon 8", '8', -1, -1, -1 }, + { "weapon 9", '9', -1, -1, -1 }, + { "weapon 10", '0', -1, -1, -1 }, + { "weapon 11", -1, -1, -1, -1 }, + { "weapon 12", -1, -1, -1, -1 }, + { "weapon 13", -1, -1, -1, -1 }, + { "+attack", K_MOUSE1, -1, -1, -1 }, + { "+button5", K_MOUSE2, -1, -1, -1 }, // secondary attack + { "reload", 'r', -1, -1, -1 }, // reload + { "buy ammo", 'b', -1, -1, -1 }, // buy ammo + { "itemact medkit", 'm', -1, -1, -1 }, // use medkit + { "+button7", 'q', -1, -1, -1 }, // buildable use + { "deconstruct", 'e', -1, -1, -1 }, // buildable destroy + { "weapprev", '[', -1, -1, -1 }, + { "weapnext", ']', -1, -1, -1 }, + { "+button3", K_MOUSE3, -1, -1, -1 }, + { "+button4", K_MOUSE4, -1, -1, -1 }, + { "vote yes", K_F1, -1, -1, -1 }, + { "vote no", K_F2, -1, -1, -1 }, + { "teamvote yes", K_F3, -1, -1, -1 }, + { "teamvote no", K_F4, -1, -1, -1 }, + { "scoresUp", K_KP_PGUP, -1, -1, -1 }, + { "scoresDown", K_KP_PGDN, -1, -1, -1 }, + { "screenshotJPEG",-1, -1, -1, -1 }, + { "messagemode", -1, -1, -1, -1 }, + { "messagemode2", -1, -1, -1, -1 }, + { "cuboidAxis next", 'h', -1, -1, -1 }, + { "cuboidRotate", 'j', -1, -1, -1 } + }; + + +static const int g_bindCount = sizeof( g_bindings ) / sizeof( bind_t ); + +/* +================= +Controls_GetKeyAssignment +================= +*/ +static void Controls_GetKeyAssignment ( char *command, int *twokeys ) +{ + int count; + int j; + char b[256]; + + twokeys[0] = twokeys[1] = -1; + count = 0; + + for( j = 0; j < 256; j++ ) + { + DC->getBindingBuf( j, b, 256 ); + + if( *b == 0 ) + continue; + + if( !Q_stricmp( b, command ) ) + { + twokeys[count] = j; + count++; + + if( count == 2 ) + break; + } + } +} + +/* +================= +Controls_GetConfig +================= +*/ +void Controls_GetConfig( void ) +{ + int i; + int twokeys[ 2 ]; + + // iterate each command, get its numeric binding + + for( i = 0; i < g_bindCount; i++ ) + { + Controls_GetKeyAssignment( g_bindings[ i ].command, twokeys ); + + g_bindings[ i ].bind1 = twokeys[ 0 ]; + g_bindings[ i ].bind2 = twokeys[ 1 ]; + } +} + +/* +================= +Controls_SetConfig +================= +*/ +void Controls_SetConfig( qboolean restart ) +{ + int i; + + // iterate each command, get its numeric binding + + for( i = 0; i < g_bindCount; i++ ) + { + if( g_bindings[i].bind1 != -1 ) + { + DC->setBinding( g_bindings[i].bind1, g_bindings[i].command ); + + if( g_bindings[i].bind2 != -1 ) + DC->setBinding( g_bindings[i].bind2, g_bindings[i].command ); + } + } + + DC->executeText( EXEC_APPEND, "in_restart\n" ); +} + +/* +================= +Controls_SetDefaults +================= +*/ +void Controls_SetDefaults( void ) +{ + int i; + + // iterate each command, set its default binding + + for( i = 0; i < g_bindCount; i++ ) + { + g_bindings[i].bind1 = g_bindings[i].defaultbind1; + g_bindings[i].bind2 = g_bindings[i].defaultbind2; + } +} + +int BindingIDFromName( const char *name ) +{ + int i; + + for( i = 0; i < g_bindCount; i++ ) + { + if( Q_stricmp( name, g_bindings[i].command ) == 0 ) + return i; + } + + return -1; +} + +char g_nameBind1[32]; +char g_nameBind2[32]; + +void BindingFromName( const char *cvar ) +{ + int i, b1, b2; + + // iterate each command, set its default binding + + for( i = 0; i < g_bindCount; i++ ) + { + if( Q_stricmp( cvar, g_bindings[i].command ) == 0 ) + { + b1 = g_bindings[i].bind1; + + if( b1 == -1 ) + break; + + DC->keynumToStringBuf( b1, g_nameBind1, 32 ); + Q_strupr( g_nameBind1 ); + + b2 = g_bindings[i].bind2; + + if( b2 != -1 ) + { + DC->keynumToStringBuf( b2, g_nameBind2, 32 ); + Q_strupr( g_nameBind2 ); + strcat( g_nameBind1, " or " ); + strcat( g_nameBind1, g_nameBind2 ); + } + + return; + } + } + + strcpy( g_nameBind1, "???" ); +} + +void Item_Slider_Paint( itemDef_t *item ) +{ + vec4_t newColor; + float x, y, value; + menuDef_t *parent = ( menuDef_t* )item->parent; + float vScale = Item_Slider_VScale( item ); + + value = ( item->cvar ) ? DC->getCVarValue( item->cvar ) : 0; + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( newColor, &parent->focusColor, sizeof( vec4_t ) ); + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + if( item->text ) + { + Item_Text_Paint( item ); + x = item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET; + y = item->textRect.y - item->textRect.h + + ( ( item->textRect.h - ( SLIDER_HEIGHT * vScale ) ) / 2.0f ); + } + else + { + x = item->window.rect.x; + y = item->window.rect.y; + } + + DC->setColor( newColor ); + DC->drawHandlePic( x, y, SLIDER_WIDTH, SLIDER_HEIGHT * vScale, DC->Assets.sliderBar ); + + y = item->textRect.y - item->textRect.h + + ( ( item->textRect.h - ( SLIDER_THUMB_HEIGHT * vScale ) ) / 2.0f ); + + x = Item_Slider_ThumbPosition( item ); + DC->drawHandlePic( x - ( SLIDER_THUMB_WIDTH / 2 ), y, + SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT * vScale, DC->Assets.sliderThumb ); + +} + +void Item_Bind_Paint( itemDef_t *item ) +{ + vec4_t newColor, lowLight; + float value; + int maxChars = 0; + menuDef_t *parent = ( menuDef_t* )item->parent; + + if( item->typeData.edit ) + maxChars = item->typeData.edit->maxPaintChars; + + value = ( item->cvar ) ? DC->getCVarValue( item->cvar ) : 0; + + if( item->window.flags & WINDOW_HASFOCUS ) + { + if( g_bindItem == item ) + { + lowLight[0] = 0.8f * parent->focusColor[0]; + lowLight[1] = 0.8f * parent->focusColor[1]; + lowLight[2] = 0.8f * parent->focusColor[2]; + lowLight[3] = 0.8f * parent->focusColor[3]; + + LerpColor( parent->focusColor, lowLight, newColor, + 0.5 + 0.5 * sin( DC->realTime / PULSE_DIVISOR ) ); + } + else + memcpy( &newColor, &parent->focusColor, sizeof( vec4_t ) ); + } + else + memcpy( &newColor, &item->window.foreColor, sizeof( vec4_t ) ); + + if( item->text ) + { + Item_Text_Paint( item ); + + if( g_bindItem == item && g_waitingForKey ) + { + UI_Text_Paint( item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET, item->textRect.y, + item->textscale, newColor, "Press key", 0, maxChars, item->textStyle ); + } + else + { + BindingFromName( item->cvar ); + UI_Text_Paint( item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET, item->textRect.y, + item->textscale, newColor, g_nameBind1, 0, maxChars, item->textStyle ); + } + } + else + UI_Text_Paint( item->textRect.x, item->textRect.y, item->textscale, newColor, + ( value != 0 ) ? "FIXME" : "FIXME", 0, maxChars, item->textStyle ); +} + +qboolean Display_KeyBindPending( void ) +{ + return g_waitingForKey; +} + +qboolean Item_Bind_HandleKey( itemDef_t *item, int key, qboolean down ) +{ + int id; + int i; + + if( Rect_ContainsPoint( &item->window.rect, DC->cursorx, DC->cursory ) && !g_waitingForKey ) + { + if( down && ( key == K_MOUSE1 || key == K_ENTER ) ) + { + g_waitingForKey = qtrue; + g_bindItem = item; + } + + return qtrue; + } + else + { + if( !g_waitingForKey || g_bindItem == NULL ) + return qtrue; + + if( key & K_CHAR_FLAG ) + return qtrue; + + switch( key ) + { + case K_ESCAPE: + g_waitingForKey = qfalse; + return qtrue; + + case K_BACKSPACE: + id = BindingIDFromName( item->cvar ); + + if( id != -1 ) + { + g_bindings[id].bind1 = -1; + g_bindings[id].bind2 = -1; + } + + Controls_SetConfig( qtrue ); + g_waitingForKey = qfalse; + g_bindItem = NULL; + return qtrue; + + case '`': + return qtrue; + } + } + + if( key != -1 ) + { + for( i = 0; i < g_bindCount; i++ ) + { + if( g_bindings[i].bind2 == key ) + g_bindings[i].bind2 = -1; + + if( g_bindings[i].bind1 == key ) + { + g_bindings[i].bind1 = g_bindings[i].bind2; + g_bindings[i].bind2 = -1; + } + } + } + + + id = BindingIDFromName( item->cvar ); + + if( id != -1 ) + { + if( key == -1 ) + { + if( g_bindings[id].bind1 != -1 ) + { + DC->setBinding( g_bindings[id].bind1, "" ); + g_bindings[id].bind1 = -1; + } + + if( g_bindings[id].bind2 != -1 ) + { + DC->setBinding( g_bindings[id].bind2, "" ); + g_bindings[id].bind2 = -1; + } + } + else if( g_bindings[id].bind1 == -1 ) + g_bindings[id].bind1 = key; + else if( g_bindings[id].bind1 != key && g_bindings[id].bind2 == -1 ) + g_bindings[id].bind2 = key; + else + { + DC->setBinding( g_bindings[id].bind1, "" ); + DC->setBinding( g_bindings[id].bind2, "" ); + g_bindings[id].bind1 = key; + g_bindings[id].bind2 = -1; + } + } + + Controls_SetConfig( qtrue ); + g_waitingForKey = qfalse; + + return qtrue; +} + + +void Item_Model_Paint( itemDef_t *item ) +{ + float x, y, w, h; + refdef_t refdef; + refEntity_t ent; + vec3_t mins, maxs, origin; + vec3_t angles; + modelDef_t *modelPtr = item->typeData.model; + + if( modelPtr == NULL ) + return; + + // setup the refdef + memset( &refdef, 0, sizeof( refdef ) ); + + refdef.rdflags = RDF_NOWORLDMODEL; + + AxisClear( refdef.viewaxis ); + + x = item->window.rect.x + 1; + y = item->window.rect.y + 1; + w = item->window.rect.w - 2; + h = item->window.rect.h - 2; + + UI_AdjustFrom640( &x, &y, &w, &h ); + + refdef.x = x; + refdef.y = y; + refdef.width = w; + refdef.height = h; + + DC->modelBounds( item->asset, mins, maxs ); + + origin[2] = -0.5 * ( mins[2] + maxs[2] ); + origin[1] = 0.5 * ( mins[1] + maxs[1] ); + + // calculate distance so the model nearly fills the box + if( qtrue ) + { + float len = 0.5 * ( maxs[2] - mins[2] ); + origin[0] = len / 0.268; // len / tan( fov/2 ) + //origin[0] = len / tan(w/2); + } + else + origin[0] = item->textscale; + + refdef.fov_x = ( modelPtr->fov_x ) ? modelPtr->fov_x : w; + refdef.fov_y = ( modelPtr->fov_y ) ? modelPtr->fov_y : h; + + //refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f); + //xx = refdef.width / tan( refdef.fov_x / 360 * M_PI ); + //refdef.fov_y = atan2( refdef.height, xx ); + //refdef.fov_y *= ( 360 / M_PI ); + + DC->clearScene(); + + refdef.time = DC->realTime; + + // add the model + + memset( &ent, 0, sizeof( ent ) ); + + //adjust = 5.0 * sin( (float)uis.realtime / 500 ); + //adjust = 360 % (int)((float)uis.realtime / 1000); + //VectorSet( angles, 0, 0, 1 ); + + // use item storage to track + + if( modelPtr->rotationSpeed ) + { + if( DC->realTime > item->window.nextTime ) + { + item->window.nextTime = DC->realTime + modelPtr->rotationSpeed; + modelPtr->angle = ( int )( modelPtr->angle + 1 ) % 360; + } + } + + VectorSet( angles, 0, modelPtr->angle, 0 ); + AnglesToAxis( angles, ent.axis ); + + ent.hModel = item->asset; + VectorCopy( origin, ent.origin ); + VectorCopy( origin, ent.lightingOrigin ); + ent.renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW; + VectorCopy( ent.origin, ent.oldorigin ); + + DC->addRefEntityToScene( &ent ); + DC->renderScene( &refdef ); + +} + + +void Item_ListBoxRow_Paint( itemDef_t *item, int row, int renderPos, qboolean highlight, qboolean scrollbar ) +{ + float x, y, w; + listBoxDef_t *listPtr = item->typeData.list; + menuDef_t *menu = ( menuDef_t * )item->parent; + float one, two; + + one = 1.0f * DC->aspectScale; + two = 2.0f * DC->aspectScale; + + x = SCROLLBAR_X( item ); + y = SCROLLBAR_Y( item ) + ( listPtr->elementHeight * renderPos ); + w = item->window.rect.w - ( two * item->window.borderSize ); + + if( scrollbar ) + w -= SCROLLBAR_ARROW_WIDTH; + + if( listPtr->elementStyle == LISTBOX_IMAGE ) + { + qhandle_t image = DC->feederItemImage( item->feederID, row ); + + UI_SetClipRegion( x, y, listPtr->elementWidth, listPtr->elementHeight ); + + if( image ) + DC->drawHandlePic( x + one, y + 1.0f, listPtr->elementWidth - two, listPtr->elementHeight - 2.0f, image ); + + if( highlight && row == item->cursorPos ) + { + DC->drawRect( x, y, listPtr->elementWidth, listPtr->elementHeight, + item->window.borderSize, item->window.borderColor ); + } + + UI_ClearClipRegion( ); + } + else + { + const float m = UI_Text_EmHeight( item->textscale ); + char text[ MAX_STRING_CHARS ]; + qhandle_t optionalImage; + + if( listPtr->numColumns > 0 ) + { + int j; + + for( j = 0; j < listPtr->numColumns; j++ ) + { + float columnPos; + float width, height, yOffset; + + if( menu->window.aspectBias != ASPECT_NONE || item->window.aspectBias != ASPECT_NONE ) + { + columnPos = ( listPtr->columnInfo[ j ].pos + 4.0f ) * DC->aspectScale; + width = listPtr->columnInfo[ j ].width * DC->aspectScale; + } + else + { + columnPos = ( listPtr->columnInfo[ j ].pos + 4.0f ); + width = listPtr->columnInfo[ j ].width; + } + + height = listPtr->columnInfo[ j ].width; + yOffset = y + ( ( listPtr->elementHeight - height ) / 2.0f ); + + Q_strncpyz( text, DC->feederItemText( item->feederID, row, j, &optionalImage ), sizeof( text ) ); + + UI_SetClipRegion( x + columnPos, yOffset, width, height ); + + if( optionalImage >= 0 ) + DC->drawHandlePic( x + columnPos, yOffset, width, height, optionalImage ); + else if( text[ 0 ] ) + { + float alignOffset = 0.0f, tw; + + tw = UI_Text_Width( text, item->textscale ); + + switch( listPtr->columnInfo[ j ].align ) + { + case ALIGN_LEFT: + alignOffset = 0.0f; + break; + + case ALIGN_RIGHT: + alignOffset = width - tw; + break; + + case ALIGN_CENTER: + alignOffset = ( width / 2.0f ) - ( tw / 2.0f ); + break; + + default: + alignOffset = 0.0f; + } + + UI_Text_Paint( x + columnPos + alignOffset, + y + m + ( ( listPtr->elementHeight - m ) / 2.0f ), + item->textscale, item->window.foreColor, text, 0, + 0, item->textStyle ); + } + + UI_ClearClipRegion( ); + } + } + else + { + float offset; + + if( menu->window.aspectBias != ASPECT_NONE || item->window.aspectBias != ASPECT_NONE ) + offset = 4.0f * DC->aspectScale; + else + offset = 4.0f; + + Q_strncpyz( text, DC->feederItemText( item->feederID, row, 0, &optionalImage ), sizeof( text ) ); + + UI_SetClipRegion( x, y, w, listPtr->elementHeight ); + + if( optionalImage >= 0 ) + DC->drawHandlePic( x + offset, y, listPtr->elementHeight, listPtr->elementHeight, optionalImage ); + else if( text[ 0 ] ) + { + UI_Text_Paint( x + offset, y + m + ( ( listPtr->elementHeight - m ) / 2.0f ), + item->textscale, item->window.foreColor, text, 0, + 0, item->textStyle ); + } + + UI_ClearClipRegion( ); + } + + if( highlight && row == item->cursorPos ) + DC->fillRect( x, y, w, listPtr->elementHeight, item->window.outlineColor ); + } +} + +void Item_ListBox_Paint( itemDef_t *item ) +{ + float size; + int i; + listBoxDef_t *listPtr = item->typeData.list; + int count = DC->feederCount( item->feederID ); + qboolean scrollbar = !listPtr->noscrollbar && + count > Item_ListBox_NumItemsForItemHeight( item ); + + if( scrollbar ) + { + float x = SCROLLBAR_SLIDER_X( item ); + float y = SCROLLBAR_Y( item ); + float thumbY = Item_ListBox_ThumbDrawPosition( item ); + + // Up arrow + DC->drawHandlePic( x, y, SCROLLBAR_ARROW_WIDTH, SCROLLBAR_ARROW_HEIGHT, DC->Assets.scrollBarArrowUp ); + y = SCROLLBAR_SLIDER_Y( item ); + + // Scroll bar + size = SCROLLBAR_SLIDER_HEIGHT( item ); + DC->drawHandlePic( x, y, SCROLLBAR_ARROW_WIDTH, size, DC->Assets.scrollBar ); + y = SCROLLBAR_SLIDER_Y( item ) + size; + + // Down arrow + DC->drawHandlePic( x, y, SCROLLBAR_ARROW_WIDTH, SCROLLBAR_ARROW_HEIGHT, DC->Assets.scrollBarArrowDown ); + + // Thumb + DC->drawHandlePic( x, thumbY, SCROLLBAR_ARROW_WIDTH, SCROLLBAR_ARROW_HEIGHT, DC->Assets.scrollBarThumb ); + } + + // Paint rows + for( i = listPtr->startPos; i < listPtr->endPos; i++ ) + Item_ListBoxRow_Paint( item, i, i - listPtr->startPos, qtrue, scrollbar ); +} + +void Item_Paint( itemDef_t *item ); + +void Item_ComboBox_Paint( itemDef_t *item ) +{ + float x, y, h; + + x = SCROLLBAR_SLIDER_X( item ); + y = SCROLLBAR_Y( item ); + h = item->window.rect.h - 2.0f; + + // Down arrow + DC->drawHandlePic( x, y, SCROLLBAR_ARROW_WIDTH, h, DC->Assets.scrollBarArrowDown ); + + Item_ListBoxRow_Paint( item, item->cursorPos, 0, qfalse, qtrue ); + + if( g_comboBoxItem != NULL ) + { + qboolean cast = Item_ComboBox_MaybeCastToListBox( item ); + Item_Paint( item ); + Item_ComboBox_MaybeUnCastFromListBox( item, cast ); + } +} + +void Item_ListBox_Update( itemDef_t *item ) +{ + listBoxDef_t *listPtr = item->typeData.list; + int feederCount = DC->feederCount( item->feederID ); + + if( listPtr->lastFeederCount != feederCount ) + { + if( listPtr->resetonfeederchange ) + { + item->cursorPos = DC->feederInitialise( item->feederID ); + Item_ListBox_SetStartPos( item, 0 ); + DC->feederSelection( item->feederID, item->cursorPos ); + } + else + { + // Make sure endPos is up-to-date + Item_ListBox_SetStartPos( item, listPtr->startPos ); + + // If the selection is off the end now, select the last element + if( item->cursorPos >= feederCount ) + item->cursorPos = feederCount - 1; + } + } + + listPtr->lastFeederCount = feederCount; +} + +void Item_OwnerDraw_Paint( itemDef_t *item ) +{ + menuDef_t *parent; + const char *text; + + if( item == NULL ) + return; + + parent = ( menuDef_t* )item->parent; + + if( DC->ownerDrawItem ) + { + vec4_t color, lowLight; + menuDef_t *parent = ( menuDef_t* )item->parent; + Fade( &item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, + parent->fadeCycle, qtrue, parent->fadeAmount ); + memcpy( &color, &item->window.foreColor, sizeof( color ) ); + + if( item->numColors > 0 && DC->getValue ) + { + // if the value is within one of the ranges then set color to that, otherwise leave at default + int i; + float f = DC->getValue( item->window.ownerDraw ); + + for( i = 0; i < item->numColors; i++ ) + { + if( f >= item->colorRanges[i].low && f <= item->colorRanges[i].high ) + { + memcpy( &color, &item->colorRanges[i].color, sizeof( color ) ); + break; + } + } + } + + if( item->window.flags & WINDOW_HASFOCUS ) + memcpy( color, &parent->focusColor, sizeof( vec4_t ) ); + else if( item->textStyle == ITEM_TEXTSTYLE_BLINK && !( ( DC->realTime / BLINK_DIVISOR ) & 1 ) ) + { + lowLight[0] = 0.8 * item->window.foreColor[0]; + lowLight[1] = 0.8 * item->window.foreColor[1]; + lowLight[2] = 0.8 * item->window.foreColor[2]; + lowLight[3] = 0.8 * item->window.foreColor[3]; + LerpColor( item->window.foreColor, lowLight, color, 0.5 + 0.5 * sin( DC->realTime / PULSE_DIVISOR ) ); + } + + if( item->cvarFlags & ( CVAR_ENABLE | CVAR_DISABLE ) && !Item_EnableShowViaCvar( item, CVAR_ENABLE ) ) + Com_Memcpy( color, parent->disableColor, sizeof( vec4_t ) ); + + if( DC->ownerDrawText && ( text = DC->ownerDrawText( item->window.ownerDraw ) ) ) + { + if( item->text && *item->text ) + { + Item_Text_Paint( item ); + + UI_Text_Paint( item->textRect.x + item->textRect.w + ITEM_VALUE_OFFSET, + item->textRect.y, item->textscale, + color, text, 0, 0, item->textStyle ); + } + else + { + item->text = text; + Item_Text_Paint( item ); + item->text = NULL; + } + } + else + { + DC->ownerDrawItem( item->window.rect.x, item->window.rect.y, + item->window.rect.w, item->window.rect.h, + item->textalignx, item->textaligny, + item->window.ownerDraw, item->window.ownerDrawFlags, + item->alignment, item->textalignment, item->textvalignment, + item->window.borderSize, item->textscale, color, item->window.backColor, + item->window.background, item->textStyle ); + } + } +} + + +void Item_Update( itemDef_t *item ) +{ + if( item == NULL ) + return; + + if( Item_IsListBox( item ) ) + Item_ListBox_Update( item ); +} + +void Item_Paint( itemDef_t *item ) +{ + vec4_t red; + menuDef_t *parent = ( menuDef_t* )item->parent; + red[0] = red[3] = 1; + red[1] = red[2] = 0; + + if( item == NULL ) + return; + + if( item->window.flags & WINDOW_ORBITING ) + { + if( DC->realTime > item->window.nextTime ) + { + float rx, ry, a, c, s, w, h; + + item->window.nextTime = DC->realTime + item->window.offsetTime; + // translate + w = item->window.rectClient.w / 2; + h = item->window.rectClient.h / 2; + rx = item->window.rectClient.x + w - item->window.rectEffects.x; + ry = item->window.rectClient.y + h - item->window.rectEffects.y; + a = 3 * M_PI / 180; + c = cos( a ); + s = sin( a ); + item->window.rectClient.x = ( rx * c - ry * s ) + item->window.rectEffects.x - w; + item->window.rectClient.y = ( rx * s + ry * c ) + item->window.rectEffects.y - h; + Item_UpdatePosition( item ); + + } + } + + + if( item->window.flags & WINDOW_INTRANSITION ) + { + if( DC->realTime > item->window.nextTime ) + { + int done = 0; + item->window.nextTime = DC->realTime + item->window.offsetTime; + // transition the x,y + + if( item->window.rectClient.x == item->window.rectEffects.x ) + done++; + else + { + if( item->window.rectClient.x < item->window.rectEffects.x ) + { + item->window.rectClient.x += item->window.rectEffects2.x; + + if( item->window.rectClient.x > item->window.rectEffects.x ) + { + item->window.rectClient.x = item->window.rectEffects.x; + done++; + } + } + else + { + item->window.rectClient.x -= item->window.rectEffects2.x; + + if( item->window.rectClient.x < item->window.rectEffects.x ) + { + item->window.rectClient.x = item->window.rectEffects.x; + done++; + } + } + } + + if( item->window.rectClient.y == item->window.rectEffects.y ) + done++; + else + { + if( item->window.rectClient.y < item->window.rectEffects.y ) + { + item->window.rectClient.y += item->window.rectEffects2.y; + + if( item->window.rectClient.y > item->window.rectEffects.y ) + { + item->window.rectClient.y = item->window.rectEffects.y; + done++; + } + } + else + { + item->window.rectClient.y -= item->window.rectEffects2.y; + + if( item->window.rectClient.y < item->window.rectEffects.y ) + { + item->window.rectClient.y = item->window.rectEffects.y; + done++; + } + } + } + + if( item->window.rectClient.w == item->window.rectEffects.w ) + done++; + else + { + if( item->window.rectClient.w < item->window.rectEffects.w ) + { + item->window.rectClient.w += item->window.rectEffects2.w; + + if( item->window.rectClient.w > item->window.rectEffects.w ) + { + item->window.rectClient.w = item->window.rectEffects.w; + done++; + } + } + else + { + item->window.rectClient.w -= item->window.rectEffects2.w; + + if( item->window.rectClient.w < item->window.rectEffects.w ) + { + item->window.rectClient.w = item->window.rectEffects.w; + done++; + } + } + } + + if( item->window.rectClient.h == item->window.rectEffects.h ) + done++; + else + { + if( item->window.rectClient.h < item->window.rectEffects.h ) + { + item->window.rectClient.h += item->window.rectEffects2.h; + + if( item->window.rectClient.h > item->window.rectEffects.h ) + { + item->window.rectClient.h = item->window.rectEffects.h; + done++; + } + } + else + { + item->window.rectClient.h -= item->window.rectEffects2.h; + + if( item->window.rectClient.h < item->window.rectEffects.h ) + { + item->window.rectClient.h = item->window.rectEffects.h; + done++; + } + } + } + + Item_UpdatePosition( item ); + + if( done == 4 ) + item->window.flags &= ~WINDOW_INTRANSITION; + + } + } + + if( item->window.ownerDrawFlags && DC->ownerDrawVisible ) + { + if( !DC->ownerDrawVisible( item->window.ownerDrawFlags ) ) + item->window.flags &= ~WINDOW_VISIBLE; + else + item->window.flags |= WINDOW_VISIBLE; + } + + if( item->cvarFlags & ( CVAR_SHOW | CVAR_HIDE ) ) + { + if( !Item_EnableShowViaCvar( item, CVAR_SHOW ) ) + return; + } + + if( item->window.flags & WINDOW_TIMEDVISIBLE ) + { + } + + if( !( item->window.flags & WINDOW_VISIBLE ) ) + return; + + Window_Paint( &item->window, parent->fadeAmount, parent->fadeClamp, parent->fadeCycle ); + + if( DC->getCVarValue( "ui_developer" ) ) + { + vec4_t color; + rectDef_t *r = Item_CorrectedTextRect( item ); + color[1] = color[3] = 1; + color[0] = color[2] = 0; + DC->drawRect( r->x, r->y, r->w, r->h, 1, color ); + } + + switch( item->type ) + { + case ITEM_TYPE_OWNERDRAW: + Item_OwnerDraw_Paint( item ); + break; + + case ITEM_TYPE_TEXT: + case ITEM_TYPE_BUTTON: + Item_Text_Paint( item ); + break; + + case ITEM_TYPE_RADIOBUTTON: + break; + + case ITEM_TYPE_CHECKBOX: + break; + + case ITEM_TYPE_CYCLE: + Item_Cycle_Paint( item ); + break; + + case ITEM_TYPE_LISTBOX: + Item_ListBox_Paint( item ); + break; + + case ITEM_TYPE_COMBOBOX: + Item_ComboBox_Paint( item ); + break; + + case ITEM_TYPE_MODEL: + Item_Model_Paint( item ); + break; + + case ITEM_TYPE_YESNO: + Item_YesNo_Paint( item ); + break; + + case ITEM_TYPE_MULTI: + Item_Multi_Paint( item ); + break; + + case ITEM_TYPE_BIND: + Item_Bind_Paint( item ); + break; + + case ITEM_TYPE_SLIDER: + Item_Slider_Paint( item ); + break; + + default: + if( Item_IsEditField( item ) ) + Item_TextField_Paint( item ); + + break; + } + + Border_Paint( &item->window ); +} + +void Menu_Init( menuDef_t *menu ) +{ + memset( menu, 0, sizeof( menuDef_t ) ); + menu->cursorItem = -1; + menu->fadeAmount = DC->Assets.fadeAmount; + menu->fadeClamp = DC->Assets.fadeClamp; + menu->fadeCycle = DC->Assets.fadeCycle; + Window_Init( &menu->window ); + menu->window.aspectBias = ALIGN_CENTER; +} + +itemDef_t *Menu_GetFocusedItem( menuDef_t *menu ) +{ + int i; + + if( menu ) + { + for( i = 0; i < menu->itemCount; i++ ) + { + if( menu->items[i]->window.flags & WINDOW_HASFOCUS ) + return menu->items[i]; + } + } + + return NULL; +} + +menuDef_t *Menu_GetFocused( void ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + { + if( Menus[i].window.flags & WINDOW_HASFOCUS && Menus[i].window.flags & WINDOW_VISIBLE ) + return & Menus[i]; + } + + return NULL; +} + +void Menu_ScrollFeeder( menuDef_t *menu, int feeder, qboolean down ) +{ + if( menu ) + { + int i; + + for( i = 0; i < menu->itemCount; i++ ) + { + itemDef_t *item = menu->items[ i ]; + + if( item->feederID == feeder ) + { + qboolean cast = Item_ComboBox_MaybeCastToListBox( item ); + Item_ListBox_HandleKey( item, down ? K_DOWNARROW : K_UPARROW, qtrue, qtrue ); + Item_ComboBox_MaybeUnCastFromListBox( item, cast ); + + return; + } + } + } +} + + + +void Menu_SetFeederSelection( menuDef_t *menu, int feeder, int index, const char *name ) +{ + if( menu == NULL ) + { + if( name == NULL ) + menu = Menu_GetFocused(); + else + menu = Menus_FindByName( name ); + } + + if( menu ) + { + int i; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( menu->items[i]->feederID == feeder ) + { + if( Item_IsListBox( menu->items[i] ) && index == 0 ) + { + menu->items[ i ]->typeData.list->cursorPos = 0; + Item_ListBox_SetStartPos( menu->items[ i ], 0 ); + } + + menu->items[i]->cursorPos = index; + DC->feederSelection( menu->items[i]->feederID, menu->items[i]->cursorPos ); + return; + } + } + } +} + +qboolean Menus_AnyFullScreenVisible( void ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + { + if( Menus[i].window.flags & WINDOW_VISIBLE && Menus[i].fullScreen ) + return qtrue; + } + + return qfalse; +} + +menuDef_t *Menus_ActivateByName( const char *p ) +{ + int i; + menuDef_t *m = NULL; + + // Activate one menu + + for( i = 0; i < menuCount; i++ ) + { + if( Q_stricmp( Menus[i].window.name, p ) == 0 ) + { + m = &Menus[i]; + Menus_Activate( m ); + break; + } + } + + // Defocus the others + for( i = 0; i < menuCount; i++ ) + { + if( Q_stricmp( Menus[i].window.name, p ) != 0 ) + Menus[i].window.flags &= ~WINDOW_HASFOCUS; + } + + return m; +} + +menuDef_t *Menus_ReplaceActiveByName( const char *p ) +{ + int i; + menuDef_t *m = NULL; + + // Activate one menu + + for( i = 0; i < menuCount; i++ ) + { + if( Q_stricmp( Menus[i].window.name, p ) == 0 ) + { + m = &Menus[i]; + if(! Menus_ReplaceActive( m ) ) + return NULL; + break; + } + } + return m; +} + + +void Item_Init( itemDef_t *item ) +{ + memset( item, 0, sizeof( itemDef_t ) ); + item->textscale = 0.55f; + Window_Init( &item->window ); + item->window.aspectBias = ASPECT_NONE; +} + +static qboolean Item_HandleMouseMove( itemDef_t *item, float x, float y, int pass, qboolean focusSet ) +{ + if( Rect_ContainsPoint( &item->window.rect, x, y ) ) + { + if( pass == 1 ) + { + if( item->type == ITEM_TYPE_TEXT && item->text ) + { + if( !Rect_ContainsPoint( Item_CorrectedTextRect( item ), x, y ) ) + return qtrue; + } + + // if we are over an item + if( IsVisible( item->window.flags ) ) + { + // different one + Item_MouseEnter( item, x, y ); + + if( !focusSet ) + focusSet = Item_SetFocus( item, x, y ); + } + } + + return qtrue; + } + + return qfalse; +} + +void Menu_HandleMouseMove( menuDef_t *menu, float x, float y ) +{ + int i, pass; + qboolean focusSet = qfalse; + qboolean result; + qboolean cast; + + if( menu == NULL ) + return; + + if( !( menu->window.flags & ( WINDOW_VISIBLE | WINDOW_FORCED ) ) ) + return; + + if( itemCapture ) + { + //Item_MouseMove(itemCapture, x, y); + return; + } + + if( g_waitingForKey || g_editingField ) + return; + + if( g_comboBoxItem != NULL ) + { + Item_SetFocus( g_comboBoxItem, x, y ); + focusSet = qtrue; + } + + // FIXME: this is the whole issue of focus vs. mouse over.. + // need a better overall solution as i don't like going through everything twice + for( pass = 0; pass < 2; pass++ ) + { + for( i = 0; i < menu->itemCount; i++ ) + { + itemDef_t *item = menu->items[ i ]; + + // turn off focus each item + // menu->items[i].window.flags &= ~WINDOW_HASFOCUS; + + if( !( item->window.flags & ( WINDOW_VISIBLE | WINDOW_FORCED ) ) ) + continue; + + // items can be enabled and disabled based on cvars + if( item->cvarFlags & ( CVAR_ENABLE | CVAR_DISABLE ) && + !Item_EnableShowViaCvar( item, CVAR_ENABLE ) ) + continue; + + if( item->cvarFlags & ( CVAR_SHOW | CVAR_HIDE ) && + !Item_EnableShowViaCvar( item, CVAR_SHOW ) ) + continue; + + cast = Item_ComboBox_MaybeCastToListBox( item ); + result = Item_HandleMouseMove( item, x, y, pass, focusSet ); + Item_ComboBox_MaybeUnCastFromListBox( item, cast ); + + if( !result && item->window.flags & WINDOW_MOUSEOVER ) + { + Item_MouseLeave( item ); + Item_SetMouseOver( item, qfalse ); + } + } + } + +} + +void Menu_Update( menuDef_t *menu ) +{ + int i; + + if( menu == NULL ) + return; + + for( i = 0; i < menu->itemCount; i++ ) + Item_Update( menu->items[ i ] ); +} + +void Menu_Paint( menuDef_t *menu, qboolean forcePaint ) +{ + int i; + + if( menu == NULL ) + return; + + if( !( menu->window.flags & WINDOW_VISIBLE ) && !forcePaint ) + return; + + if( menu->window.ownerDrawFlags && DC->ownerDrawVisible && !DC->ownerDrawVisible( menu->window.ownerDrawFlags ) ) + return; + + if( forcePaint ) + menu->window.flags |= WINDOW_FORCED; + + // draw the background if necessary + if( menu->fullScreen ) + { + // implies a background shader + // FIXME: make sure we have a default shader if fullscreen is set with no background + DC->drawHandlePic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, menu->window.background ); + } + + // paint the background and or border + Window_Paint( &menu->window, menu->fadeAmount, menu->fadeClamp, menu->fadeCycle ); + + Border_Paint( &menu->window ); + + for( i = 0; i < menu->itemCount; i++ ) + Item_Paint( menu->items[i] ); + + if( DC->getCVarValue( "ui_developer" ) ) + { + vec4_t color; + color[0] = color[2] = color[3] = 1; + color[1] = 0; + DC->drawRect( menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, 1, color ); + } +} + +/* +=============== +Keyword Hash +=============== +*/ + +#define KEYWORDHASH_SIZE 512 + +typedef struct keywordHash_s +{ + char *keyword; + qboolean ( *func )( itemDef_t *item, int handle ); + + int param; + + struct keywordHash_s *next; +} + +keywordHash_t; + +int KeywordHash_Key( char *keyword ) +{ + int register hash, i; + + hash = 0; + + for( i = 0; keyword[i] != '\0'; i++ ) + { + if( keyword[i] >= 'A' && keyword[i] <= 'Z' ) + hash += ( keyword[i] + ( 'a' - 'A' ) ) * ( 119 + i ); + else + hash += keyword[i] * ( 119 + i ); + } + + hash = ( hash ^ ( hash >> 10 ) ^ ( hash >> 20 ) ) & ( KEYWORDHASH_SIZE - 1 ); + return hash; +} + +void KeywordHash_Add( keywordHash_t *table[], keywordHash_t *key ) +{ + int hash; + + hash = KeywordHash_Key( key->keyword ); + /* + if(table[hash]) int collision = qtrue; + */ + key->next = table[hash]; + table[hash] = key; +} + +keywordHash_t *KeywordHash_Find( keywordHash_t *table[], char *keyword ) +{ + keywordHash_t *key; + int hash; + + hash = KeywordHash_Key( keyword ); + + for( key = table[hash]; key; key = key->next ) + { + if( !Q_stricmp( key->keyword, keyword ) ) + return key; + } + + return NULL; +} + +/* +=============== +Item_DataType + +Give a numeric representation of which typeData union element this item uses +=============== +*/ +itemDataType_t Item_DataType( itemDef_t *item ) +{ + switch( item->type ) + { + default: + case ITEM_TYPE_NONE: + return TYPE_NONE; + + case ITEM_TYPE_LISTBOX: + case ITEM_TYPE_COMBOBOX: + return TYPE_LIST; + + case ITEM_TYPE_CYCLE: + return TYPE_COMBO; + + case ITEM_TYPE_EDITFIELD: + case ITEM_TYPE_NUMERICFIELD: + case ITEM_TYPE_SAYFIELD: + case ITEM_TYPE_YESNO: + case ITEM_TYPE_BIND: + case ITEM_TYPE_SLIDER: + case ITEM_TYPE_TEXT: + return TYPE_EDIT; + + case ITEM_TYPE_MULTI: + return TYPE_MULTI; + + case ITEM_TYPE_MODEL: + return TYPE_MODEL; + } +} + +/* +=============== +Item_IsEditField +=============== +*/ +static ID_INLINE qboolean Item_IsEditField( itemDef_t *item ) +{ + switch( item->type ) + { + case ITEM_TYPE_EDITFIELD: + case ITEM_TYPE_NUMERICFIELD: + case ITEM_TYPE_SAYFIELD: + return qtrue; + + default: + return qfalse; + } +} + +/* +=============== +Item_IsListBox +=============== +*/ +static ID_INLINE qboolean Item_IsListBox( itemDef_t *item ) +{ + switch( item->type ) + { + case ITEM_TYPE_LISTBOX: + case ITEM_TYPE_COMBOBOX: + return qtrue; + + default: + return qfalse; + } +} + +/* +=============== +Item Keyword Parse functions +=============== +*/ + +// name <string> +qboolean ItemParse_name( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->window.name ) ) + return qfalse; + + return qtrue; +} + +// name <string> +qboolean ItemParse_focusSound( itemDef_t *item, int handle ) +{ + const char *temp; + + if( !PC_String_Parse( handle, &temp ) ) + return qfalse; + + item->focusSound = DC->registerSound( temp, qfalse ); + return qtrue; +} + + +// text <string> +qboolean ItemParse_text( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->text ) ) + return qfalse; + + return qtrue; +} + +// group <string> +qboolean ItemParse_group( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->window.group ) ) + return qfalse; + + return qtrue; +} + +// asset_model <string> +qboolean ItemParse_asset_model( itemDef_t *item, int handle ) +{ + const char *temp; + + if( !PC_String_Parse( handle, &temp ) ) + return qfalse; + + item->asset = DC->registerModel( temp ); + item->typeData.model->angle = rand() % 360; + return qtrue; +} + +// asset_shader <string> +qboolean ItemParse_asset_shader( itemDef_t *item, int handle ) +{ + const char *temp; + + if( !PC_String_Parse( handle, &temp ) ) + return qfalse; + + item->asset = DC->registerShaderNoMip( temp ); + return qtrue; +} + +// model_origin <number> <number> <number> +qboolean ItemParse_model_origin( itemDef_t *item, int handle ) +{ + return ( PC_Float_Parse( handle, &item->typeData.model->origin[0] ) && + PC_Float_Parse( handle, &item->typeData.model->origin[1] ) && + PC_Float_Parse( handle, &item->typeData.model->origin[2] ) ); +} + +// model_fovx <number> +qboolean ItemParse_model_fovx( itemDef_t *item, int handle ) +{ + return PC_Float_Parse( handle, &item->typeData.model->fov_x ); +} + +// model_fovy <number> +qboolean ItemParse_model_fovy( itemDef_t *item, int handle ) +{ + return PC_Float_Parse( handle, &item->typeData.model->fov_y ); +} + +// model_rotation <integer> +qboolean ItemParse_model_rotation( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.model->rotationSpeed ); +} + +// model_angle <integer> +qboolean ItemParse_model_angle( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.model->angle ); +} + +// rect <rectangle> +qboolean ItemParse_rect( itemDef_t *item, int handle ) +{ + if( !PC_Rect_Parse( handle, &item->window.rectClient ) ) + return qfalse; + + return qtrue; +} + +// aspectBias <bias> +qboolean ItemParse_aspectBias( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->window.aspectBias ) ) + return qfalse; + + return qtrue; +} + +// style <integer> +qboolean ItemParse_style( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->window.style ) ) + return qfalse; + + return qtrue; +} + +// decoration +qboolean ItemParse_decoration( itemDef_t *item, int handle ) +{ + item->window.flags |= WINDOW_DECORATION; + return qtrue; +} + +// notselectable +qboolean ItemParse_notselectable( itemDef_t *item, int handle ) +{ + item->typeData.list->notselectable = qtrue; + return qtrue; +} + +// noscrollbar +qboolean ItemParse_noscrollbar( itemDef_t *item, int handle ) +{ + item->typeData.list->noscrollbar = qtrue; + return qtrue; +} + +// resetonfeederchange +qboolean ItemParse_resetonfeederchange( itemDef_t *item, int handle ) +{ + item->typeData.list->resetonfeederchange = qtrue; + return qtrue; +} + +// auto wrapped +qboolean ItemParse_wrapped( itemDef_t *item, int handle ) +{ + item->window.flags |= WINDOW_WRAPPED; + return qtrue; +} + + +// type <integer> +qboolean ItemParse_type( itemDef_t *item, int handle ) +{ + if( item->type != ITEM_TYPE_NONE ) + { + PC_SourceError( handle, "item already has a type" ); + return qfalse; + } + + if( !PC_Int_Parse( handle, &item->type ) ) + return qfalse; + + if( item->type == ITEM_TYPE_NONE ) + { + PC_SourceError( handle, "type must not be none" ); + return qfalse; + } + + // allocate the relevant type data + switch( item->type ) + { + case ITEM_TYPE_LISTBOX: + case ITEM_TYPE_COMBOBOX: + item->typeData.list = UI_Alloc( sizeof( listBoxDef_t ) ); + memset( item->typeData.list, 0, sizeof( listBoxDef_t ) ); + break; + + case ITEM_TYPE_CYCLE: + item->typeData.cycle = UI_Alloc( sizeof( cycleDef_t ) ); + memset( item->typeData.cycle, 0, sizeof( cycleDef_t ) ); + break; + + case ITEM_TYPE_EDITFIELD: + case ITEM_TYPE_SAYFIELD: + case ITEM_TYPE_NUMERICFIELD: + case ITEM_TYPE_YESNO: + case ITEM_TYPE_BIND: + case ITEM_TYPE_SLIDER: + case ITEM_TYPE_TEXT: + item->typeData.edit = UI_Alloc( sizeof( editFieldDef_t ) ); + memset( item->typeData.edit, 0, sizeof( editFieldDef_t ) ); + + if( item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_SAYFIELD ) + item->typeData.edit->maxPaintChars = MAX_EDITFIELD; + break; + + case ITEM_TYPE_MULTI: + item->typeData.multi = UI_Alloc( sizeof( multiDef_t ) ); + memset( item->typeData.multi, 0, sizeof( multiDef_t ) ); + break; + + case ITEM_TYPE_MODEL: + item->typeData.model = UI_Alloc( sizeof( modelDef_t ) ); + memset( item->typeData.model, 0, sizeof( modelDef_t ) ); + break; + + default: + break; + } + + return qtrue; +} + +// elementwidth, used for listbox image elements +qboolean ItemParse_elementwidth( itemDef_t *item, int handle ) +{ + return PC_Float_Parse( handle, &item->typeData.list->elementWidth ); +} + +// elementheight, used for listbox image elements +qboolean ItemParse_elementheight( itemDef_t *item, int handle ) +{ + return PC_Float_Parse( handle, &item->typeData.list->elementHeight ); +} + +// dropitems, number of items to drop from a combobox +qboolean ItemParse_dropitems( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.list->dropItems ); +} + +// feeder <int> +qboolean ItemParse_feeder( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->feederID ) ) + return qfalse; + + return qtrue; +} + +// elementtype, used to specify what type of elements a listbox contains +// uses textstyle for storage +qboolean ItemParse_elementtype( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.list->elementStyle ); +} + +// columns sets a number of columns and an x pos and width per.. +qboolean ItemParse_columns( itemDef_t *item, int handle ) +{ + int i; + + if( !PC_Int_Parse( handle, &item->typeData.list->numColumns ) ) + return qfalse; + + if( item->typeData.list->numColumns > MAX_LB_COLUMNS ) + { + PC_SourceError( handle, "exceeded maximum allowed columns (%d)", + MAX_LB_COLUMNS ); + return qfalse; + } + + for( i = 0; i < item->typeData.list->numColumns; i++ ) + { + int pos, width, align; + + if( !PC_Int_Parse( handle, &pos ) || + !PC_Int_Parse( handle, &width ) || + !PC_Int_Parse( handle, &align ) ) + return qfalse; + + item->typeData.list->columnInfo[i].pos = pos; + item->typeData.list->columnInfo[i].width = width; + item->typeData.list->columnInfo[i].align = align; + } + + return qtrue; +} + +qboolean ItemParse_border( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->window.border ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_bordersize( itemDef_t *item, int handle ) +{ + if( !PC_Float_Parse( handle, &item->window.borderSize ) ) + return qfalse; + + return qtrue; +} + +// FIXME: why does this require a parameter? visible MENU_FALSE does nothing +qboolean ItemParse_visible( itemDef_t *item, int handle ) +{ + int i; + + if( !PC_Int_Parse( handle, &i ) ) + return qfalse; + + if( i ) + item->window.flags |= WINDOW_VISIBLE; + + return qtrue; +} + +// ownerdraw <number>, implies ITEM_TYPE_OWNERDRAW +qboolean ItemParse_ownerdraw( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->window.ownerDraw ) ) + return qfalse; + + if( item->type != ITEM_TYPE_NONE && item->type != ITEM_TYPE_OWNERDRAW ) + { + PC_SourceError( handle, "ownerdraws cannot have an item type" ); + return qfalse; + } + + item->type = ITEM_TYPE_OWNERDRAW; + + return qtrue; +} + +qboolean ItemParse_align( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->alignment ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textalign( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->textalignment ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textvalign( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->textvalignment ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textalignx( itemDef_t *item, int handle ) +{ + if( !PC_Float_Parse( handle, &item->textalignx ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textaligny( itemDef_t *item, int handle ) +{ + if( !PC_Float_Parse( handle, &item->textaligny ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textscale( itemDef_t *item, int handle ) +{ + if( !PC_Float_Parse( handle, &item->textscale ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_textstyle( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->textStyle ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_backcolor( itemDef_t *item, int handle ) +{ + int i; + float f; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + item->window.backColor[i] = f; + } + + return qtrue; +} + +qboolean ItemParse_forecolor( itemDef_t *item, int handle ) +{ + int i; + float f; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + item->window.foreColor[i] = f; + item->window.flags |= WINDOW_FORECOLORSET; + } + + return qtrue; +} + +qboolean ItemParse_bordercolor( itemDef_t *item, int handle ) +{ + int i; + float f; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + item->window.borderColor[i] = f; + } + + return qtrue; +} + +qboolean ItemParse_outlinecolor( itemDef_t *item, int handle ) +{ + if( !PC_Color_Parse( handle, &item->window.outlineColor ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_background( itemDef_t *item, int handle ) +{ + const char *temp; + + if( !PC_String_Parse( handle, &temp ) ) + return qfalse; + + item->window.background = DC->registerShaderNoMip( temp ); + return qtrue; +} + +qboolean ItemParse_cinematic( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->window.cinematicName ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_doubleClick( itemDef_t *item, int handle ) +{ + return ( item->typeData.list && + PC_Script_Parse( handle, &item->typeData.list->doubleClick ) ); +} + +qboolean ItemParse_onFocus( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->onFocus ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_leaveFocus( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->leaveFocus ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_mouseEnter( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->mouseEnter ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_mouseExit( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->mouseExit ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_mouseEnterText( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->mouseEnterText ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_mouseExitText( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->mouseExitText ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_onTextEntry( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->onTextEntry ) ) + return qfalse; + + return qtrue; +} + + +qboolean ItemParse_onCharEntry( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->onCharEntry ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_action( itemDef_t *item, int handle ) +{ + if( !PC_Script_Parse( handle, &item->action ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_cvarTest( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->cvarTest ) ) + return qfalse; + + return qtrue; +} + +qboolean ItemParse_cvar( itemDef_t *item, int handle ) +{ + if( !PC_String_Parse( handle, &item->cvar ) ) + return qfalse; + + if( Item_DataType( item ) == TYPE_EDIT ) + { + item->typeData.edit->minVal = -1; + item->typeData.edit->maxVal = -1; + item->typeData.edit->defVal = -1; + } + + return qtrue; +} + +qboolean ItemParse_maxChars( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.edit->maxChars ); +} + +qboolean ItemParse_maxPaintChars( itemDef_t *item, int handle ) +{ + return PC_Int_Parse( handle, &item->typeData.edit->maxPaintChars ); +} + +qboolean ItemParse_maxFieldWidth( itemDef_t *item, int handle ) +{ + if( !PC_Int_Parse( handle, &item->typeData.edit->maxFieldWidth ) ) + return qfalse; + + if( item->typeData.edit->maxFieldWidth < MIN_FIELD_WIDTH ) + { + PC_SourceError( handle, "max field width must be at least %d", + MIN_FIELD_WIDTH ); + return qfalse; + } + + return qtrue; +} + + + +qboolean ItemParse_cvarFloat( itemDef_t *item, int handle ) +{ + return ( PC_String_Parse( handle, &item->cvar ) && + PC_Float_Parse( handle, &item->typeData.edit->defVal ) && + PC_Float_Parse( handle, &item->typeData.edit->minVal ) && + PC_Float_Parse( handle, &item->typeData.edit->maxVal ) ); +} + +qboolean ItemParse_cvarStrList( itemDef_t *item, int handle ) +{ + pc_token_t token; + multiDef_t *multiPtr; + int pass; + + multiPtr = item->typeData.multi; + multiPtr->count = 0; + multiPtr->strDef = qtrue; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( *token.string != '{' ) + return qfalse; + + pass = 0; + + while( 1 ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + { + PC_SourceError( handle, "end of file inside menu item\n" ); + return qfalse; + } + + if( *token.string == '}' ) + return qtrue; + + if( *token.string == ',' || *token.string == ';' ) + continue; + + if( pass == 0 ) + { + multiPtr->cvarList[multiPtr->count] = String_Alloc( token.string ); + pass = 1; + } + else + { + multiPtr->cvarStr[multiPtr->count] = String_Alloc( token.string ); + pass = 0; + multiPtr->count++; + + if( multiPtr->count >= MAX_MULTI_CVARS ) + { + PC_SourceError( handle, "cvar string list may not exceed %d cvars", + MAX_MULTI_CVARS ); + return qfalse; + } + } + + } + + return qfalse; +} + +qboolean ItemParse_cvarFloatList( itemDef_t *item, int handle ) +{ + pc_token_t token; + multiDef_t *multiPtr; + + multiPtr = item->typeData.multi; + multiPtr->count = 0; + multiPtr->strDef = qfalse; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( *token.string != '{' ) + return qfalse; + + while( 1 ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + { + PC_SourceError( handle, "end of file inside menu item\n" ); + return qfalse; + } + + if( *token.string == '}' ) + return qtrue; + + if( *token.string == ',' || *token.string == ';' ) + continue; + + multiPtr->cvarList[multiPtr->count] = String_Alloc( token.string ); + + if( !PC_Float_Parse( handle, &multiPtr->cvarValue[multiPtr->count] ) ) + return qfalse; + + multiPtr->count++; + + if( multiPtr->count >= MAX_MULTI_CVARS ) + { + PC_SourceError( handle, "cvar string list may not exceed %d cvars", + MAX_MULTI_CVARS ); + return qfalse; + } + } + + return qfalse; +} + + + +qboolean ItemParse_addColorRange( itemDef_t *item, int handle ) +{ + colorRangeDef_t color; + + if( PC_Float_Parse( handle, &color.low ) && + PC_Float_Parse( handle, &color.high ) && + PC_Color_Parse( handle, &color.color ) ) + { + if( item->numColors < MAX_COLOR_RANGES ) + { + memcpy( &item->colorRanges[item->numColors], &color, sizeof( color ) ); + item->numColors++; + } + else + { + PC_SourceError( handle, "may not exceed %d color ranges", + MAX_COLOR_RANGES ); + return qfalse; + } + + return qtrue; + } + + return qfalse; +} + +qboolean ItemParse_ownerdrawFlag( itemDef_t *item, int handle ) +{ + int i; + + if( !PC_Int_Parse( handle, &i ) ) + return qfalse; + + item->window.ownerDrawFlags |= i; + return qtrue; +} + +qboolean ItemParse_enableCvar( itemDef_t *item, int handle ) +{ + if( PC_Script_Parse( handle, &item->enableCvar ) ) + { + item->cvarFlags = CVAR_ENABLE; + return qtrue; + } + + return qfalse; +} + +qboolean ItemParse_disableCvar( itemDef_t *item, int handle ) +{ + if( PC_Script_Parse( handle, &item->enableCvar ) ) + { + item->cvarFlags = CVAR_DISABLE; + return qtrue; + } + + return qfalse; +} + +qboolean ItemParse_showCvar( itemDef_t *item, int handle ) +{ + if( PC_Script_Parse( handle, &item->enableCvar ) ) + { + item->cvarFlags = CVAR_SHOW; + return qtrue; + } + + return qfalse; +} + +qboolean ItemParse_hideCvar( itemDef_t *item, int handle ) +{ + if( PC_Script_Parse( handle, &item->enableCvar ) ) + { + item->cvarFlags = CVAR_HIDE; + return qtrue; + } + + return qfalse; +} + + +keywordHash_t itemParseKeywords[] = { + {"name", ItemParse_name, TYPE_ANY}, + {"type", ItemParse_type, TYPE_ANY}, + {"text", ItemParse_text, TYPE_ANY}, + {"group", ItemParse_group, TYPE_ANY}, + {"asset_model", ItemParse_asset_model, TYPE_MODEL}, + {"asset_shader", ItemParse_asset_shader, TYPE_ANY}, // ? + {"model_origin", ItemParse_model_origin, TYPE_MODEL}, + {"model_fovx", ItemParse_model_fovx, TYPE_MODEL}, + {"model_fovy", ItemParse_model_fovy, TYPE_MODEL}, + {"model_rotation", ItemParse_model_rotation, TYPE_MODEL}, + {"model_angle", ItemParse_model_angle, TYPE_MODEL}, + {"rect", ItemParse_rect, TYPE_ANY}, + {"aspectBias", ItemParse_aspectBias, TYPE_ANY}, + {"style", ItemParse_style, TYPE_ANY}, + {"decoration", ItemParse_decoration, TYPE_ANY}, + {"notselectable", ItemParse_notselectable, TYPE_LIST}, + {"noscrollbar", ItemParse_noscrollbar, TYPE_LIST}, + {"resetonfeederchange", ItemParse_resetonfeederchange, TYPE_LIST}, + {"wrapped", ItemParse_wrapped, TYPE_ANY}, + {"elementwidth", ItemParse_elementwidth, TYPE_LIST}, + {"elementheight", ItemParse_elementheight, TYPE_LIST}, + {"dropitems", ItemParse_dropitems, TYPE_LIST}, + {"feeder", ItemParse_feeder, TYPE_ANY}, + {"elementtype", ItemParse_elementtype, TYPE_LIST}, + {"columns", ItemParse_columns, TYPE_LIST}, + {"border", ItemParse_border, TYPE_ANY}, + {"bordersize", ItemParse_bordersize, TYPE_ANY}, + {"visible", ItemParse_visible, TYPE_ANY}, + {"ownerdraw", ItemParse_ownerdraw, TYPE_ANY}, + {"align", ItemParse_align, TYPE_ANY}, + {"textalign", ItemParse_textalign, TYPE_ANY}, + {"textvalign", ItemParse_textvalign, TYPE_ANY}, + {"textalignx", ItemParse_textalignx, TYPE_ANY}, + {"textaligny", ItemParse_textaligny, TYPE_ANY}, + {"textscale", ItemParse_textscale, TYPE_ANY}, + {"textstyle", ItemParse_textstyle, TYPE_ANY}, + {"backcolor", ItemParse_backcolor, TYPE_ANY}, + {"forecolor", ItemParse_forecolor, TYPE_ANY}, + {"bordercolor", ItemParse_bordercolor, TYPE_ANY}, + {"outlinecolor", ItemParse_outlinecolor, TYPE_ANY}, + {"background", ItemParse_background, TYPE_ANY}, + {"onFocus", ItemParse_onFocus, TYPE_ANY}, + {"leaveFocus", ItemParse_leaveFocus, TYPE_ANY}, + {"mouseEnter", ItemParse_mouseEnter, TYPE_ANY}, + {"mouseExit", ItemParse_mouseExit, TYPE_ANY}, + {"mouseEnterText", ItemParse_mouseEnterText, TYPE_ANY}, + {"mouseExitText", ItemParse_mouseExitText, TYPE_ANY}, + {"onTextEntry", ItemParse_onTextEntry, TYPE_ANY}, + {"onCharEntry", ItemParse_onCharEntry, TYPE_ANY}, + {"action", ItemParse_action, TYPE_ANY}, + {"cvar", ItemParse_cvar, TYPE_ANY}, + {"maxChars", ItemParse_maxChars, TYPE_EDIT}, + {"maxPaintChars", ItemParse_maxPaintChars, TYPE_EDIT}, + {"maxFieldWidth", ItemParse_maxFieldWidth, TYPE_EDIT}, + {"focusSound", ItemParse_focusSound, TYPE_ANY}, + {"cvarFloat", ItemParse_cvarFloat, TYPE_EDIT}, + {"cvarStrList", ItemParse_cvarStrList, TYPE_MULTI}, + {"cvarFloatList", ItemParse_cvarFloatList, TYPE_MULTI}, + {"addColorRange", ItemParse_addColorRange, TYPE_ANY}, + {"ownerdrawFlag", ItemParse_ownerdrawFlag, TYPE_ANY}, // hm. + {"enableCvar", ItemParse_enableCvar, TYPE_ANY}, + {"cvarTest", ItemParse_cvarTest, TYPE_ANY}, + {"disableCvar", ItemParse_disableCvar, TYPE_ANY}, + {"showCvar", ItemParse_showCvar, TYPE_ANY}, + {"hideCvar", ItemParse_hideCvar, TYPE_ANY}, + {"cinematic", ItemParse_cinematic, TYPE_ANY}, + {"doubleclick", ItemParse_doubleClick, TYPE_LIST}, + {NULL, voidFunction2} +}; + +keywordHash_t *itemParseKeywordHash[KEYWORDHASH_SIZE]; + +/* +=============== +Item_SetupKeywordHash +=============== +*/ +void Item_SetupKeywordHash( void ) +{ + int i; + + memset( itemParseKeywordHash, 0, sizeof( itemParseKeywordHash ) ); + + for( i = 0; itemParseKeywords[ i ].keyword; i++ ) + KeywordHash_Add( itemParseKeywordHash, &itemParseKeywords[ i ] ); +} + +/* +=============== +Item_Parse +=============== +*/ +qboolean Item_Parse( int handle, itemDef_t *item ) +{ + pc_token_t token; + keywordHash_t *key; + + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( *token.string != '{' ) + return qfalse; + + while( 1 ) + { + if( !trap_Parse_ReadToken( handle, &token ) ) + { + PC_SourceError( handle, "end of file inside menu item\n" ); + return qfalse; + } + + if( *token.string == '}' ) + return qtrue; + + key = KeywordHash_Find( itemParseKeywordHash, token.string ); + + if( !key ) + { + PC_SourceError( handle, "unknown menu item keyword %s", token.string ); + continue; + } + + // do type-checks + if( key->param != TYPE_ANY ) + { + itemDataType_t test = Item_DataType( item ); + + if( test != key->param ) + { + if( test == TYPE_NONE ) + PC_SourceError( handle, "menu item keyword %s requires " + "type specification", token.string ); + else + PC_SourceError( handle, "menu item keyword %s is incompatible with " + "specified item type", token.string ); + continue; + } + } + + if( !key->func( item, handle ) ) + { + PC_SourceError( handle, "couldn't parse menu item keyword %s", token.string ); + return qfalse; + } + } + + return qfalse; +} + + +// Item_InitControls +// init's special control types +void Item_InitControls( itemDef_t *item ) +{ + if( item == NULL ) + return; + + if( Item_IsListBox( item ) ) + { + item->cursorPos = 0; + + if( item->typeData.list ) + { + item->typeData.list->cursorPos = 0; + Item_ListBox_SetStartPos( item, 0 ); + item->typeData.list->cursorPos = 0; + } + } +} + +/* +=============== +Menu Keyword Parse functions +=============== +*/ + +qboolean MenuParse_font( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_String_Parse( handle, &menu->font ) ) + return qfalse; + + if( !DC->Assets.fontRegistered ) + { + DC->registerFont( menu->font, 48, &DC->Assets.textFont ); + DC->Assets.fontRegistered = qtrue; + } + + return qtrue; +} + +qboolean MenuParse_name( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_String_Parse( handle, &menu->window.name ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_fullscreen( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, ( int* ) & menu->fullScreen ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_rect( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Rect_Parse( handle, &menu->window.rect ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_aspectBias( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &menu->window.aspectBias ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_style( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &menu->window.style ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_visible( itemDef_t *item, int handle ) +{ + int i; + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &i ) ) + return qfalse; + + if( i ) + menu->window.flags |= WINDOW_VISIBLE; + + return qtrue; +} + +qboolean MenuParse_onOpen( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Script_Parse( handle, &menu->onOpen ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_onClose( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Script_Parse( handle, &menu->onClose ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_onESC( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Script_Parse( handle, &menu->onESC ) ) + return qfalse; + + return qtrue; +} + + + +qboolean MenuParse_border( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &menu->window.border ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_borderSize( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Float_Parse( handle, &menu->window.borderSize ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_backcolor( itemDef_t *item, int handle ) +{ + int i; + float f; + menuDef_t *menu = ( menuDef_t* )item; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + menu->window.backColor[i] = f; + } + + return qtrue; +} + +qboolean MenuParse_forecolor( itemDef_t *item, int handle ) +{ + int i; + float f; + menuDef_t *menu = ( menuDef_t* )item; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + menu->window.foreColor[i] = f; + menu->window.flags |= WINDOW_FORECOLORSET; + } + + return qtrue; +} + +qboolean MenuParse_bordercolor( itemDef_t *item, int handle ) +{ + int i; + float f; + menuDef_t *menu = ( menuDef_t* )item; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + menu->window.borderColor[i] = f; + } + + return qtrue; +} + +qboolean MenuParse_focuscolor( itemDef_t *item, int handle ) +{ + int i; + float f; + menuDef_t *menu = ( menuDef_t* )item; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + menu->focusColor[i] = f; + } + + return qtrue; +} + +qboolean MenuParse_disablecolor( itemDef_t *item, int handle ) +{ + int i; + float f; + menuDef_t *menu = ( menuDef_t* )item; + + for( i = 0; i < 4; i++ ) + { + if( !PC_Float_Parse( handle, &f ) ) + return qfalse; + + menu->disableColor[i] = f; + } + + return qtrue; +} + + +qboolean MenuParse_outlinecolor( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Color_Parse( handle, &menu->window.outlineColor ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_background( itemDef_t *item, int handle ) +{ + const char *buff; + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_String_Parse( handle, &buff ) ) + return qfalse; + + menu->window.background = DC->registerShaderNoMip( buff ); + return qtrue; +} + +qboolean MenuParse_cinematic( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_String_Parse( handle, &menu->window.cinematicName ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_ownerdrawFlag( itemDef_t *item, int handle ) +{ + int i; + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &i ) ) + return qfalse; + + menu->window.ownerDrawFlags |= i; + return qtrue; +} + +qboolean MenuParse_ownerdraw( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &menu->window.ownerDraw ) ) + return qfalse; + + return qtrue; +} + + +// decoration +qboolean MenuParse_popup( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + menu->window.flags |= WINDOW_POPUP; + return qtrue; +} + + +qboolean MenuParse_outOfBounds( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + menu->window.flags |= WINDOW_OOB_CLICK; + return qtrue; +} + +qboolean MenuParse_soundLoop( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_String_Parse( handle, &menu->soundName ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_fadeClamp( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Float_Parse( handle, &menu->fadeClamp ) ) + return qfalse; + + return qtrue; +} + +qboolean MenuParse_fadeAmount( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Float_Parse( handle, &menu->fadeAmount ) ) + return qfalse; + + return qtrue; +} + + +qboolean MenuParse_fadeCycle( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( !PC_Int_Parse( handle, &menu->fadeCycle ) ) + return qfalse; + + return qtrue; +} + + +qboolean MenuParse_itemDef( itemDef_t *item, int handle ) +{ + menuDef_t *menu = ( menuDef_t* )item; + + if( menu->itemCount < MAX_MENUITEMS ) + { + menu->items[menu->itemCount] = UI_Alloc( sizeof( itemDef_t ) ); + Item_Init( menu->items[menu->itemCount] ); + + if( !Item_Parse( handle, menu->items[menu->itemCount] ) ) + return qfalse; + + Item_InitControls( menu->items[menu->itemCount] ); + menu->items[menu->itemCount++]->parent = menu; + } + else + { + PC_SourceError( handle, "itemDefs per menu may not exceed %d", + MAX_MENUITEMS ); + return qfalse; + } + + return qtrue; +} + +keywordHash_t menuParseKeywords[] = { + {"font", MenuParse_font}, + {"name", MenuParse_name}, + {"fullscreen", MenuParse_fullscreen}, + {"rect", MenuParse_rect}, + {"aspectBias", MenuParse_aspectBias}, + {"style", MenuParse_style}, + {"visible", MenuParse_visible}, + {"onOpen", MenuParse_onOpen}, + {"onClose", MenuParse_onClose}, + {"onESC", MenuParse_onESC}, + {"border", MenuParse_border}, + {"borderSize", MenuParse_borderSize}, + {"backcolor", MenuParse_backcolor}, + {"forecolor", MenuParse_forecolor}, + {"bordercolor", MenuParse_bordercolor}, + {"focuscolor", MenuParse_focuscolor}, + {"disablecolor", MenuParse_disablecolor}, + {"outlinecolor", MenuParse_outlinecolor}, + {"background", MenuParse_background}, + {"ownerdraw", MenuParse_ownerdraw}, + {"ownerdrawFlag", MenuParse_ownerdrawFlag}, + {"outOfBoundsClick", MenuParse_outOfBounds}, + {"soundLoop", MenuParse_soundLoop}, + {"itemDef", MenuParse_itemDef}, + {"cinematic", MenuParse_cinematic}, + {"popup", MenuParse_popup}, + {"fadeClamp", MenuParse_fadeClamp}, + {"fadeCycle", MenuParse_fadeCycle}, + {"fadeAmount", MenuParse_fadeAmount}, + {NULL, voidFunction2} +}; + +keywordHash_t *menuParseKeywordHash[KEYWORDHASH_SIZE]; + +/* +=============== +Menu_SetupKeywordHash +=============== +*/ +void Menu_SetupKeywordHash( void ) +{ + int i; + + memset( menuParseKeywordHash, 0, sizeof( menuParseKeywordHash ) ); + + for( i = 0; menuParseKeywords[ i ].keyword; i++ ) + KeywordHash_Add( menuParseKeywordHash, &menuParseKeywords[ i ] ); +} + +/* +=============== +Menu_Parse +=============== +*/ +qboolean Menu_Parse( int handle, menuDef_t *menu ) +{ + pc_token_t token; + keywordHash_t *key; + + if( !trap_Parse_ReadToken( handle, &token ) ) + return qfalse; + + if( *token.string != '{' ) + return qfalse; + + while( 1 ) + { + memset( &token, 0, sizeof( pc_token_t ) ); + + if( !trap_Parse_ReadToken( handle, &token ) ) + { + PC_SourceError( handle, "end of file inside menu\n" ); + return qfalse; + } + + if( *token.string == '}' ) + return qtrue; + + key = KeywordHash_Find( menuParseKeywordHash, token.string ); + + if( !key ) + { + PC_SourceError( handle, "unknown menu keyword %s", token.string ); + continue; + } + + if( !key->func( ( itemDef_t* )menu, handle ) ) + { + PC_SourceError( handle, "couldn't parse menu keyword %s", token.string ); + return qfalse; + } + } + + return qfalse; +} + +/* +=============== +Menu_New +=============== +*/ +void Menu_New( int handle ) +{ + menuDef_t *menu = &Menus[menuCount]; + + if( menuCount < MAX_MENUS ) + { + Menu_Init( menu ); + + if( Menu_Parse( handle, menu ) ) + { + Menu_PostParse( menu ); + menuCount++; + } + } +} + +int Menu_Count( void ) +{ + return menuCount; +} + +void Menu_UpdateAll( void ) +{ + int i; + + for( i = 0; i < openMenuCount; i++ ) + Menu_Update( menuStack[ i ] ); +} + +void Menu_PaintAll( void ) +{ + int i; + + if( g_editingField || g_waitingForKey ) + DC->setCVar( "ui_hideCursor", "1" ); + else + DC->setCVar( "ui_hideCursor", "0" ); + + if( captureFunc != voidFunction ) + { + if( captureFuncExpiry > 0 && DC->realTime > captureFuncExpiry ) + UI_RemoveCaptureFunc( ); + else + captureFunc( captureData ); + } + + for( i = 0; i < openMenuCount; i++ ) + Menu_Paint( menuStack[ i ], qfalse ); + + if( DC->getCVarValue( "ui_developer" ) ) + { + vec4_t v = {1, 1, 1, 1}; + UI_Text_Paint( 5, 25, .5, v, va( "fps: %f", DC->FPS ), 0, 0, 0 ); + } +} + +void Menu_Reset( void ) +{ + menuCount = 0; +} + +displayContextDef_t *Display_GetContext( void ) +{ + return DC; +} + +void *Display_CaptureItem( int x, int y ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + { + if( Rect_ContainsPoint( &Menus[i].window.rect, x, y ) ) + return & Menus[i]; + } + + return NULL; +} + + +// FIXME: +qboolean Display_MouseMove( void *p, float x, float y ) +{ + int i; + menuDef_t *menu = p; + + if( menu == NULL ) + { + menu = Menu_GetFocused(); + + if( menu ) + { + if( menu->window.flags & WINDOW_POPUP ) + { + Menu_HandleMouseMove( menu, x, y ); + return qtrue; + } + } + + for( i = 0; i < menuCount; i++ ) + Menu_HandleMouseMove( &Menus[i], x, y ); + } + else + { + menu->window.rect.x += x; + menu->window.rect.y += y; + Menu_UpdatePosition( menu ); + } + + return qtrue; + +} + +int Display_CursorType( int x, int y ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + { + rectDef_t r2; + r2.x = Menus[i].window.rect.x - 3; + r2.y = Menus[i].window.rect.y - 3; + r2.w = r2.h = 7; + + if( Rect_ContainsPoint( &r2, x, y ) ) + return CURSOR_SIZER; + } + + return CURSOR_ARROW; +} + + +void Display_HandleKey( int key, qboolean down, int x, int y ) +{ + menuDef_t *menu = Display_CaptureItem( x, y ); + + if( menu == NULL ) + menu = Menu_GetFocused(); + + if( menu ) + Menu_HandleKey( menu, key, down ); +} + +static void Window_CacheContents( windowDef_t *window ) +{ + if( window ) + { + if( window->cinematicName ) + { + int cin = DC->playCinematic( window->cinematicName, 0, 0, 0, 0 ); + DC->stopCinematic( cin ); + } + } +} + + +static void Item_CacheContents( itemDef_t *item ) +{ + if( item ) + Window_CacheContents( &item->window ); + +} + +static void Menu_CacheContents( menuDef_t *menu ) +{ + if( menu ) + { + int i; + Window_CacheContents( &menu->window ); + + for( i = 0; i < menu->itemCount; i++ ) + Item_CacheContents( menu->items[i] ); + + if( menu->soundName && *menu->soundName ) + DC->registerSound( menu->soundName, qfalse ); + } + +} + +void Display_CacheAll( void ) +{ + int i; + + for( i = 0; i < menuCount; i++ ) + Menu_CacheContents( &Menus[i] ); +} + + +static qboolean Menu_OverActiveItem( menuDef_t *menu, float x, float y ) +{ + if( menu && menu->window.flags & ( WINDOW_VISIBLE | WINDOW_FORCED ) ) + { + if( Rect_ContainsPoint( &menu->window.rect, x, y ) ) + { + int i; + + for( i = 0; i < menu->itemCount; i++ ) + { + if( !( menu->items[i]->window.flags & ( WINDOW_VISIBLE | WINDOW_FORCED ) ) ) + continue; + + if( menu->items[i]->window.flags & WINDOW_DECORATION ) + continue; + + if( Rect_ContainsPoint( &menu->items[i]->window.rect, x, y ) ) + { + itemDef_t * overItem = menu->items[i]; + + if( overItem->type == ITEM_TYPE_TEXT && overItem->text ) + { + if( Rect_ContainsPoint( Item_CorrectedTextRect( overItem ), x, y ) ) + return qtrue; + else + continue; + } + else + return qtrue; + } + } + + } + } + + return qfalse; +} |