JKA: MP Source

01064              {
01065         AWARD_ACCURACY,
01066         AWARD_IMPRESSIVE,
01067         AWARD_EXCELLENT,
01068         AWARD_GAUNTLET,
01069         AWARD_FRAGS,
01070         AWARD_PERFECT
01071 } awardType_t;

10406                                                {
10407         char buf[256];
10408 
10409         // this should be the ONLY way the menu system is brought up
10410         // enusure minumum menu data is cached
10411   if (Menu_Count() > 0) {
10412                 vec3_t v;
10413                 v[0] = v[1] = v[2] = 0;
10414           switch ( menu ) {
10415           case UIMENU_NONE:
10416                         trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
10417                         trap_Key_ClearStates();
10418                         trap_Cvar_Set( "cl_paused", "0" );
10419                         Menus_CloseAll();
10420 
10421                   return;
10422           case UIMENU_MAIN:
10423                 {
10424                         qboolean active = qfalse;
10425 
10426                         //trap_Cvar_Set( "sv_killserver", "1" );
10427                         trap_Key_SetCatcher( KEYCATCH_UI );
10428                         //trap_S_StartLocalSound( trap_S_RegisterSound("sound/misc/menu_background.wav", qfalse) , CHAN_LOCAL_SOUND );
10429                         //trap_S_StartBackgroundTrack("sound/misc/menu_background.wav", NULL);
10430                         if (uiInfo.inGameLoad) 
10431                         {
10432 //                              UI_LoadNonIngame();
10433                         }
10434                         
10435                         Menus_CloseAll();
10436                         Menus_ActivateByName("main");
10437                         trap_Cvar_VariableStringBuffer("com_errorMessage", buf, sizeof(buf));
10438                         
10439                         if (buf[0]) 
10440                         {
10441                                 if (!ui_singlePlayerActive.integer) 
10442                                 {
10443 #ifdef _XBOX
10444                                         // Display Xbox popups after an ERR_DROP?
10445                                         UI_xboxErrorPopup( XB_POPUP_COM_ERROR );
10446 #else
10447                                         Menus_ActivateByName("error_popmenu");
10448 #endif
10449                                         active = qtrue;
10450                                 } 
10451                                 else 
10452                                 {
10453                                         trap_Cvar_Set("com_errorMessage", "");
10454                                 }
10455                         }
10456                         return;
10457                 }
10458 
10459           case UIMENU_TEAM:
10460                         trap_Key_SetCatcher( KEYCATCH_UI );
10461       Menus_ActivateByName("team");
10462                   return;
10463           case UIMENU_POSTGAME:
10464                         //trap_Cvar_Set( "sv_killserver", "1" );
10465                         trap_Key_SetCatcher( KEYCATCH_UI );
10466                         if (uiInfo.inGameLoad) {
10467 //                              UI_LoadNonIngame();
10468                         }
10469                         Menus_CloseAll();
10470                         Menus_ActivateByName("endofgame");
10471                   //UI_ConfirmMenu( "Bad CD Key", NULL, NeedCDKeyAction );
10472                   return;
10473           case UIMENU_INGAME:
10474                   trap_Cvar_Set( "cl_paused", "1" );
10475                         trap_Key_SetCatcher( KEYCATCH_UI );
10476                         UI_BuildPlayerList();
10477                         Menus_CloseAll();
10478                         Menus_ActivateByName("ingame");
10479                   return;
10480           case UIMENU_PLAYERCONFIG:
10481                  // trap_Cvar_Set( "cl_paused", "1" );
10482                         trap_Key_SetCatcher( KEYCATCH_UI );
10483                         UI_BuildPlayerList();
10484                         Menus_CloseAll();
10485                         Menus_ActivateByName("ingame_player");
10486                         UpdateForceUsed();
10487                   return;
10488           case UIMENU_PLAYERFORCE:
10489                  // trap_Cvar_Set( "cl_paused", "1" );
10490                         trap_Key_SetCatcher( KEYCATCH_UI );
10491                         UI_BuildPlayerList();
10492                         Menus_CloseAll();
10493                         Menus_ActivateByName("ingame_playerforce");
10494                         UpdateForceUsed();
10495                   return;
10496           case UIMENU_SIEGEMESSAGE:
10497                  // trap_Cvar_Set( "cl_paused", "1" );
10498                         trap_Key_SetCatcher( KEYCATCH_UI );
10499                         Menus_CloseAll();
10500                         Menus_ActivateByName("siege_popmenu");
10501                   return;
10502           case UIMENU_SIEGEOBJECTIVES:
10503                  // trap_Cvar_Set( "cl_paused", "1" );
10504                         trap_Key_SetCatcher( KEYCATCH_UI );
10505                         Menus_CloseAll();
10506                         Menus_ActivateByName("ingame_siegeobjectives");
10507                         return;
10508           case UIMENU_VOICECHAT:
10509                  // trap_Cvar_Set( "cl_paused", "1" );
10510                         // No chatin non-siege games.
10511                  
10512                         if (trap_Cvar_VariableValue( "g_gametype" ) < GT_TEAM)
10513                         {
10514                                 return;
10515                         }
10516                                  
10517                         trap_Key_SetCatcher( KEYCATCH_UI );
10518                         Menus_CloseAll();
10519                         Menus_ActivateByName("ingame_voicechat");
10520                         return;
10521           case UIMENU_CLOSEALL:
10522                         Menus_CloseAll();
10523                         return;
10524           case UIMENU_CLASSSEL:
10525                         trap_Key_SetCatcher( KEYCATCH_UI );
10526                         Menus_CloseAll();
10527                         Menus_ActivateByName("ingame_siegeclass");
10528                   return;
10529           }
10530   }
10531 }

00318 {
00319         return syscall( CG_ANYLANGUAGE_READCHARFROMSTRING, psText, piAdvanceCount, pbIsTrailingPunctuation);
00320 }

00071                                   {
00072         return syscall( CG_ARGC );
00073 }

00075                                                            {
00076         syscall( CG_ARGV, n, buffer, bufferLength );
00077 }

00602                                          {
00603   syscall(CG_CIN_DRAWCINEMATIC, handle);
00604 }

00584                                                                                                    {
00585   return syscall(CG_CIN_PLAYCINEMATIC, arg0, xpos, ypos, width, height, bits);
00586 }

00596                                             {
00597   return syscall(CG_CIN_RUNCINEMATIC, handle);
00598 }

00608                                                                   {
00609   syscall(CG_CIN_SETEXTENTS, handle, x, y, w, h);
00610 }

00590                                             {
00591   return syscall(CG_CIN_STOPCINEMATIC, handle);
00592 }

00206                                                                                                                            {
00207         return syscall( UI_CM_LERPTAG, tag, mod, startFrame, endFrame, PASSFLOAT(frac), tagName );
00208 }

00079                                                              {
00080         syscall( UI_CMD_EXECUTETEXT, exec_when, text );
00081 }

00063                                                                                 {
00064         syscall( UI_CVAR_CREATE, var_name, var_value, flags );
00065 }

00067                                                                       {
00068         syscall( UI_CVAR_INFOSTRINGBUFFER, bit, buffer, bufsize );
00069 }

00050                                                                                                          {
00051         syscall( CG_CVAR_REGISTER, vmCvar, varName, defaultValue, flags );
00052 }

00059                                          {
00060         syscall( UI_CVAR_RESET, name ); 
00061 }

00058                                                                  {
00059         syscall( CG_CVAR_SET, var_name, value );
00060 }

00055                                                              {
00056         syscall( UI_CVAR_SETVALUE, var_name, PASSFLOAT( value ) );
00057 }

00054                                              {
00055         syscall( CG_CVAR_UPDATE, vmCvar );
00056 }

00062                                                                                        {
00063         syscall( CG_CVAR_VARIABLESTRINGBUFFER, var_name, buffer, bufsize );
00064 }

00036                                                       {
00037         char buf[128];
00038 
00039         trap_Cvar_VariableStringBuffer(var_name, buf, sizeof(buf));
00040         return atof(buf);
00041 }

00025                                       {
00026         syscall( CG_ERROR, fmt );
00027 }

00095                                              {
00096         syscall( CG_FS_FCLOSEFILE, f );
00097 }

00083                                                                                        {
00084         return syscall( CG_FS_FOPENFILE, qpath, f, mode );
00085 }

