FWGS/Paranoia2
2
0
Fork 2
forked from a1batross/Paranoia2_original
Code Issues Pull Requests 1 Releases Wiki Activity
a9d98679f3
Paranoia2/mainui/basemenu.cpp

1609 lines
36 KiB
C++
Raw Normal View History

CRLF to LF
2020-08-31 18:50:41 +02:00
/*
Copyright (C) 1997-2001 Id Software, Inc.
This program 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.
This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// ui_menu.c -- main menu interface
#define OEMRESOURCE // for OCR_* cursor junk
#include "extdll.h"
#include "basemenu.h"
#include "keydefs.h"
#include "menufont.h" // built-in menu font
#include "utils.h"
#include "menu_btnsbmp_table.h"
//CR
#include "ui_title_anim.h"
cvar_t *ui_precache;
cvar_t *ui_showmodels;
cvar_t *ui_videoconfig;
uiStatic_t uiStatic;
char uiEmptyString[256];
const char *uiSoundIn = "media/launch_upmenu1.wav";
const char *uiSoundOut = "media/launch_dnmenu1.wav";
const char *uiSoundLaunch = "media/launch_select2.wav";
const char *uiSoundGlow = "media/launch_glow1.wav";
const char *uiSoundBuzz = "media/launch_deny2.wav";
const char *uiSoundKey = "media/launch_select1.wav";
const char *uiSoundRemoveKey = "media/launch_deny1.wav";
const char *uiSoundMove = ""; // Xash3D not use movesound
const char *uiSoundNull = "";
int uiColorHelp = 0xFFFFFFFF; // 255, 255, 255, 255 // hint letters color
int uiPromptBgColor = 0xFF404040; // 64, 64, 64, 255 // dialog background color
int uiPromptTextColor = 0xFFF0B418; // 255, 160, 0, 255 // dialog or button letters color
int uiPromptFocusColor = 0xFFFFFF00; // 255, 255, 0, 255 // dialog or button focus letters color
int uiInputTextColor = 0xFFC0C0C0; // 192, 192, 192, 255
int uiInputBgColor = 0xFF404040; // 64, 64, 64, 255 // field, scrollist, checkbox background color
int uiInputFgColor = 0xFF555555; // 85, 85, 85, 255 // field, scrollist, checkbox foreground color
int uiColorWhite = 0xFFFFFFFF; // 255, 255, 255, 255 // useful for bitmaps
int uiColorDkGrey = 0xFF404040; // 64, 64, 64, 255 // shadow and grayed items
int uiColorBlack = 0xFF000000; // 0, 0, 0, 255 // some controls background
int uiColorConsole = 0xFFF0B418; // just for reference
// color presets (this is nasty hack to allow color presets to part of text)
const int g_iColorTable[8] =
{
0xFF000000, // black
0xFFFF0000, // red
0xFF00FF00, // green
0xFFFFFF00, // yellow
0xFF0000FF, // blue
0xFF00FFFF, // cyan
0xFFF0B418, // dialog or button letters color
0xFFFFFFFF, // white
};
/*
=================
UI_ScaleCoords
Any parameter can be NULL if you don't want it
=================
*/
void UI_ScaleCoords( int *x, int *y, int *w, int *h )
{
if( x ) *x *= uiStatic.scaleX;
if( y ) *y *= uiStatic.scaleY;
if( w ) *w *= uiStatic.scaleX;
if( h ) *h *= uiStatic.scaleY;
}
/*
=================
UI_CursorInRect
=================
*/
int UI_CursorInRect( int x, int y, int w, int h )
{
if( uiStatic.cursorX < x )
return FALSE;
if( uiStatic.cursorX > x + w )
return FALSE;
if( uiStatic.cursorY < y )
return FALSE;
if( uiStatic.cursorY > y + h )
return FALSE;
return TRUE;
}
/*
=================
UI_DrawPic
=================
*/
void UI_DrawPic( int x, int y, int width, int height, const int color, const char *pic )
{
HIMAGE hPic = PIC_Load( pic );
int r, g, b, a;
UnpackRGBA( r, g, b, a, color );
PIC_Set( hPic, r, g, b, a );
PIC_Draw( x, y, width, height );
}
/*
=================
UI_DrawPicAdditive
=================
*/
void UI_DrawPicAdditive( int x, int y, int width, int height, const int color, const char *pic )
{
HIMAGE hPic = PIC_Load( pic );
int r, g, b, a;
UnpackRGBA( r, g, b, a, color );
PIC_Set( hPic, r, g, b, a );
PIC_DrawAdditive( x, y, width, height );
}
/*
=================
UI_FillRect
=================
*/
void UI_FillRect( int x, int y, int width, int height, const int color )
{
int r, g, b, a;
UnpackRGBA( r, g, b, a, color );
FillRGBA( x, y, width, height, r, g, b, a );
}
/*
=================
UI_DrawRectangleExt
=================
*/
void UI_DrawRectangleExt( int in_x, int in_y, int in_w, int in_h, const int color, int outlineWidth )
{
int x, y, w, h;
x = in_x - outlineWidth;
y = in_y - outlineWidth;
w = outlineWidth;
h = in_h + outlineWidth + outlineWidth;
// draw left
UI_FillRect( x, y, w, h, color );
x = in_x + in_w;
y = in_y - outlineWidth;
w = outlineWidth;
h = in_h + outlineWidth + outlineWidth;
// draw right
UI_FillRect( x, y, w, h, color );
x = in_x;
y = in_y - outlineWidth;
w = in_w;
h = outlineWidth;
// draw top
UI_FillRect( x, y, w, h, color );
// draw bottom
x = in_x;
y = in_y + in_h;
w = in_w;
h = outlineWidth;
UI_FillRect( x, y, w, h, color );
}
/*
=================
UI_DrawString
=================
*/
void UI_DrawString( int x, int y, int w, int h, const char *string, const int color, int forceColor, int charW, int charH, int justify, int shadow )
{
int modulate, shadowModulate;
char line[1024], *l;
int xx, yy, ofsX, ofsY, len, ch;
if( !string || !string[0] )
return;
#if 0 // g-cont. disabled 29/06/2011
// this code do a bad things with prompt dialogues
// vertically centered
if( !strchr( string, '\n' ))
y = y + (( h - charH ) / 2 );
#endif
if( shadow )
{
shadowModulate = PackAlpha( uiColorBlack, UnpackAlpha( color ));
ofsX = charW / 8;
ofsY = charH / 8;
}
modulate = color;
yy = y;
while( *string )
{
// get a line of text
len = 0;
while( *string )
{
if( *string == '\n' )
{
string++;
break;
}
line[len++] = *string++;
if( len == sizeof( line ) - 1 )
break;
}
line[len] = 0;
// align the text as appropriate
if( justify == 0 ) xx = x;
if( justify == 1 ) xx = x + ((w - (ColorStrlen( line ) * charW )) / 2);
if( justify == 2 ) xx = x + (w - (ColorStrlen( line ) * charW ));
// draw it
l = line;
while( *l )
{
if( IsColorString( l ))
{
int colorNum = ColorIndex( *(l+1) );
if( colorNum == 7 && color != 0 )
{
modulate = color;
}
else if( !forceColor )
{
modulate = PackAlpha( g_iColorTable[colorNum], UnpackAlpha( color ));
}
l += 2;
continue;
}
ch = *l++;
ch &= 255;
CP1251 to UTF-8 (to preserve original comments)
2020-08-31 18:55:47 +02:00
// fix for letter ё
if( ch == 0xB8 ) ch = (byte)'е';
if( ch == 0xA8 ) ch = (byte)'Е';
CRLF to LF
2020-08-31 18:50:41 +02:00
if( ch != ' ' )
{
if( shadow ) TextMessageDrawChar( xx + ofsX, yy + ofsY, charW, charH, ch, shadowModulate, uiStatic.hFont );
TextMessageDrawChar( xx, yy, charW, charH, ch, modulate, uiStatic.hFont );
}
xx += charW;
}
yy += charH;
}
}
/*
=================
UI_DrawMouseCursor
=================
*/
void UI_DrawMouseCursor( void )
{
menuCommon_s *item;
HICON hCursor = NULL;
int i;
if( uiStatic.hideCursor ) return;
for( i = 0; i < uiStatic.menuActive->numItems; i++ )
{
item = (menuCommon_s *)uiStatic.menuActive->items[i];
if ( item->flags & (QMF_INACTIVE|QMF_HIDDEN))
continue;
if ( !UI_CursorInRect( item->x, item->y, item->width, item->height ))
continue;
if ( item->flags & QMF_GRAYED )
{
hCursor = (HICON)LoadCursor( NULL, (LPCTSTR)OCR_NO );
}
else
{
if( item->type == QMTYPE_FIELD )
hCursor = (HICON)LoadCursor( NULL, (LPCTSTR)OCR_IBEAM );
}
break;
}
if( !hCursor ) hCursor = (HICON)LoadCursor( NULL, (LPCTSTR)OCR_NORMAL );
SET_CURSOR( hCursor );
}
/*
=================
UI_DrawBackground_Callback
=================
*/
void UI_DrawBackground_Callback( void *self )
{
if (!uiStatic.m_fHaveSteamBackground)
{
menuCommon_s *item = (menuCommon_s *)self;
UI_DrawPic( item->x, item->y, item->width, item->height, uiColorWhite, ((menuBitmap_s *)self)->pic );
return;
}
int xpos, ypos;
float xScale, yScale;
// work out scaling factors
xScale = ScreenWidth / uiStatic.m_flTotalWidth;
yScale = ScreenHeight / uiStatic.m_flTotalHeight;
// iterate and draw all the background pieces
ypos = 0;
for (int y = 0; y < BACKGROUND_ROWS; y++)
{
xpos = 0;
for (int x = 0; x < BACKGROUND_COLUMNS; x++)
{
bimage_t &bimage = uiStatic.m_SteamBackground[y][x];
int dx = (int)ceil(xpos * xScale);
int dy = (int)ceil(ypos * yScale);
int dw = (int)ceil(bimage.width * xScale);
int dt = (int)ceil(bimage.height * yScale);
if (x == 0) dx = 0;
if (y == 0) dy = 0;
PIC_Set( bimage.hImage, 255, 255, 255, 255 );
PIC_Draw( dx, dy, dw, dt );
xpos += bimage.width;
}
ypos += uiStatic.m_SteamBackground[y][0].height;
}
}
/*
=================
UI_LoadBackgroundImage
=================
*/
void UI_LoadBackgroundImage( void )
{
int num_background_images = 0;
char filename[512];
for( int y = 0; y < BACKGROUND_ROWS; y++ )
{
for( int x = 0; x < BACKGROUND_COLUMNS; x++ )
{
sprintf( filename, "resource/background/800_%d_%c_loading.tga", y + 1, 'a' + x );
if (g_engfuncs.pfnFileExists( filename, TRUE ))
num_background_images++;
}
}
if (num_background_images == (BACKGROUND_COLUMNS * BACKGROUND_ROWS))
uiStatic.m_fHaveSteamBackground = TRUE;
else uiStatic.m_fHaveSteamBackground = FALSE;
if (uiStatic.m_fHaveSteamBackground)
{
uiStatic.m_flTotalWidth = uiStatic.m_flTotalHeight = 0.0f;
for( int y = 0; y < BACKGROUND_ROWS; y++ )
{
for( int x = 0; x < BACKGROUND_COLUMNS; x++ )
{
bimage_t &bimage = uiStatic.m_SteamBackground[y][x];
sprintf(filename, "resource/background/800_%d_%c_loading.tga", y + 1, 'a' + x);
bimage.hImage = PIC_Load( filename, PIC_NOFLIP_TGA );
bimage.width = PIC_Width( bimage.hImage );
bimage.height = PIC_Height( bimage.hImage );
if (y==0) uiStatic.m_flTotalWidth += bimage.width;
if (x==0) uiStatic.m_flTotalHeight += bimage.height;
}
}
}
else
{
if( g_engfuncs.pfnFileExists( "gfx/shell/splash.bmp", TRUE ))
{
// if we doesn't have logo.avi in gamedir we don't want to draw it
if( !g_engfuncs.pfnFileExists( "media/logo.avi", TRUE ))
uiStatic.m_fDisableLogo = TRUE;
}
}
}
/*
=================
UI_StartSound
=================
*/
void UI_StartSound( const char *sound )
{
PLAY_SOUND( sound );
}
// =====================================================================
/*
=================
UI_AddItem
=================
*/
void UI_AddItem( menuFramework_s *menu, void *item )
{
menuCommon_s *generic = (menuCommon_s *)item;
if( menu->numItems >= UI_MAX_MENUITEMS )
HOST_ERROR( "UI_AddItem: UI_MAX_MENUITEMS limit exceeded\n" );
menu->items[menu->numItems] = item;
((menuCommon_s *)menu->items[menu->numItems])->parent = menu;
((menuCommon_s *)menu->items[menu->numItems])->flags &= ~QMF_HASMOUSEFOCUS;
menu->numItems++;
switch( generic->type )
{
case QMTYPE_SCROLLLIST:
UI_ScrollList_Init((menuScrollList_s *)item );
break;
case QMTYPE_SPINCONTROL:
UI_SpinControl_Init((menuSpinControl_s *)item );
break;
case QMTYPE_CHECKBOX:
UI_CheckBox_Init((menuCheckBox_s *)item );
break;
case QMTYPE_SLIDER:
UI_Slider_Init((menuSlider_s *)item );
break;
case QMTYPE_FIELD:
UI_Field_Init((menuField_s *)item );
break;
case QMTYPE_ACTION:
UI_Action_Init((menuAction_s *)item );
break;
case QMTYPE_BITMAP:
UI_Bitmap_Init((menuBitmap_s *)item );
break;
case QMTYPE_BM_BUTTON:
UI_PicButton_Init((menuPicButton_s *)item );
break;
default:
HOST_ERROR( "UI_AddItem: unknown item type (%i)\n", generic->type );
}
}
/*
=================
UI_CursorMoved
=================
*/
void UI_CursorMoved( menuFramework_s *menu )
{
void (*callback)( void *self, int event );
if( menu->cursor == menu->cursorPrev )
return;
if( menu->cursorPrev >= 0 && menu->cursorPrev < menu->numItems )
{
callback = ((menuCommon_s *)menu->items[menu->cursorPrev])->callback;
if( callback ) callback( menu->items[menu->cursorPrev], QM_LOSTFOCUS );
}
if( menu->cursor >= 0 && menu->cursor < menu->numItems )
{
callback = ((menuCommon_s *)menu->items[menu->cursor])->callback;
if( callback ) callback( menu->items[menu->cursor], QM_GOTFOCUS );
}
}
/*
=================
UI_SetCursor
=================
*/
void UI_SetCursor( menuFramework_s *menu, int cursor )
{
if(((menuCommon_s *)(menu->items[cursor]))->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN))
return;
menu->cursorPrev = menu->cursor;
menu->cursor = cursor;
UI_CursorMoved( menu );
}
/*
=================
UI_SetCursorToItem
=================
*/
void UI_SetCursorToItem( menuFramework_s *menu, void *item )
{
for( int i = 0; i < menu->numItems; i++ )
{
if( menu->items[i] == item )
{
UI_SetCursor( menu, i );
return;
}
}
}
/*
=================
UI_ItemAtCursor
=================
*/
void *UI_ItemAtCursor( menuFramework_s *menu )
{
if( menu->cursor < 0 || menu->cursor >= menu->numItems )
return 0;
// inactive items can't be has focus
if( ((menuCommon_s *)menu->items[menu->cursor])->flags & QMF_INACTIVE )
return 0;
return menu->items[menu->cursor];
}
/*
=================
UI_AdjustCursor
This functiont takes the given menu, the direction, and attempts to
adjust the menu's cursor so that it's at the next available slot
=================
*/
void UI_AdjustCursor( menuFramework_s *menu, int dir )
{
menuCommon_s *item;
int wrapped = false;
wrap:
while( menu->cursor >= 0 && menu->cursor < menu->numItems )
{
item = (menuCommon_s *)menu->items[menu->cursor];
if( item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN|QMF_MOUSEONLY))
menu->cursor += dir;
else break;
}
if( dir == 1 )
{
if( menu->cursor >= menu->numItems )
{
if( wrapped )
{
menu->cursor = menu->cursorPrev;
return;
}
menu->cursor = 0;
wrapped = true;
goto wrap;
}
}
else if( dir == -1 )
{
if( menu->cursor < 0 )
{
if( wrapped )
{
menu->cursor = menu->cursorPrev;
return;
}
menu->cursor = menu->numItems - 1;
wrapped = true;
goto wrap;
}
}
}
/*
=================
UI_DrawMenu
=================
*/
void UI_DrawMenu( menuFramework_s *menu )
{
static long statusFadeTime;
static menuCommon_s *lastItem;
menuCommon_s *item;
int i;
// draw contents
for( i = 0; i < menu->numItems; i++ )
{
item = (menuCommon_s *)menu->items[i];
if( item->flags & QMF_HIDDEN )
continue;
if( item->ownerdraw )
{
// total subclassing, owner draws everything
item->ownerdraw( item );
continue;
}
switch( item->type )
{
case QMTYPE_SCROLLLIST:
UI_ScrollList_Draw((menuScrollList_s *)item );
break;
case QMTYPE_SPINCONTROL:
UI_SpinControl_Draw((menuSpinControl_s *)item );
break;
case QMTYPE_CHECKBOX:
UI_CheckBox_Draw((menuCheckBox_s *)item );
break;
case QMTYPE_SLIDER:
UI_Slider_Draw((menuSlider_s *)item );
break;
case QMTYPE_FIELD:
UI_Field_Draw((menuField_s *)item );
break;
case QMTYPE_ACTION:
UI_Action_Draw((menuAction_s *)item );
break;
case QMTYPE_BITMAP:
UI_Bitmap_Draw((menuBitmap_s *)item );
break;
case QMTYPE_BM_BUTTON:
UI_PicButton_Draw((menuPicButton_s *)item );
break;
}
}
// draw status bar
item = (menuCommon_s *)UI_ItemAtCursor( menu );
if( item != lastItem )
{
// flash on selected button (like in GoldSrc)
if( item ) item->lastFocusTime = uiStatic.realTime;
statusFadeTime = uiStatic.realTime;
lastItem = item;
}
if( item && ( item->flags & QMF_HASMOUSEFOCUS && !( item->flags & QMF_NOTIFY )) && ( item->statusText != NULL ))
{
// fade it in, but wait a second
int alpha = bound( 0, ((( uiStatic.realTime - statusFadeTime ) - 1000 ) * 0.001f ) * 255, 255 );
int r, g, b, x, len;
GetConsoleStringSize( item->statusText, &len, NULL );
UnpackRGB( r, g, b, uiColorHelp );
TextMessageSetColor( r, g, b, alpha );
x = ( ScreenWidth - len ) * 0.5; // centering
DrawConsoleString( x, 720 * uiStatic.scaleY, item->statusText );
}
else statusFadeTime = uiStatic.realTime;
}
/*
=================
UI_DefaultKey
=================
*/
const char *UI_DefaultKey( menuFramework_s *menu, int key, int down )
{
const char *sound = NULL;
menuCommon_s *item;
int cursorPrev;
// menu system key
if( down && key == K_ESCAPE )
{
UI_PopMenu();
return uiSoundOut;
}
if( !menu || !menu->numItems )
return 0;
item = (menuCommon_s *)UI_ItemAtCursor( menu );
if( item && !(item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN)))
{
switch( item->type )
{
case QMTYPE_SCROLLLIST:
sound = UI_ScrollList_Key((menuScrollList_s *)item, key, down );
break;
case QMTYPE_SPINCONTROL:
sound = UI_SpinControl_Key((menuSpinControl_s *)item, key, down );
break;
case QMTYPE_CHECKBOX:
sound = UI_CheckBox_Key((menuCheckBox_s *)item, key, down );
break;
case QMTYPE_SLIDER:
sound = UI_Slider_Key((menuSlider_s *)item, key, down );
break;
case QMTYPE_FIELD:
sound = UI_Field_Key((menuField_s *)item, key, down );
break;
case QMTYPE_ACTION:
sound = UI_Action_Key((menuAction_s *)item, key, down );
break;
case QMTYPE_BITMAP:
sound = UI_Bitmap_Key((menuBitmap_s *)item, key, down );
break;
case QMTYPE_BM_BUTTON:
sound = UI_PicButton_Key((menuPicButton_s *)item, key, down );
break;
}
if( sound ) return sound; // key was handled
}
// system keys are always wait for keys down and never keys up
if( !down ) return 0;
// default handling
switch( key )
{
case K_UPARROW:
case K_KP_UPARROW:
case K_LEFTARROW:
case K_KP_LEFTARROW:
cursorPrev = menu->cursor;
menu->cursorPrev = menu->cursor;
menu->cursor--;
UI_AdjustCursor( menu, -1 );
if( cursorPrev != menu->cursor )
{
UI_CursorMoved( menu );
if( !(((menuCommon_s *)menu->items[menu->cursor])->flags & QMF_SILENT ))
sound = uiSoundMove;
}
break;
case K_DOWNARROW:
case K_KP_DOWNARROW:
case K_RIGHTARROW:
case K_KP_RIGHTARROW:
case K_TAB:
cursorPrev = menu->cursor;
menu->cursorPrev = menu->cursor;
menu->cursor++;
UI_AdjustCursor(menu, 1);
if( cursorPrev != menu->cursor )
{
UI_CursorMoved(menu);
if( !(((menuCommon_s *)menu->items[menu->cursor])->flags & QMF_SILENT ))
sound = uiSoundMove;
}
break;
case K_MOUSE1:
if( item )
{
if((item->flags & QMF_HASMOUSEFOCUS) && !(item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN)))
return UI_ActivateItem( menu, item );
}
break;
case K_ENTER:
case K_KP_ENTER:
if( item )
{
if( !(item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN|QMF_MOUSEONLY)))
return UI_ActivateItem( menu, item );
}
break;
}
return sound;
}
/*
=================
UI_ActivateItem
=================
*/
const char *UI_ActivateItem( menuFramework_s *menu, menuCommon_s *item )
{
if( item->callback )
{
item->callback( item, QM_ACTIVATED );
if( !( item->flags & QMF_SILENT ))
return uiSoundMove;
}
return 0;
}
/*
=================
UI_RefreshServerList
=================
*/
void UI_RefreshServerList( void )
{
uiStatic.numServers = 0;
memset( uiStatic.serverAddresses, 0, sizeof( uiStatic.serverAddresses ));
memset( uiStatic.serverNames, 0, sizeof( uiStatic.serverNames ));
CLIENT_COMMAND( FALSE, "localservers\n" );
}
/*
=================
UI_RefreshInternetServerList
=================
*/
void UI_RefreshInternetServerList( void )
{
uiStatic.numServers = 0;
memset( uiStatic.serverAddresses, 0, sizeof( uiStatic.serverAddresses ));
memset( uiStatic.serverNames, 0, sizeof( uiStatic.serverNames ));
CLIENT_COMMAND( FALSE, "internetservers\n" );
}
/*
=================
UI_StartBackGroundMap
=================
*/
bool UI_StartBackGroundMap( void )
{
static bool first = TRUE;
if( !first ) return FALSE;
first = FALSE;
// some map is already running
if( !uiStatic.bgmapcount || CL_IsActive() || gpGlobals->demoplayback )
return FALSE;
int bgmapid = RANDOM_LONG( 0, uiStatic.bgmapcount - 1 );
char cmd[128];
sprintf( cmd, "maps/%s.bsp", uiStatic.bgmaps[bgmapid] );
if( !FILE_EXISTS( cmd )) return FALSE;
sprintf( cmd, "map_background %s\n", uiStatic.bgmaps[bgmapid] );
CLIENT_COMMAND( FALSE, cmd );
return TRUE;
}
// =====================================================================
/*
=================
UI_CloseMenu
=================
*/
void UI_CloseMenu( void )
{
uiStatic.menuActive = NULL;
uiStatic.menuDepth = 0;
uiStatic.visible = false;
// clearing serverlist
uiStatic.numServers = 0;
memset( uiStatic.serverAddresses, 0, sizeof( uiStatic.serverAddresses ));
memset( uiStatic.serverNames, 0, sizeof( uiStatic.serverNames ));
UI_ClearButtonStack ();
// KEY_ClearStates ();
KEY_SetDest ( KEY_GAME );
}
/*
=================
UI_PushMenu
=================
*/
void UI_PushMenu( menuFramework_s *menu )
{
int i;
menuCommon_s *item;
// if this menu is already present, drop back to that level to avoid stacking menus by hotkeys
for( i = 0; i < uiStatic.menuDepth; i++ )
{
if( uiStatic.menuStack[i] == menu )
{
uiStatic.menuDepth = i;
break;
}
}
if( i == uiStatic.menuDepth )
{
if( uiStatic.menuDepth >= UI_MAX_MENUDEPTH )
HOST_ERROR( "UI_PushMenu: menu stack overflow\n" );
uiStatic.menuStack[uiStatic.menuDepth++] = menu;
}
uiStatic.menuActive = menu;
uiStatic.firstDraw = true;
uiStatic.enterSound = gpGlobals->time + 0.15; // make some delay
uiStatic.visible = true;
KEY_SetDest ( KEY_MENU );
menu->cursor = 0;
menu->cursorPrev = 0;
// force first available item to have focus
for( i = 0; i < menu->numItems; i++ )
{
item = (menuCommon_s *)menu->items[i];
if( item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN|QMF_MOUSEONLY))
continue;
menu->cursorPrev = -1;
UI_SetCursor( menu, i );
break;
}
}
/*
=================
UI_PopMenu
=================
*/
void UI_PopMenu( void )
{
UI_StartSound( uiSoundOut );
uiStatic.menuDepth--;
if( uiStatic.menuDepth < 0 )
HOST_ERROR( "UI_PopMenu: menu stack underflow\n" );
UI_PopPButtonStack();
if( uiStatic.menuDepth )
{
uiStatic.menuActive = uiStatic.menuStack[uiStatic.menuDepth-1];
uiStatic.firstDraw = true;
}
else if ( CL_IsActive( ))
{
UI_CloseMenu();
}
else
{
// never trying the close menu when client isn't connected
KEY_SetDest( KEY_MENU );
UI_Main_Menu();
}
if( uiStatic.m_fDemosPlayed && uiStatic.m_iOldMenuDepth == uiStatic.menuDepth )
{
CLIENT_COMMAND( FALSE, "demos\n" );
uiStatic.m_fDemosPlayed = false;
uiStatic.m_iOldMenuDepth = 0;
}
}
// =====================================================================
/*
=================
UI_UpdateMenu
=================
*/
void UI_UpdateMenu( float flTime )
{
if( !uiStatic.initialized )
return;
UI_DrawFinalCredits ();
if( !uiStatic.visible )
return;
if( !uiStatic.menuActive )
return;
uiStatic.realTime = flTime * 1000;
uiStatic.framecount++;
if( CVAR_GET_FLOAT( "cl_background" ) && !g_engfuncs.pfnClientInGame())
return; // don't draw menu while level is loading
if( uiStatic.firstDraw )
{
// we loading background so skip SCR_Update
if( UI_StartBackGroundMap( )) return;
if( uiStatic.menuActive->activateFunc )
uiStatic.menuActive->activateFunc();
}
// draw menu
if( uiStatic.menuActive->drawFunc )
uiStatic.menuActive->drawFunc();
else UI_DrawMenu( uiStatic.menuActive );
if( uiStatic.firstDraw )
{
uiStatic.firstDraw = false;
static int first = TRUE;
if( first )
{
// if game was launched with commandline e.g. +map or +load ignore the music
if( !CL_IsActive( ))
BACKGROUND_TRACK( "gamestartup", "gamestartup" );
first = FALSE;
}
}
//CR
UI_DrawTitleAnim();
//
// draw cursor
UI_DrawMouseCursor();
// delay playing the enter sound until after the menu has been
// drawn, to avoid delay while caching images
if( uiStatic.enterSound > 0.0f && uiStatic.enterSound <= gpGlobals->time )
{
UI_StartSound( uiSoundIn );
uiStatic.enterSound = -1;
}
}
/*
=================
UI_KeyEvent
=================
*/
void UI_KeyEvent( int key, int down )
{
const char *sound;
if( !uiStatic.initialized )
return;
if( !uiStatic.visible )
return;
if( !uiStatic.menuActive )
return;
if( uiStatic.menuActive->keyFunc )
sound = uiStatic.menuActive->keyFunc( key, down );
else sound = UI_DefaultKey( uiStatic.menuActive, key, down );
if( !down ) return;
if( sound && sound != uiSoundNull )
UI_StartSound( sound );
}
/*
=================
UI_CharEvent
=================
*/
void UI_CharEvent( int key )
{
menuFramework_s *menu;
menuCommon_s *item;
if( !uiStatic.initialized )
return;
if( !uiStatic.visible )
return;
if( !uiStatic.menuActive )
return;
menu = uiStatic.menuActive;
if( !menu || !menu->numItems )
return;
item = (menuCommon_s *)UI_ItemAtCursor( menu );
if( item && !(item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN)))
{
switch( item->type )
{
case QMTYPE_FIELD:
UI_Field_Char((menuField_s *)item, key );
break;
}
}
}
/*
=================
UI_MouseMove
=================
*/
void UI_MouseMove( int x, int y )
{
int i;
menuCommon_s *item;
if( !uiStatic.initialized )
return;
if( !uiStatic.visible )
return;
if( !uiStatic.menuActive )
return;
// now menu uses absolute coordinates
uiStatic.cursorX = x;
uiStatic.cursorY = y;
if( UI_CursorInRect( 1, 1, ScreenWidth - 1, ScreenHeight - 1 ))
uiStatic.mouseInRect = true;
else uiStatic.mouseInRect = false;
uiStatic.cursorX = bound( 0, uiStatic.cursorX, ScreenWidth );
uiStatic.cursorY = bound( 0, uiStatic.cursorY, ScreenHeight );
// region test the active menu items
for( i = 0; i < uiStatic.menuActive->numItems; i++ )
{
item = (menuCommon_s *)uiStatic.menuActive->items[i];
if( item->flags & (QMF_GRAYED|QMF_INACTIVE|QMF_HIDDEN))
{
if( item->flags & QMF_HASMOUSEFOCUS )
{
if( !UI_CursorInRect( item->x, item->y, item->width, item->height ))
item->flags &= ~QMF_HASMOUSEFOCUS;
else item->lastFocusTime = uiStatic.realTime;
}
continue;
}
if( !UI_CursorInRect( item->x, item->y, item->width, item->height ))
{
item->bPressed = false;
continue;
}
// set focus to item at cursor
if( uiStatic.menuActive->cursor != i )
{
UI_SetCursor( uiStatic.menuActive, i );
((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursorPrev]))->flags &= ~QMF_HASMOUSEFOCUS;
if (!(((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->flags & QMF_SILENT ))
UI_StartSound( uiSoundMove );
}
((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->flags |= QMF_HASMOUSEFOCUS;
((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->lastFocusTime = uiStatic.realTime;
return;
}
// out of any region
if( uiStatic.menuActive->numItems )
{
((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->flags &= ~QMF_HASMOUSEFOCUS;
((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->bPressed = false;
// a mouse only item restores focus to the previous item
if(((menuCommon_s *)(uiStatic.menuActive->items[uiStatic.menuActive->cursor]))->flags & QMF_MOUSEONLY )
{
if( uiStatic.menuActive->cursorPrev != -1 )
uiStatic.menuActive->cursor = uiStatic.menuActive->cursorPrev;
}
}
}
/*
=================
UI_SetActiveMenu
=================
*/
void UI_SetActiveMenu( int fActive )
{
if( !uiStatic.initialized )
return;
// don't continue firing if we leave game
KEY_ClearStates();
uiStatic.framecount = 0;
if( fActive )
{
KEY_SetDest( KEY_MENU );
UI_Main_Menu();
}
else
{
UI_CloseMenu();
}
}
/*
=================
UI_AddServerToList
=================
*/
void UI_AddServerToList( netadr_t adr, const char *info )
{
int i;
if( !uiStatic.initialized )
return;
if( uiStatic.numServers == UI_MAX_SERVERS )
return; // full
if( stricmp( gMenu.m_gameinfo.gamefolder, Info_ValueForKey( info, "gamedir" )))
return;
// ignore if duplicated
for( i = 0; i < uiStatic.numServers; i++ )
{
if( !stricmp( uiStatic.serverNames[i], info ))
return;
}
// add it to the list
uiStatic.updateServers = true; // info has been updated
uiStatic.serverAddresses[uiStatic.numServers] = adr;
strncpy( uiStatic.serverNames[uiStatic.numServers], info, sizeof( uiStatic.serverNames[uiStatic.numServers] ));
uiStatic.numServers++;
}
/*
=================
UI_IsVisible
Some systems may need to know if it is visible or not
=================
*/
int UI_IsVisible( void )
{
if( !uiStatic.initialized )
return false;
return uiStatic.visible;
}
void UI_GetCursorPos( int *pos_x, int *pos_y )
{
if( pos_x ) *pos_x = uiStatic.cursorX;
if( pos_y ) *pos_y = uiStatic.cursorY;
}
void UI_SetCursorPos( int pos_x, int pos_y )
{
// uiStatic.cursorX = bound( 0, pos_x, ScreenWidth );
// uiStatic.cursorY = bound( 0, pos_y, ScreenHeight );
uiStatic.mouseInRect = true;
}
void UI_ShowCursor( int show )
{
uiStatic.hideCursor = (show) ? false : true;
}
int UI_MouseInRect( void )
{
return uiStatic.mouseInRect;
}
/*
=================
UI_Precache
=================
*/
void UI_Precache( void )
{
if( !uiStatic.initialized )
return;
if( !ui_precache->value )
return;
PIC_Load( UI_LEFTARROW );
PIC_Load( UI_LEFTARROWFOCUS );
PIC_Load( UI_RIGHTARROW );
PIC_Load( UI_RIGHTARROWFOCUS );
PIC_Load( UI_UPARROW );
PIC_Load( UI_UPARROWFOCUS );
PIC_Load( UI_DOWNARROW );
PIC_Load( UI_DOWNARROWFOCUS );
if( ui_precache->value == 1 )
return;
UI_Main_Precache();
UI_NewGame_Precache();
UI_LoadGame_Precache();
UI_SaveGame_Precache();
UI_SaveLoad_Precache();
UI_MultiPlayer_Precache();
UI_Options_Precache();
UI_InternetGames_Precache();
UI_LanGame_Precache();
UI_PlayerSetup_Precache();
UI_Controls_Precache();
UI_AdvControls_Precache();
UI_GameOptions_Precache();
UI_CreateGame_Precache();
UI_Audio_Precache();
UI_Video_Precache();
UI_VidOptions_Precache();
UI_VidModes_Precache();
UI_CustomGame_Precache();
UI_Credits_Precache();
}
void UI_ParseColor( char *&pfile, int *outColor )
{
int i, color[3];
char token[1024];
memset( color, 0xFF, sizeof( color ));
for( i = 0; i < 3; i++ )
{
pfile = COM_ParseFile( pfile, token );
if( !pfile ) break;
color[i] = atoi( token );
}
*outColor = PackRGB( color[0], color[1], color[2] );
}
void UI_ApplyCustomColors( void )
{
char *afile = (char *)LOAD_FILE( "gfx/shell/colors.lst", NULL );
char *pfile = afile;
char token[1024];
if( !afile )
{
// not error, not warning, just notify
Con_Printf( "UI_SetColors: colors.lst not found\n" );
return;
}
while(( pfile = COM_ParseFile( pfile, token )) != NULL )
{
if( !stricmp( token, "HELP_COLOR" ))
{
UI_ParseColor( pfile, &uiColorHelp );
}
else if( !stricmp( token, "PROMPT_BG_COLOR" ))
{
UI_ParseColor( pfile, &uiPromptBgColor );
}
else if( !stricmp( token, "PROMPT_TEXT_COLOR" ))
{
UI_ParseColor( pfile, &uiPromptTextColor );
}
else if( !stricmp( token, "PROMPT_FOCUS_COLOR" ))
{
UI_ParseColor( pfile, &uiPromptFocusColor );
}
else if( !stricmp( token, "INPUT_TEXT_COLOR" ))
{
UI_ParseColor( pfile, &uiInputTextColor );
}
else if( !stricmp( token, "INPUT_BG_COLOR" ))
{
UI_ParseColor( pfile, &uiInputBgColor );
}
else if( !stricmp( token, "INPUT_FG_COLOR" ))
{
UI_ParseColor( pfile, &uiInputFgColor );
}
else if( !stricmp( token, "CON_TEXT_COLOR" ))
{
UI_ParseColor( pfile, &uiColorConsole );
}
}
int r, g, b;
UnpackRGB( r, g, b, uiColorConsole );
ConsoleSetColor( r, g, b );
FREE_FILE( afile );
}
static void UI_LoadBackgroundMapList( void )
{
if( !g_engfuncs.pfnFileExists( "scripts/chapterbackgrounds.txt", TRUE ))
return;
char *afile = (char *)LOAD_FILE( "scripts/chapterbackgrounds.txt", NULL );
char *pfile = afile;
char token[1024];
uiStatic.bgmapcount = 0;
if( !afile )
{
Con_Printf( "UI_LoadBackgroundMapList: chapterbackgrounds.txt not found\n" );
return;
}
while(( pfile = COM_ParseFile( pfile, token )) != NULL )
{
// skip the numbers (old format list)
if( isdigit( token[0] )) continue;
strncpy( uiStatic.bgmaps[uiStatic.bgmapcount], token, sizeof( uiStatic.bgmaps[0] ) - 1 );
if( ++uiStatic.bgmapcount > UI_MAX_BGMAPS )
break; // list is full
}
FREE_FILE( afile );
}
/*
=================
UI_VidInit
=================
*/
int UI_VidInit( void )
{
UI_Precache ();
uiStatic.scaleX = ScreenWidth / 1024.0f;
uiStatic.scaleY = ScreenHeight / 768.0f;
// move cursor to screen center
uiStatic.cursorX = ScreenWidth >> 1;
uiStatic.cursorY = ScreenHeight >> 1;
uiStatic.outlineWidth = 4;
uiStatic.sliderWidth = 6;
// all menu buttons have the same view sizes
uiStatic.buttons_draw_width = UI_BUTTONS_WIDTH;
uiStatic.buttons_draw_height = UI_BUTTONS_HEIGHT;
UI_ScaleCoords( NULL, NULL, &uiStatic.outlineWidth, NULL );
UI_ScaleCoords( NULL, NULL, &uiStatic.sliderWidth, NULL );
UI_ScaleCoords( NULL, NULL, &uiStatic.buttons_draw_width, &uiStatic.buttons_draw_height );
// trying to load colors.lst
UI_ApplyCustomColors ();
// trying to load chapterbackgrounds.txt
UI_LoadBackgroundMapList ();
// register menu font
uiStatic.hFont = PIC_Load( "#XASH_SYSTEMFONT_001.bmp", menufont_bmp, sizeof( menufont_bmp ));
UI_LoadBackgroundImage ();
#if 0
FILE *f;
// dump menufont onto disk
f = fopen( "menufont.bmp", "wb" );
fwrite( menufont_bmp, sizeof( menufont_bmp ), 1, f );
fclose( f );
#endif
// reload all menu buttons
UI_LoadBmpButtons ();
// now recalc all the menus in stack
for( int i = 0; i < uiStatic.menuDepth; i++ )
{
menuFramework_s *item = uiStatic.menuStack[i];
// do vid restart for all pushed elements
if( item && item->vidInitFunc )
item->vidInitFunc();
}
return 1;
}
/*
=================
UI_Init
=================
*/
void UI_Init( void )
{
// register our cvars and commands
ui_precache = CVAR_REGISTER( "ui_precache", "0", FCVAR_ARCHIVE );
ui_showmodels = CVAR_REGISTER( "ui_showmodels", "0", FCVAR_ARCHIVE );
ui_videoconfig = CVAR_REGISTER( "video_config", "high", FCVAR_ARCHIVE );
Cmd_AddCommand( "menu_main", UI_Main_Menu );
Cmd_AddCommand( "menu_newgame", UI_NewGame_Menu );
Cmd_AddCommand( "menu_loadgame", UI_LoadGame_Menu );
Cmd_AddCommand( "menu_savegame", UI_SaveGame_Menu );
Cmd_AddCommand( "menu_saveload", UI_SaveLoad_Menu );
Cmd_AddCommand( "menu_multiplayer", UI_MultiPlayer_Menu );
Cmd_AddCommand( "menu_options", UI_Options_Menu );
Cmd_AddCommand( "menu_langame", UI_LanGame_Menu );
Cmd_AddCommand( "menu_internetgames", UI_InternetGames_Menu );
Cmd_AddCommand( "menu_playersetup", UI_PlayerSetup_Menu );
Cmd_AddCommand( "menu_controls", UI_Controls_Menu );
Cmd_AddCommand( "menu_advcontrols", UI_AdvControls_Menu );
Cmd_AddCommand( "menu_gameoptions", UI_GameOptions_Menu );
Cmd_AddCommand( "menu_creategame", UI_CreateGame_Menu );
Cmd_AddCommand( "menu_audio", UI_Audio_Menu );
Cmd_AddCommand( "menu_video", UI_Video_Menu );
Cmd_AddCommand( "menu_vidoptions", UI_VidOptions_Menu );
Cmd_AddCommand( "menu_vidmodes", UI_VidModes_Menu );
Cmd_AddCommand( "menu_customgame", UI_CustomGame_Menu );
CHECK_MAP_LIST( TRUE );
memset( uiEmptyString, ' ', sizeof( uiEmptyString )); // HACKHACK
uiStatic.initialized = true;
// setup game info
GetGameInfo( &gMenu.m_gameinfo );
// load custom strings
UI_LoadCustomStrings();
//CR
UI_InitTitleAnim();
}
/*
=================
UI_Shutdown
=================
*/
void UI_Shutdown( void )
{
if( !uiStatic.initialized )
return;
Cmd_RemoveCommand( "menu_main" );
Cmd_RemoveCommand( "menu_newgame" );
Cmd_RemoveCommand( "menu_loadgame" );
Cmd_RemoveCommand( "menu_savegame" );
Cmd_RemoveCommand( "menu_saveload" );
Cmd_RemoveCommand( "menu_multiplayer" );
Cmd_RemoveCommand( "menu_options" );
Cmd_RemoveCommand( "menu_internetgames" );
Cmd_RemoveCommand( "menu_langame" );
Cmd_RemoveCommand( "menu_playersetup" );
Cmd_RemoveCommand( "menu_controls" );
Cmd_RemoveCommand( "menu_advcontrols" );
Cmd_RemoveCommand( "menu_gameoptions" );
Cmd_RemoveCommand( "menu_creategame" );
Cmd_RemoveCommand( "menu_audio" );
Cmd_RemoveCommand( "menu_video" );
Cmd_RemoveCommand( "menu_vidoptions" );
Cmd_RemoveCommand( "menu_vidmodes" );
Cmd_RemoveCommand( "menu_advanced" );
Cmd_RemoveCommand( "menu_performance" );
Cmd_RemoveCommand( "menu_network" );
Cmd_RemoveCommand( "menu_defaults" );
Cmd_RemoveCommand( "menu_cinematics" );
Cmd_RemoveCommand( "menu_customgame" );
memset( &uiStatic, 0, sizeof( uiStatic_t ));
}
Reference in New Issue Copy Permalink