00099                                                                                                 {
00100         return syscall( CG_FS_GETFILELIST, path, extension, listbuf, bufsize );
00101 }

00087                                                               {
00088         syscall( CG_FS_READ, buffer, len, f );
00089 }

00091                                                                      {
00092         syscall( CG_FS_WRITE, buffer, len, f );
00093 }

00258                                                    {
00259         syscall( UI_GETCLIENTSTATE, state );
00260 }

00254                                                      {
00255         syscall( UI_GETCLIPBOARDDATA, buf, bufsize );
00256 }

00266                                                                 {
00267         return syscall( UI_GETCONFIGSTRING, index, buff, buffsize );
00268 }

00461                                                          {
00462         syscall( CG_GETGLCONFIG, glconfig );
00463 }

00242                                   {
00243         syscall( UI_KEY_CLEARSTATES );
00244 }

00222                                                                  {
00223         syscall( UI_KEY_GETBINDINGBUF, keynum, buf, buflen );
00224 }

00529                                 {
00530         return syscall( CG_KEY_GETCATCHER );
00531 }

00234                                             {
00235         return syscall( UI_KEY_GETOVERSTRIKEMODE );
00236 }

00525                                        {
00526         return syscall( CG_KEY_ISDOWN, keynum );
00527 }

00218                                                                      {
00219         syscall( UI_KEY_KEYNUMTOSTRINGBUF, keynum, buf, buflen );
00220 }

00226                                                             {
00227         syscall( UI_KEY_SETBINDING, keynum, binding );
00228 }

00533                                         {
00534         syscall( CG_KEY_SETCATCHER, catcher );
00535 }

00238                                                   {
00239         syscall( UI_KEY_SETOVERSTRIKEMODE, state );
00240 }

00330                                                                        {
00331         return syscall( UI_LAN_ADDSERVER, source, name, addr );
00332 }

00306                                  {
00307         syscall( UI_LAN_CLEARPING, n );
00308 }

00338                                                                                     {
00339         return syscall( UI_LAN_COMPARESERVERS, source, sortKey, sortDir, s1, s2 );
00340 }

00310                                                                      {
00311         syscall( UI_LAN_GETPING, n, buf, buflen, pingtime );
00312 }

00314                                                           {
00315         syscall( UI_LAN_GETPINGINFO, n, buf, buflen );
00316 }

00286                                        {
00287         return syscall( UI_LAN_GETPINGQUEUECOUNT );
00288 }

00274                                                                                  {
00275         syscall( UI_LAN_GETSERVERADDRESSSTRING, source, n, buf, buflen );
00276 }

00270                                               {
00271         return syscall( UI_LAN_GETSERVERCOUNT, source );
00272 }

00278                                                                         {
00279         syscall( UI_LAN_GETSERVERINFO, source, n, buf, buflen );
00280 }

00282                                                 {
00283         return syscall( UI_LAN_GETSERVERPING, source, n );
00284 }

00298                                   {
00299         syscall( UI_LAN_LOADCACHEDSERVERS );
00300 }

00318                                                                        {
00319         syscall( UI_LAN_MARKSERVERVISIBLE, source, n, visible );
00320 }

00334                                                          {
00335         syscall( UI_LAN_REMOVESERVER, source, addr );
00336 }

00302                                 {
00303         syscall( UI_LAN_RESETPINGS, n );
00304 }

00294                                   {
00295         syscall( UI_LAN_SAVECACHEDSERVERS );
00296 }

00322                                                  {
00323         return syscall( UI_LAN_SERVERISVISIBLE, source, n );
00324 }

00290                                                                                        {
00291         return syscall( UI_LAN_SERVERSTATUS, serverAddress, serverStatus, maxLen );
00292 }

00326                                                    {
00327         return syscall( UI_LAN_UPDATEVISIBLEPINGS, source );
00328 }

00308 {
00309         return syscall( CG_LANGUAGE_ISASIAN );
00310 }

00313 {
00314         return syscall( CG_LANGUAGE_USESSPACES );
00315 }

00521                                  {
00522         return syscall( CG_MEMORY_REMAINING );
00523 }

00029                                           {
00030         return syscall( CG_MILLISECONDS ); 
00031 }

00021                                       {
00022         syscall( CG_PRINT, fmt );
00023 }

00352                                                                                                {
00353         syscall( CG_R_ADDLIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
00354 }

00335                                                                                            {
00336         syscall( CG_R_ADDPOLYTOSCENE, hShader, numVerts, verts );
00337 }

00331                                                             {
00332         syscall( CG_R_ADDREFENTITYTOSCENE, re );
00333 }

00322                                   {
00323         syscall( CG_R_CLEARSCENE );
00324 }

00369                                                                                                                        {
00370         syscall( CG_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
00371 }

00303 {
00304         syscall( CG_R_FONT_DRAWSTRING, ox, oy, text, rgba, setIndex, iCharLimit, PASSFLOAT(scale));
00305 }

00298 {
00299         return syscall( CG_R_FONT_STRHEIGHTPIXELS, iFontIndex, PASSFLOAT(scale));
00300 }

00293 {
00294         return syscall( CG_R_FONT_STRLENCHARS, text);
00295 }

00288 {
00289         return syscall( CG_R_FONT_STRLENPIXELS, text, iFontIndex, PASSFLOAT(scale));
00290 }

00373                                                                            {
00374         syscall( CG_R_MODELBOUNDS, model, mins, maxs );
00375 }

00283 {
00284         return syscall( CG_R_REGISTERFONT, fontName);
00285 }

00266                                                    {
00267         return syscall( CG_R_REGISTERMODEL, name );
00268 }

00278                                                          {
00279         return syscall( CG_R_REGISTERSHADERNOMIP, name );
00280 }

00270                                                   {
00271         return syscall( CG_R_REGISTERSKIN, name );
00272 }

00407 {
00408         syscall( CG_R_REMAP_SHADER, oldShader, newShader, timeOffset );
00409 }

00360                                                  {
00361         syscall( CG_R_RENDERSCENE, fd );
00362 }

00364                                              {
00365         syscall( CG_R_SETCOLOR, rgba );
00366 }

00166 {
00167         syscall( UI_R_SHADERNAMEFROMINDEX, name, index );
00168 }

00575                                   {
00576         return syscall( CG_REAL_TIME, qtime );
00577 }

00229                                                            {
00230         return syscall( CG_S_REGISTERSOUND, sample );
00231 }

00233                                                                                                              {
00234         syscall( CG_S_STARTBACKGROUNDTRACK, intro, loop, bReturnWithoutStarting  );
00235 }

00196                                                                   {
00197         syscall( CG_S_STARTLOCALSOUND, sfx, channelNum );
00198 }

00571                                            {
00572         syscall( CG_S_STOPBACKGROUNDTRACK );
00573 }

00119                                   {
00120         syscall( CG_UPDATESCREEN );
00121 }

00064                          {
00065         static char     buffer[MAX_STRING_CHARS];
00066 
00067         trap_Argv( arg, buffer, sizeof( buffer ) );
00068 
00069         return buffer;
00070 }

00048 {
00049         if ( value < min ) return min;
00050         if ( value > max ) return max;
00051         return value;
00052 }

00147                       {
00148         char    gameList[4096];
00149         char *gameFile;
00150         int             i, len, count, size;
00151         fileHandle_t f;
00152         postGameInfo_t newInfo;
00153 
00154         count = trap_FS_GetFileList( "games", "game", gameList, sizeof(gameList) );
00155 
00156         size = sizeof(postGameInfo_t);
00157         memset(&newInfo, 0, size);
00158 
00159         if (count > 0) {
00160                 gameFile = gameList;
00161                 for ( i = 0; i < count; i++ ) {
00162                         len = strlen(gameFile);
00163                         if (trap_FS_FOpenFile(va("games/%s",gameFile), &f, FS_WRITE) >= 0) {
00164                                 trap_FS_Write(&size, sizeof(int), f);
00165                                 trap_FS_Write(&newInfo, size, f);
00166                                 trap_FS_FCloseFile(f);
00167                         }
00168                         gameFile += len + 1;
00169                 }
00170         }
00171         
00172         UI_SetBestScores(&newInfo, qfalse);
00173 
00174 }

00296                                            {
00297         char    *cmd;
00298 
00299         uiInfo.uiDC.frameTime = realTime - uiInfo.uiDC.realTime;
00300         uiInfo.uiDC.realTime = realTime;
00301 
00302         cmd = UI_Argv( 0 );
00303 
00304         // ensure minimum menu data is available
00305         //Menu_Cache();
00306 
00307         if ( Q_stricmp (cmd, "ui_test") == 0 ) {
00308                 UI_ShowPostGame(qtrue);
00309         }
00310 
00311         if ( Q_stricmp (cmd, "ui_report") == 0 ) {
00312                 UI_Report();
00313                 return qtrue;
00314         }
00315         
00316         if ( Q_stricmp (cmd, "ui_load") == 0 ) {
00317                 UI_Load();
00318                 return qtrue;
00319         }
00320 
00321         if ( Q_stricmp (cmd, "ui_opensiegemenu" ) == 0 ) 
00322         {
00323                 if ( trap_Cvar_VariableValue ( "g_gametype" ) == GT_SIEGE )
00324                 {
00325                         Menus_CloseAll();
00326                         if (Menus_ActivateByName(UI_Argv(1)))
00327                         {
00328                                 trap_Key_SetCatcher( KEYCATCH_UI );
00329                         }
00330                 }
00331                 return qtrue;
00332         }
00333 
00334         if ( Q_stricmp (cmd, "ui_openmenu" ) == 0 ) 
00335         {
00336                 //if ( trap_Cvar_VariableValue ( "developer" ) )
00337                 {
00338                         Menus_CloseAll();
00339                         if (Menus_ActivateByName(UI_Argv(1)))
00340                         {
00341                                 trap_Key_SetCatcher( KEYCATCH_UI );
00342                         }
00343                         return qtrue;
00344                 }
00345         }
00346 
00347         /*
00348         if ( Q_stricmp (cmd, "remapShader") == 0 ) {
00349                 if (trap_Argc() == 4) {
00350                         char shader1[MAX_QPATH];
00351                         char shader2[MAX_QPATH];
00352                         Q_strncpyz(shader1, UI_Argv(1), sizeof(shader1));
00353                         Q_strncpyz(shader2, UI_Argv(2), sizeof(shader2));
00354                         trap_R_RemapShader(shader1, shader2, UI_Argv(3));
00355                         return qtrue;
00356                 }
00357         }
00358         */
00359 
00360         if ( Q_stricmp (cmd, "postgame") == 0 ) {
00361                 UI_CalcPostGameStats();
00362                 return qtrue;
00363         }
00364 
00365         if ( Q_stricmp (cmd, "ui_cache") == 0 ) {
00366                 UI_Cache_f();
00367                 return qtrue;
00368         }
00369 
00370         if ( Q_stricmp (cmd, "ui_teamOrders") == 0 ) {
00371                 //UI_TeamOrdersMenu_f();
00372                 return qtrue;
00373         }
00374 
00375 
00376         if ( Q_stricmp (cmd, "ui_cdkey") == 0 ) {
00377                 //UI_CDKeyMenu_f();
00378                 return qtrue;
00379         }
00380 
00381         return qfalse;
00382 }

00485 {
00486         if (uiInfo.uiDC.cursorx < x ||
00487                 uiInfo.uiDC.cursory < y ||
00488                 uiInfo.uiDC.cursorx > x+width ||
00489                 uiInfo.uiDC.cursory > y+height)
00490                 return qfalse;
00491 
00492         return qtrue;
00493 }

00073                                                      {
00074         static char     buffer[MAX_STRING_CHARS];
00075 
00076         trap_Cvar_VariableStringBuffer( var_name, buffer, sizeof( buffer ) );
00077 
00078         return buffer;
00079 }

10676                                               {
10677         const char *s;
10678         uiClientState_t cstate;
10679         char                    info[MAX_INFO_VALUE];
10680         char text[256];
10681         float centerPoint, yStart, scale;
10682 
10683         char sStringEdTemp[256];
10684 
10685         menuDef_t *menu = Menus_FindByName("Connect");
10686 
10687 
10688         if ( !overlay && menu ) {
10689                 Menu_Paint(menu, qtrue);
10690         }
10691 
10692         if (!overlay) {
10693                 centerPoint = 320;
10694                 yStart = 130;
10695                 scale = 1.0f;   // -ste
10696         } else {
10697                 centerPoint = 320;
10698                 yStart = 32;
10699                 scale = 1.0f;   // -ste
10700                 return;
10701         }
10702 
10703         // see what information we should display
10704         trap_GetClientState( &cstate );
10705 
10706 
10707         info[0] = '\0';
10708         if( trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) ) ) {
10709                 trap_SP_GetStringTextString("MENUS_LOADING_MAPNAME", sStringEdTemp, sizeof(sStringEdTemp));
10710                 Text_PaintCenter(centerPoint, yStart, scale, colorWhite, va( /*"Loading %s"*/sStringEdTemp, Info_ValueForKey( info, "mapname" )), 0, FONT_MEDIUM);
10711         }
10712 
10713         if (!Q_stricmp(cstate.servername,"localhost")) {
10714                 trap_SP_GetStringTextString("MENUS_STARTING_UP", sStringEdTemp, sizeof(sStringEdTemp));
10715                 Text_PaintCenter(centerPoint, yStart + 48, scale, colorWhite, sStringEdTemp, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
10716         } else {
10717                 trap_SP_GetStringTextString("MENUS_CONNECTING_TO", sStringEdTemp, sizeof(sStringEdTemp));
10718                 strcpy(text, va(/*"Connecting to %s"*/sStringEdTemp, cstate.servername));
10719                 Text_PaintCenter(centerPoint, yStart + 48, scale, colorWhite,text , ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
10720         }
10721 
10722         //UI_DrawProportionalString( 320, 96, "Press Esc to abort", UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, menu_text_color );
10723 
10724         // display global MOTD at bottom
10725         Text_PaintCenter(centerPoint, 425, scale, colorWhite, Info_ValueForKey( cstate.updateInfoString, "motd" ), 0, FONT_MEDIUM);
10726         // print any server info (server full, bad version, etc)
10727         if ( cstate.connState < CA_CONNECTED ) {
10728                 Text_PaintCenter(centerPoint, yStart + 176, scale, colorWhite, cstate.messageString, 0, FONT_MEDIUM);
10729         }
10730 
10731         if ( lastConnState > cstate.connState ) {
10732                 lastLoadingText[0] = '\0';
10733         }
10734         lastConnState = cstate.connState;
10735 
10736         switch ( cstate.connState ) {
10737         case CA_CONNECTING:
10738                 {
10739                         trap_SP_GetStringTextString("MENUS_AWAITING_CONNECTION", sStringEdTemp, sizeof(sStringEdTemp));
10740                         s = va(/*"Awaiting connection...%i"*/sStringEdTemp, cstate.connectPacketCount);
10741                 }
10742                 break;
10743         case CA_CHALLENGING:
10744                 {
10745                         trap_SP_GetStringTextString("MENUS_AWAITING_CHALLENGE", sStringEdTemp, sizeof(sStringEdTemp));
10746                         s = va(/*"Awaiting challenge...%i"*/sStringEdTemp, cstate.connectPacketCount);
10747                 }
10748                 break;
10749         case CA_CONNECTED: {
10750                 char downloadName[MAX_INFO_VALUE];
10751 
10752                         trap_Cvar_VariableStringBuffer( "cl_downloadName", downloadName, sizeof(downloadName) );
10753                         if (*downloadName) {
10754                                 UI_DisplayDownloadInfo( downloadName, centerPoint, yStart, scale, FONT_MEDIUM );
10755                                 return;
10756                         }
10757                 }
10758                 trap_SP_GetStringTextString("MENUS_AWAITING_GAMESTATE", sStringEdTemp, sizeof(sStringEdTemp));
10759                 s = /*"Awaiting gamestate..."*/sStringEdTemp;
10760                 break;
10761         case CA_LOADING:
10762                 return;
10763         case CA_PRIMED:
10764                 return;
10765         default:
10766                 return;
10767         }
10768 
10769         if (Q_stricmp(cstate.servername,"localhost")) {
10770                 Text_PaintCenter(centerPoint, yStart + 80, scale, colorWhite, s, 0, FONT_MEDIUM);
10771         }
10772         // password required / connection rejected information goes here
10773 }

00400                                                                                {
00401         float   s0;
00402         float   s1;
00403         float   t0;
00404         float   t1;
00405 
00406         if( w < 0 ) {   // flip about vertical
00407                 w  = -w;
00408                 s0 = 1;
00409                 s1 = 0;
00410         }
00411         else {
00412                 s0 = 0;
00413                 s1 = 1;
00414         }
00415 
00416         if( h < 0 ) {   // flip about horizontal
00417                 h  = -h;
00418                 t0 = 1;
00419                 t1 = 0;
00420         }
00421         else {
00422                 t0 = 0;
00423                 t1 = 1;
00424         }
00425         
00426         trap_R_DrawStretchPic( x, y, w, h, s0, t0, s1, t1, hShader );
00427 }

00393                                                                                          {
00394         qhandle_t       hShader;
00395 
00396         hShader = trap_R_RegisterShaderNoMip( picname );
00397         trap_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
00398 }

00604 {
00605         // having all these different style defines (1 for UI, one for CG, and now one for the re->font stuff) 
00606         //      is dumb, but for now...
00607         //
00608         int iStyle = 0;
00609         int iMenuFont = (style & UI_SMALLFONT) ? FONT_SMALL : FONT_MEDIUM;
00610 
00611         switch (style & (UI_LEFT|UI_CENTER|UI_RIGHT))
00612         {
00613                 default:
00614                 case UI_LEFT:
00615                 {
00616                         // nada...
00617                 }
00618                 break;
00619 
00620                 case UI_CENTER:
00621                 {
00622                         x -= CG_Text_Width(str, 1.0, iMenuFont) / 2;
00623                 }
00624                 break;
00625 
00626                 case UI_RIGHT:
00627                 {
00628                         x -= CG_Text_Width(str, 1.0, iMenuFont) / 2;
00629                 }
00630                 break;
00631         }
00632 
00633         if (style & UI_DROPSHADOW)
00634         {
00635                 iStyle = ITEM_TEXTSTYLE_SHADOWED;
00636         }
00637         else
00638         if ( style & (UI_BLINK|UI_PULSE) )
00639         {
00640                 iStyle = ITEM_TEXTSTYLE_BLINK;
00641         }
00642 
00643         CG_Text_Paint(x, y, 1.0, color, str, 0, 0, iStyle, iMenuFont);
00644 }

00460                                                                                     {
00461         trap_R_SetColor( color );
00462 
00463   UI_DrawTopBottom(x, y, width, height);
00464   UI_DrawSides(x, y, width, height);
00465 
00466         trap_R_SetColor( NULL );
00467 }

00444                                                       {
00445         trap_R_DrawStretchPic( x, y, 1, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
00446         trap_R_DrawStretchPic( x + w - 1, y, 1, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
00447 }

00479 {
00480         UI_FillRect( x + BIGCHAR_WIDTH/2, y + BIGCHAR_HEIGHT/2, ( width + 1 ) * BIGCHAR_WIDTH, ( lines + 1 ) * BIGCHAR_HEIGHT, colorBlack );
00481         UI_DrawRect( x + BIGCHAR_WIDTH/2, y + BIGCHAR_HEIGHT/2, ( width + 1 ) * BIGCHAR_WIDTH, ( lines + 1 ) * BIGCHAR_HEIGHT, colorWhite );
00482 }

00449                                                           {
00450         trap_R_DrawStretchPic( x, y, w, 1, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
00451         trap_R_DrawStretchPic( x, y + h - 1, w, 1, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
00452 }

09146 {
09147         static char info[MAX_STRING_CHARS];
09148         const int feederID = feederFloat;
09149 
09150         if (feederID == FEEDER_Q3HEADS) 
09151         {
09152                 int actual;
09153                 UI_SelectedTeamHead(index, &actual);
09154                 uiInfo.q3SelectedHead = index;
09155                 trap_Cvar_Set("ui_selectedModelIndex", va("%i", index));
09156                 index = actual;
09157                 if (index >= 0 && index < uiInfo.q3HeadCount) 
09158                 {
09159                         trap_Cvar_Set( "model", uiInfo.q3HeadNames[index]);     //standard model
09160                         trap_Cvar_Set ( "char_color_red", "255" );                      //standard colors
09161                         trap_Cvar_Set ( "char_color_green", "255" );
09162                         trap_Cvar_Set ( "char_color_blue", "255" );
09163                 }
09164         } 
09165         else if (feederID == FEEDER_MOVES) 
09166         {
09167                 itemDef_t *item;
09168                 menuDef_t *menu;
09169                 modelDef_t *modelPtr;
09170 
09171                 menu = Menus_FindByName("rulesMenu_moves");
09172 
09173                 if (menu)
09174                 {
09175                         item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
09176                         if (item)
09177                         {
09178                                 modelPtr = (modelDef_t*)item->typeData;
09179                                 if (modelPtr)
09180                                 {
09181                                         char modelPath[MAX_QPATH];
09182                                         int animRunLength;
09183 
09184                                         ItemParse_model_g2anim_go( item,  datapadMoveData[uiInfo.movesTitleIndex][index].anim );
09185 
09186                                         Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
09187                                         ItemParse_asset_model_go( item, modelPath, &animRunLength );
09188                                         UI_UpdateCharacterSkin();
09189 
09190                                         uiInfo.moveAnimTime = uiInfo.uiDC.realTime + animRunLength;
09191 
09192                                         if (datapadMoveData[uiInfo.movesTitleIndex][index].anim)
09193                                         {
09194 
09195                                                 // Play sound for anim
09196                                                 if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_FORCE_JUMP)
09197                                                 {
09198                                                         trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveJumpSound, CHAN_LOCAL );
09199                                                 }
09200                                                 else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_ROLL)
09201                                                 {
09202                                                         trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveRollSound, CHAN_LOCAL );
09203                                                 }
09204                                                 else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_SABER)
09205                                                 {
09206                                                         // Randomly choose one sound
09207                                                         int soundI = Q_irand( 1, 6 );
09208                                                         sfxHandle_t *soundPtr;
09209                                                         soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound1;
09210                                                         if (soundI == 2)
09211                                                         {
09212                                                                 soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound2;
09213                                                         }
09214                                                         else if (soundI == 3)
09215                                                         {
09216                                                                 soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound3;
09217                                                         }
09218                                                         else if (soundI == 4)
09219                                                         {
09220                                                                 soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound4;
09221                                                         }
09222                                                         else if (soundI == 5)
09223                                                         {
09224                                                                 soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound5;
09225                                                         }
09226                                                         else if (soundI == 6)
09227                                                         {
09228                                                                 soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound6;
09229                                                         }
09230 
09231                                                         trap_S_StartLocalSound( *soundPtr, CHAN_LOCAL );
09232                                                 }
09233 
09234                                                 if (datapadMoveData[uiInfo.movesTitleIndex][index].desc)
09235                                                 {
09236                                                         trap_Cvar_Set( "ui_move_desc", datapadMoveData[uiInfo.movesTitleIndex][index].desc);
09237                                                 }
09238                                         }
09239                                         UI_SaberAttachToChar( item );
09240                                 }
09241                         }
09242                 }
09243         } 
09244         else if (feederID == FEEDER_MOVES_TITLES) 
09245         {
09246                 itemDef_t *item;
09247                 menuDef_t *menu;
09248                 modelDef_t *modelPtr;
09249 
09250                 uiInfo.movesTitleIndex = index;
09251                 uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
09252                 menu = Menus_FindByName("rulesMenu_moves");
09253 
09254                 if (menu)
09255                 {
09256                         item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
09257                         if (item)
09258                         {
09259                                 modelPtr = (modelDef_t*)item->typeData;
09260                                 if (modelPtr)
09261                                 {
09262                                         char modelPath[MAX_QPATH];
09263                                         int     animRunLength;
09264 
09265                                         uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
09266                                         ItemParse_model_g2anim_go( item,  uiInfo.movesBaseAnim );
09267 
09268                                         Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
09269                                         ItemParse_asset_model_go( item, modelPath, &animRunLength );
09270 
09271                                         UI_UpdateCharacterSkin();
09272 
09273                                 }
09274                         }
09275                 }
09276         }
09277         else if (feederID == FEEDER_SIEGE_TEAM1)
09278         {
09279                 if (!g_siegedFeederForcedSet)
09280                 {
09281                         g_UIGloballySelectedSiegeClass = UI_SiegeClassNum(siegeTeam1->classes[index]);
09282                         trap_Cvar_Set("ui_classDesc", g_UIClassDescriptions[g_UIGloballySelectedSiegeClass].desc);
09283 
09284                         //g_siegedFeederForcedSet = 1;
09285                         //Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM2, -1, NULL);
09286 
09287                         UI_SiegeSetCvarsForClass(siegeTeam1->classes[index]);
09288                 }
09289                 g_siegedFeederForcedSet = 0;
09290         }
09291         else if (feederID == FEEDER_SIEGE_TEAM2)
09292         {
09293                 if (!g_siegedFeederForcedSet)
09294                 {
09295                         g_UIGloballySelectedSiegeClass = UI_SiegeClassNum(siegeTeam2->classes[index]);
09296                         trap_Cvar_Set("ui_classDesc", g_UIClassDescriptions[g_UIGloballySelectedSiegeClass].desc);
09297 
09298                         //g_siegedFeederForcedSet = 1;
09299                         //Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM2, -1, NULL);
09300 
09301                         UI_SiegeSetCvarsForClass(siegeTeam2->classes[index]);
09302                 }
09303                 g_siegedFeederForcedSet = 0;
09304         }
09305         else if (feederID == FEEDER_FORCECFG) 
09306         {
09307                 int newindex = index;
09308 
09309                 if (uiForceSide == FORCE_LIGHTSIDE)
09310                 {
09311                         newindex += uiInfo.forceConfigLightIndexBegin;
09312                         if (newindex >= uiInfo.forceConfigCount)
09313                         {
09314                                 return qfalse;
09315                         }
09316                 }
09317                 else
09318                 { //else dark
09319                         newindex += uiInfo.forceConfigDarkIndexBegin;
09320                         if (newindex >= uiInfo.forceConfigCount || newindex > uiInfo.forceConfigLightIndexBegin)
09321                         { //dark gets read in before light
09322                                 return qfalse;
09323                         }
09324                 }
09325 
09326                 if (index >= 0 && index < uiInfo.forceConfigCount) 
09327                 {
09328                                 UI_ForceConfigHandle(uiInfo.forceConfigSelected, index);
09329                                 uiInfo.forceConfigSelected = index;
09330                 }
09331         } 
09332         else if (feederID == FEEDER_MAPS || feederID == FEEDER_ALLMAPS) 
09333         {
09334                 int actual, map;
09335                 const char *checkValid = NULL;
09336 
09337                 map = (feederID == FEEDER_ALLMAPS) ? ui_currentNetMap.integer : ui_currentMap.integer;
09338                 if (uiInfo.mapList[map].cinematic >= 0) {
09339                   trap_CIN_StopCinematic(uiInfo.mapList[map].cinematic);
09340                   uiInfo.mapList[map].cinematic = -1;
09341                 }
09342                 checkValid = UI_SelectedMap(index, &actual);
09343 
09344                 if (!checkValid || !checkValid[0])
09345                 { //this isn't a valid map to select, so reselect the current
09346                         index = ui_mapIndex.integer;
09347                         UI_SelectedMap(index, &actual);
09348                 }
09349 
09350                 trap_Cvar_Set("ui_mapIndex", va("%d", index));
09351                 gUISelectedMap = index;
09352                 ui_mapIndex.integer = index;
09353 
09354                 if (feederID == FEEDER_MAPS) {
09355                         ui_currentMap.integer = actual;
09356                         trap_Cvar_Set("ui_currentMap", va("%d", actual));
09357                 uiInfo.mapList[ui_currentMap.integer].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.mapList[ui_currentMap.integer].mapLoadName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
09358                         UI_LoadBestScores(uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum);
09359                         //trap_Cvar_Set("ui_opponentModel", uiInfo.mapList[ui_currentMap.integer].opponentName);
09360                         //updateOpponentModel = qtrue;
09361                 } else {
09362                         ui_currentNetMap.integer = actual;
09363                         trap_Cvar_Set("ui_currentNetMap", va("%d", actual));
09364                 uiInfo.mapList[ui_currentNetMap.integer].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.mapList[ui_currentNetMap.integer].mapLoadName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
09365                 }
09366 
09367         } else if (feederID == FEEDER_SERVERS) {
09368                 const char *mapName = NULL;
09369                 uiInfo.serverStatus.currentServer = index;
09370                 trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[index], info, MAX_STRING_CHARS);
09371                 uiInfo.serverStatus.currentServerPreview = trap_R_RegisterShaderNoMip(va("levelshots/%s", Info_ValueForKey(info, "mapname")));
09372                 if (uiInfo.serverStatus.currentServerCinematic >= 0) {
09373                   trap_CIN_StopCinematic(uiInfo.serverStatus.currentServerCinematic);
09374                         uiInfo.serverStatus.currentServerCinematic = -1;
09375                 }
09376                 mapName = Info_ValueForKey(info, "mapname");
09377                 if (mapName && *mapName) {
09378                         uiInfo.serverStatus.currentServerCinematic = trap_CIN_PlayCinematic(va("%s.roq", mapName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
09379                 }
09380         } else if (feederID == FEEDER_SERVERSTATUS) {
09381                 //
09382         } else if (feederID == FEEDER_FINDPLAYER) {
09383           uiInfo.currentFoundPlayerServer = index;
09384           //
09385           if ( index < uiInfo.numFoundPlayerServers-1) {
09386                         // build a new server status for this server
09387                         Q_strncpyz(uiInfo.serverStatusAddress, uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer], sizeof(uiInfo.serverStatusAddress));
09388                         Menu_SetFeederSelection(NULL, FEEDER_SERVERSTATUS, 0, NULL);
09389                         UI_BuildServerStatus(qtrue);
09390           }
09391         } else if (feederID == FEEDER_PLAYER_LIST) {
09392                 uiInfo.playerIndex = index;
09393         } else if (feederID == FEEDER_TEAM_LIST) {
09394                 uiInfo.teamIndex = index;
09395         } else if (feederID == FEEDER_MODS) {
09396                 uiInfo.modIndex = index;
09397         } else if (feederID == FEEDER_CINEMATICS) {
09398                 uiInfo.movieIndex = index;
09399                 if (uiInfo.previewMovie >= 0) {
09400                   trap_CIN_StopCinematic(uiInfo.previewMovie);
09401                 }
09402                 uiInfo.previewMovie = -1;
09403         } else if (feederID == FEEDER_DEMOS) {
09404                 uiInfo.demoIndex = index;
09405         }
09406         else if (feederID == FEEDER_COLORCHOICES) 
09407         {
09408                 if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount)
09409                 {
09410                         Item_RunScript(item, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorActionText[index]);
09411                 }
09412         }
09413         else if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
09414         {
09415                 if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount)
09416                 {
09417                         trap_Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
09418                 }
09419         } 
09420         else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
09421         {
09422                 if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount)
09423                 {
09424                         trap_Cvar_Set("ui_char_skin_torso", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]);
09425                 }
09426         } 
09427         else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
09428         {
09429                 if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount)
09430                 {
09431                         trap_Cvar_Set("ui_char_skin_legs", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]);
09432                 }
09433         } 
09434         else if (feederID == FEEDER_PLAYER_SPECIES) 
09435         {
09436                 uiInfo.playerSpeciesIndex = index;
09437         } 
09438         else if (feederID == FEEDER_LANGUAGES) 
09439         {
09440                 uiInfo.languageCountIndex = index;
09441         } 
09442         else if (  feederID == FEEDER_SIEGE_BASE_CLASS )
09443         {
09444                 int team,baseClass; 
09445 
09446                 team = (int)trap_Cvar_VariableValue("ui_team");
09447                 baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
09448 
09449                 UI_UpdateCvarsForClass(team, baseClass, index);
09450         }
09451         else if (feederID == FEEDER_SIEGE_CLASS_WEAPONS) 
09452         {
09453 //              trap_Cvar_VariableStringBuffer( va("ui_class_weapondesc%i", index), info, sizeof(info) );
09454 //              trap_Cvar_Set( "ui_itemforceinvdesc", info );
09455         } 
09456         else if (feederID == FEEDER_SIEGE_CLASS_INVENTORY) 
09457         {
09458 //              trap_Cvar_VariableStringBuffer( va("ui_class_itemdesc%i", index), info, sizeof(info) );
09459 //              trap_Cvar_Set( "ui_itemforceinvdesc", info );
09460         } 
09461         else if (feederID == FEEDER_SIEGE_CLASS_FORCE) 
09462         {
09463                 int i;
09464 //              int validCnt = 0;
09465 
09466                 trap_Cvar_VariableStringBuffer( va("ui_class_power%i", index), info, sizeof(info) );
09467 
09468                 //count them up
09469                 for (i=0;i< NUM_FORCE_POWERS;i++)
09470                 {
09471                         if (!strcmp(HolocronIcons[i],info))
09472                         {
09473                                 trap_Cvar_Set( "ui_itemforceinvdesc", forcepowerDesc[i] );
09474                         }
09475                 }
09476         } 
09477 #ifdef _XBOX
09478         else if (feederID == FEEDER_XBL_ACCOUNTS)
09479         {
09480                 XBL_SetAccountIndex( index );
09481         }
09482         else if (feederID == FEEDER_XBL_PLAYERS)
09483         {
09484                 XBL_PL_SetPlayerIndex( index );
09485         }
09486         else if (feederID == FEEDER_XBL_FRIENDS)
09487         {
09488                 XBL_F_SetChosenFriendIndex( index );
09489         }
09490         else if (feederID == FEEDER_XBL_SERVERS)
09491         {
09492                 XBL_MM_SetChosenServerIndex( index );
09493         }
09494 #endif
09495 
09496         return qtrue;
09497 }

00436                                                                                     {
00437         trap_R_SetColor( color );
00438 
00439         trap_R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
00440 
00441         trap_R_SetColor( NULL );
00442 }

00308                                               {
00309         int             n;
00310         char    *value;
00311 
00312         for ( n = 0; n < ui_numBots ; n++ ) {
00313                 value = Info_ValueForKey( ui_botInfos[n], "name" );
00314                 if ( !Q_stricmp( value, name ) ) {
00315                         return ui_botInfos[n];
00316                 }
00317         }
00318 
00319         return NULL;
00320 }

codemp/ui/ui_local.h File Reference

Data Structures

Defines

Typedefs

Enumerations

Functions

Variables

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation


Data Structures
struct	_tag_menuframework
struct	aliasInfo
struct	characterInfo
struct	gameTypeInfo
struct	lerpFrame_t
struct	mapInfo
struct	menuaction_s
struct	menubitmap_s
struct	menucommon_s
struct	menufield_s
struct	menulist_s
struct	menuradiobutton_s
struct	menuslider_s
struct	menutext_s
struct	mfield_t
struct	modInfo_t
struct	pendingServer_t
struct	pendingServerStatus_t
struct	pinglist_t
struct	playerInfo_t
struct	playerSpeciesInfo_t
struct	postGameInfo_s
struct	serverFilter_s
struct	serverStatus_s
struct	serverStatusInfo_t
struct	teamInfo
struct	tierInfo
struct	uiInfo_t
struct	uiStatic_t
Defines
#define	RCOLUMN_OFFSET ( BIGCHAR_WIDTH )
#define	LCOLUMN_OFFSET (-BIGCHAR_WIDTH )
#define	SLIDER_RANGE 10
#define	MAX_EDIT_LINE 256
#define	MAX_MENUDEPTH 8
#define	MAX_MENUITEMS 256
#define	MAX_FORCE_CONFIGS 128
#define	MTYPE_NULL 0
#define	MTYPE_SLIDER 1
#define	MTYPE_ACTION 2
#define	MTYPE_SPINCONTROL 3
#define	MTYPE_FIELD 4
#define	MTYPE_RADIOBUTTON 5
#define	MTYPE_BITMAP 6
#define	MTYPE_TEXT 7
#define	MTYPE_SCROLLLIST 8
#define	MTYPE_PTEXT 9
#define	MTYPE_BTEXT 10
#define	QMF_BLINK 0x00000001
#define	QMF_SMALLFONT 0x00000002
#define	QMF_LEFT_JUSTIFY 0x00000004
#define	QMF_CENTER_JUSTIFY 0x00000008
#define	QMF_RIGHT_JUSTIFY 0x00000010
#define	QMF_NUMBERSONLY 0x00000020
#define	QMF_HIGHLIGHT 0x00000040
#define	QMF_HIGHLIGHT_IF_FOCUS 0x00000080
#define	QMF_PULSEIFFOCUS 0x00000100
#define	QMF_HASMOUSEFOCUS 0x00000200
#define	QMF_NOONOFFTEXT 0x00000400
#define	QMF_MOUSEONLY 0x00000800
#define	QMF_HIDDEN 0x00001000
#define	QMF_GRAYED 0x00002000
#define	QMF_INACTIVE 0x00004000
#define	QMF_NODEFAULTINIT 0x00008000
#define	QMF_OWNERDRAW 0x00010000
#define	QMF_PULSE 0x00020000
#define	QMF_LOWERCASE 0x00040000
#define	QMF_UPPERCASE 0x00080000
#define	QMF_SILENT 0x00100000
#define	QM_GOTFOCUS 1
#define	QM_LOSTFOCUS 2
#define	QM_ACTIVATED 3
#define	MAX_FAVORITESERVERS 16
#define	UI_NUMFX 7
#define	MAX_HEADS 64
#define	MAX_ALIASES 64
#define	MAX_HEADNAME 32
#define	MAX_TEAMS 64
#define	MAX_GAMETYPES 16
#define	MAX_MAPS 128
#define	MAX_SPMAPS 16
#define	PLAYERS_PER_TEAM 8
#define	MAX_PINGREQUESTS 32
#define	MAX_ADDRESSLENGTH 64
#define	MAX_HOSTNAMELENGTH 22
#define	MAX_MAPNAMELENGTH 16
#define	MAX_STATUSLENGTH 64
#define	MAX_LISTBOXWIDTH 59
#define	UI_FONT_THRESHOLD 0.1
#define	MAX_DISPLAY_SERVERS 2048
#define	MAX_SERVERSTATUS_LINES 128
#define	MAX_SERVERSTATUS_TEXT 1024
#define	MAX_FOUNDPLAYER_SERVERS 16
#define	TEAM_MEMBERS 8
#define	GAMES_ALL 0
#define	GAMES_FFA 1
#define	GAMES_HOLOCRON 2
#define	GAMES_TEAMPLAY 3
#define	GAMES_TOURNEY 4
#define	GAMES_CTF 5
#define	MAPS_PER_TIER 3
#define	MAX_TIERS 16
#define	MAX_MODS 64
#define	MAX_DEMOS 256
#define	MAX_MOVIES 256
#define	MAX_Q3PLAYERMODELS 256
#define	MAX_PLAYERMODELS 32
#define	MAX_SCROLLTEXT_SIZE 4096
#define	MAX_SCROLLTEXT_LINES 64
#define	ASSET_BACKGROUND "uiBackground"
Typedefs
typedef _tag_menuframework	menuframework_s
typedef serverFilter_s	serverFilter_t
typedef serverStatus_s	serverStatus_t
typedef postGameInfo_s	postGameInfo_t
Enumerations
enum	awardType_t { AWARD_ACCURACY, AWARD_IMPRESSIVE, AWARD_EXCELLENT, AWARD_GAUNTLET, AWARD_FRAGS, AWARD_PERFECT }
Functions
void	Menu_Cache (void)
void	Menu_Focus (menucommon_s *m)
void	Menu_AddItem (menuframework_s menu, void item)
void	Menu_AdjustCursor (menuframework_s *menu, int dir)
void	Menu_Draw (menuframework_s *menu)
void *	Menu_ItemAtCursor (menuframework_s *m)
sfxHandle_t	Menu_ActivateItem (menuframework_s s, menucommon_s item)
void	Menu_SetCursor (menuframework_s *s, int cursor)
void	Menu_SetCursorToItem (menuframework_s m, void ptr)
sfxHandle_t	Menu_DefaultKey (menuframework_s *s, int key)
void	Bitmap_Init (menubitmap_s *b)
void	Bitmap_Draw (menubitmap_s *b)
void	ScrollList_Draw (menulist_s *l)
sfxHandle_t	ScrollList_Key (menulist_s *l, int key)
void	MField_Clear (mfield_t *edit)
void	MField_KeyDownEvent (mfield_t *edit, int key)
void	MField_CharEvent (mfield_t *edit, int ch)
void	MField_Draw (mfield_t *edit, int x, int y, int style, vec4_t color)
void	MenuField_Init (menufield_s *m)
void	MenuField_Draw (menufield_s *f)
sfxHandle_t	MenuField_Key (menufield_s m, int key)
qboolean	UI_FeederSelection (float feederID, int index, itemDef_t *item)
void	UI_Report ()
void	UI_Load ()
void	UI_LoadMenus (const char *menuFile, qboolean reset)
void	_UI_SetActiveMenu (uiMenuCommand_t menu)
int	UI_AdjustTimeByGame (int time)
void	UI_ShowPostGame (qboolean newHigh)
void	UI_ClearScores ()
void	UI_LoadArenas (void)
void	UI_LoadForceConfig_List (void)
void	MainMenu_Cache (void)
void	UI_MainMenu (void)
void	UI_RegisterCvars (void)
void	UI_UpdateCvars (void)
void	UI_CreditMenu (void)
void	InGame_Cache (void)
void	UI_InGameMenu (void)
void	ConfirmMenu_Cache (void)
void	UI_ConfirmMenu (const char question, void(draw)(void), void(*action)(qboolean result))
void	UI_SetupMenu_Cache (void)
void	UI_SetupMenu (void)
void	UI_TeamMainMenu (void)
void	TeamMain_Cache (void)
void	UI_DrawConnectScreen (qboolean overlay)
void	UI_ControlsMenu (void)
void	Controls_Cache (void)
void	UI_DemosMenu (void)
void	Demos_Cache (void)
void	UI_CinematicsMenu (void)
void	UI_CinematicsMenu_f (void)
void	UI_CinematicsMenu_Cache (void)
void	UI_ModsMenu (void)
void	UI_ModsMenu_Cache (void)
void	UI_CDKeyMenu (void)
void	UI_CDKeyMenu_Cache (void)
void	UI_CDKeyMenu_f (void)
void	UI_PlayerModelMenu (void)
void	PlayerModel_Cache (void)
void	UI_PlayerSettingsMenu (void)
void	PlayerSettings_Cache (void)
void	UI_PreferencesMenu (void)
void	Preferences_Cache (void)
void	UI_SpecifyLeagueMenu (void)
void	SpecifyLeague_Cache (void)
void	UI_SpecifyServerMenu (void)
void	SpecifyServer_Cache (void)
void	UI_ArenaServersMenu (void)
void	ArenaServers_Cache (void)
void	UI_StartServerMenu (qboolean multiplayer)
void	StartServer_Cache (void)
void	ServerOptions_Cache (void)
void	UI_BotSelectMenu (char *bot)
void	UI_BotSelectMenu_Cache (void)
void	UI_ServerInfoMenu (void)
void	ServerInfo_Cache (void)
void	UI_GraphicsOptionsMenu (void)
void	GraphicsOptions_Cache (void)
void	DriverInfo_Cache (void)
void	UI_Init (void)
void	UI_Shutdown (void)
void	UI_KeyEvent (int key)
void	UI_MouseEvent (int dx, int dy)
void	UI_Refresh (int realtime)
qboolean	UI_ConsoleCommand (int realTime)
float	UI_ClampCvar (float min, float max, float value)
void	UI_DrawNamedPic (float x, float y, float width, float height, const char *picname)
void	UI_DrawHandlePic (float x, float y, float w, float h, qhandle_t hShader)
void	UI_FillRect (float x, float y, float width, float height, const float *color)
void	UI_DrawRect (float x, float y, float width, float height, const float *color)
void	UI_DrawTopBottom (float x, float y, float w, float h)
void	UI_DrawSides (float x, float y, float w, float h)
void	UI_UpdateScreen (void)
void	UI_SetColor (const float *rgba)
void	UI_LerpColor (vec4_t a, vec4_t b, vec4_t c, float t)
void	UI_DrawBannerString (int x, int y, const char *str, int style, vec4_t color)
float	UI_ProportionalSizeScale (int style)
void	UI_DrawProportionalString (int x, int y, const char *str, int style, vec4_t color)
int	UI_ProportionalStringWidth (const char *str)
void	UI_DrawString (int x, int y, const char *str, int style, vec4_t color)
void	UI_DrawChar (int x, int y, int ch, int style, vec4_t color)
qboolean	UI_CursorInRect (int x, int y, int width, int height)
void	UI_DrawTextBox (int x, int y, int width, int lines)
qboolean	UI_IsFullscreen (void)
void	UI_SetActiveMenu (uiMenuCommand_t menu)
void	UI_PushMenu (menuframework_s *menu)
void	UI_PopMenu (void)
void	UI_ForceMenuOff (void)
char *	UI_Argv (int arg)
char *	UI_Cvar_VariableString (const char *var_name)
void	UI_StartDemoLoop (void)
void	UI_LoadBestScores (const char *map, int game)
void	UI_SPLevelMenu_Cache (void)
void	UI_SPLevelMenu (void)
void	UI_SPLevelMenu_f (void)
void	UI_SPLevelMenu_ReInit (void)
void	UI_SPArena_Start (const char *arenaInfo)
void	UI_SPPostgameMenu_Cache (void)
void	UI_SPPostgameMenu_f (void)
void	UI_SPSkillMenu (const char *arenaInfo)
void	UI_SPSkillMenu_Cache (void)
void	trap_Print (const char *string)
void	trap_Error (const char *string)
int	trap_Milliseconds (void)
void	trap_Cvar_Register (vmCvar_t vmCvar, const char varName, const char *defaultValue, int flags)
void	trap_Cvar_Update (vmCvar_t *vmCvar)
void	trap_Cvar_Set (const char var_name, const char value)
float	trap_Cvar_VariableValue (const char *var_name)
void	trap_Cvar_VariableStringBuffer (const char var_name, char buffer, int bufsize)
void	trap_Cvar_SetValue (const char *var_name, float value)
void	trap_Cvar_Reset (const char *name)
void	trap_Cvar_Create (const char var_name, const char var_value, int flags)
void	trap_Cvar_InfoStringBuffer (int bit, char *buffer, int bufsize)
int	trap_Argc (void)
void	trap_Argv (int n, char *buffer, int bufferLength)
void	trap_Cmd_ExecuteText (int exec_when, const char *text)
int	trap_FS_FOpenFile (const char qpath, fileHandle_t f, fsMode_t mode)
void	trap_FS_Read (void *buffer, int len, fileHandle_t f)
void	trap_FS_Write (const void *buffer, int len, fileHandle_t f)
void	trap_FS_FCloseFile (fileHandle_t f)
int	trap_FS_GetFileList (const char path, const char extension, char *listbuf, int bufsize)
qhandle_t	trap_R_RegisterModel (const char *name)
qhandle_t	trap_R_RegisterSkin (const char *name)
qhandle_t	trap_R_RegisterShaderNoMip (const char *name)
void	trap_R_ShaderNameFromIndex (char *name, int index)
void	trap_R_ClearScene (void)
void	trap_R_AddRefEntityToScene (const refEntity_t *re)
void	trap_R_AddPolyToScene (qhandle_t hShader, int numVerts, const polyVert_t *verts)
void	trap_R_AddLightToScene (const vec3_t org, float intensity, float r, float g, float b)
void	trap_R_RenderScene (const refdef_t *fd)
void	trap_R_SetColor (const float *rgba)
void	trap_R_DrawStretchPic (float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader)
void	trap_R_ModelBounds (clipHandle_t model, vec3_t mins, vec3_t maxs)
void	trap_UpdateScreen (void)
int	trap_CM_LerpTag (orientation_t tag, clipHandle_t mod, int startFrame, int endFrame, float frac, const char tagName)
void	trap_S_StartLocalSound (sfxHandle_t sfx, int channelNum)
sfxHandle_t	trap_S_RegisterSound (const char *sample)
void	trap_Key_KeynumToStringBuf (int keynum, char *buf, int buflen)
void	trap_Key_GetBindingBuf (int keynum, char *buf, int buflen)
void	trap_Key_SetBinding (int keynum, const char *binding)
qboolean	trap_Key_IsDown (int keynum)
qboolean	trap_Key_GetOverstrikeMode (void)
void	trap_Key_SetOverstrikeMode (qboolean state)
void	trap_Key_ClearStates (void)
int	trap_Key_GetCatcher (void)
void	trap_Key_SetCatcher (int catcher)
void	trap_GetClipboardData (char *buf, int bufsize)
void	trap_GetClientState (uiClientState_t *state)
void	trap_GetGlconfig (glconfig_t *glconfig)
int	trap_GetConfigString (int index, char *buff, int buffsize)
int	trap_LAN_GetServerCount (int source)
void	trap_LAN_GetServerAddressString (int source, int n, char *buf, int buflen)
void	trap_LAN_GetServerInfo (int source, int n, char *buf, int buflen)
int	trap_LAN_GetServerPing (int source, int n)
int	trap_LAN_GetPingQueueCount (void)
void	trap_LAN_ClearPing (int n)
void	trap_LAN_GetPing (int n, char buf, int buflen, int pingtime)
void	trap_LAN_GetPingInfo (int n, char *buf, int buflen)
void	trap_LAN_LoadCachedServers ()
void	trap_LAN_SaveCachedServers ()
void	trap_LAN_MarkServerVisible (int source, int n, qboolean visible)
int	trap_LAN_ServerIsVisible (int source, int n)
qboolean	trap_LAN_UpdateVisiblePings (int source)
int	trap_LAN_AddServer (int source, const char name, const char addr)
void	trap_LAN_RemoveServer (int source, const char *addr)
void	trap_LAN_ResetPings (int n)
int	trap_LAN_ServerStatus (const char serverAddress, char serverStatus, int maxLen)
int	trap_LAN_CompareServers (int source, int sortKey, int sortDir, int s1, int s2)
int	trap_MemoryRemaining (void)
qhandle_t	trap_R_RegisterFont (const char *name)
int	trap_R_Font_StrLenPixels (const char *text, const int iFontIndex, const float scale)
int	trap_R_Font_StrLenChars (const char *text)
int	trap_R_Font_HeightPixels (const int iFontIndex, const float scale)
void	trap_R_Font_DrawString (int ox, int oy, const char text, const float rgba, const int setIndex, int iCharLimit, const float scale)
qboolean	trap_Language_IsAsian (void)
qboolean	trap_Language_UsesSpaces (void)
unsigned	trap_AnyLanguage_ReadCharFromString (const char psText, int piAdvanceCount, qboolean *pbIsTrailingPunctuation)
void	trap_S_StopBackgroundTrack (void)
void	trap_S_StartBackgroundTrack (const char intro, const char loop, qboolean bReturnWithoutStarting)
int	trap_CIN_PlayCinematic (const char *arg0, int xpos, int ypos, int width, int height, int bits)
e_status	trap_CIN_StopCinematic (int handle)
e_status	trap_CIN_RunCinematic (int handle)
void	trap_CIN_DrawCinematic (int handle)
void	trap_CIN_SetExtents (int handle, int x, int y, int w, int h)
int	trap_RealTime (qtime_t *qtime)
void	trap_R_RemapShader (const char oldShader, const char newShader, const char *timeOffset)
void	UI_AddBots_Cache (void)
void	UI_AddBotsMenu (void)
void	UI_RemoveBots_Cache (void)
void	UI_RemoveBotsMenu (void)
void	UI_TeamOrdersMenu (void)
void	UI_TeamOrdersMenu_f (void)
void	UI_TeamOrdersMenu_Cache (void)
void	UI_LoadConfig_Cache (void)
void	UI_LoadConfigMenu (void)
void	UI_SaveConfigMenu_Cache (void)
void	UI_SaveConfigMenu (void)
void	UI_DisplayOptionsMenu_Cache (void)
void	UI_DisplayOptionsMenu (void)
void	UI_SoundOptionsMenu_Cache (void)
void	UI_SoundOptionsMenu (void)
void	UI_NetworkOptionsMenu_Cache (void)
void	UI_NetworkOptionsMenu (void)
const char *	UI_GetArenaInfoByNumber (int num)
const char *	UI_GetArenaInfoByMap (const char *map)
const char *	UI_GetSpecialArenaInfo (const char *tag)
int	UI_GetNumArenas (void)
int	UI_GetNumSPArenas (void)
int	UI_GetNumSPTiers (void)
char *	UI_GetBotInfoByNumber (int num)
char *	UI_GetBotInfoByName (const char *name)
int	UI_GetNumBots (void)
void	UI_LoadBots (void)
char *	UI_GetBotNameByNumber (int num)
void	UI_GetBestScore (int level, int score, int skill)
void	UI_SetBestScore (int level, int score)
int	UI_TierCompleted (int levelWon)
qboolean	UI_ShowTierVideo (int tier)
qboolean	UI_CanShowTierVideo (int tier)
int	UI_GetCurrentGame (void)
void	UI_NewGame (void)
void	UI_LogAwardData (int award, int data)
int	UI_GetAwardLevel (int award)
void	UI_SPUnlock_f (void)
void	UI_SPUnlockMedals_f (void)
void	UI_InitGameinfo (void)
void	Login_Cache (void)
void	UI_LoginMenu (void)
void	Signup_Cache (void)
void	UI_SignupMenu (void)
void	RankStatus_Cache (void)
void	UI_RankStatusMenu (void)
Variables
vmCvar_t	ui_ffa_fraglimit
vmCvar_t	ui_ffa_timelimit
vmCvar_t	ui_selectedModelIndex
vmCvar_t	ui_team_fraglimit
vmCvar_t	ui_team_timelimit
vmCvar_t	ui_team_friendly
vmCvar_t	ui_ctf_capturelimit
vmCvar_t	ui_ctf_timelimit
vmCvar_t	ui_ctf_friendly
vmCvar_t	ui_arenasFile
vmCvar_t	ui_botsFile
vmCvar_t	ui_browserMaster
vmCvar_t	ui_browserGameType
vmCvar_t	ui_browserSortKey
vmCvar_t	ui_browserShowFull
vmCvar_t	ui_browserShowEmpty
vmCvar_t	ui_drawCrosshair
vmCvar_t	ui_drawCrosshairNames
vmCvar_t	ui_marks
vmCvar_t	ui_captureLimit
vmCvar_t	ui_fragLimit
vmCvar_t	ui_gameType
vmCvar_t	ui_netGameType
vmCvar_t	ui_actualNetGameType
vmCvar_t	ui_joinGameType
vmCvar_t	ui_netSource
vmCvar_t	ui_serverFilterType
vmCvar_t	ui_dedicated
vmCvar_t	ui_opponentName
vmCvar_t	ui_menuFiles
vmCvar_t	ui_currentMap
vmCvar_t	ui_currentNetMap
vmCvar_t	ui_mapIndex
vmCvar_t	ui_currentOpponent
vmCvar_t	ui_selectedPlayer
vmCvar_t	ui_selectedPlayerName
vmCvar_t	ui_lastServerRefresh_0
vmCvar_t	ui_lastServerRefresh_1
vmCvar_t	ui_lastServerRefresh_2
vmCvar_t	ui_lastServerRefresh_3
vmCvar_t	ui_singlePlayerActive
vmCvar_t	ui_scoreAccuracy
vmCvar_t	ui_scoreImpressives
vmCvar_t	ui_scoreExcellents
vmCvar_t	ui_scoreDefends
vmCvar_t	ui_scoreAssists
vmCvar_t	ui_scoreGauntlets
vmCvar_t	ui_scoreScore
vmCvar_t	ui_scorePerfect
vmCvar_t	ui_scoreTeam
vmCvar_t	ui_scoreBase
vmCvar_t	ui_scoreTimeBonus
vmCvar_t	ui_scoreSkillBonus
vmCvar_t	ui_scoreShutoutBonus
vmCvar_t	ui_scoreTime
vmCvar_t	ui_serverStatusTimeOut
vmCvar_t	ui_bypassMainMenuLoad
sfxHandle_t	menu_in_sound
sfxHandle_t	menu_move_sound
sfxHandle_t	menu_out_sound
sfxHandle_t	menu_buzz_sound
sfxHandle_t	menu_null_sound
sfxHandle_t	weaponChangeSound
vec4_t	menu_text_color
vec4_t	menu_grayed_color
vec4_t	menu_dark_color
vec4_t	menu_highlight_color
vec4_t	menu_red_color
vec4_t	menu_black_color
vec4_t	menu_dim_color
vec4_t	color_black
vec4_t	color_white
vec4_t	color_yellow
vec4_t	color_blue
vec4_t	color_orange
vec4_t	color_red
vec4_t	color_dim
vec4_t	name_color
vec4_t	list_color
vec4_t	listbar_color
vec4_t	text_color_disabled
vec4_t	text_color_normal
vec4_t	text_color_highlight
char *	ui_medalNames []
char *	ui_medalPicNames []
char *	ui_medalSounds []
uiInfo_t	uiInfo
qboolean	m_entersound
uiStatic_t	uis