ui_main.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code 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.

Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
/*
=======================================================================

USER INTERFACE MAIN

=======================================================================
*/

// use this to get a demo build without an explicit demo build, i.e. to get the demo ui files to build
//#define PRE_RELEASE_TADEMO

#include "ui_local.h"

uiInfo_t uiInfo;

static const char *MonthAbbrev[] = {
    "Jan","Feb","Mar",
    "Apr","May","Jun",
    "Jul","Aug","Sep",
    "Oct","Nov","Dec"
};


static const char *skillLevels[] = {
  "I Can Win",
  "Bring It On",
  "Hurt Me Plenty",
  "Hardcore",
  "Nightmare"
};

static const int numSkillLevels = sizeof(skillLevels) / sizeof(const char*);


static const char *netSources[] = {
    "Local",
    "Mplayer",
    "Internet",
    "Favorites"
};
static const int numNetSources = sizeof(netSources) / sizeof(const char*);

static const serverFilter_t serverFilters[] = {
    {"All", "" },
    {"Quake 3 Arena", "" },
    {"Team Arena", "missionpack" },
    {"Rocket Arena", "arena" },
    {"Alliance", "alliance20" },
    {"Weapons Factory Arena", "wfa" },
    {"OSP", "osp" },
};

static const char *teamArenaGameTypes[] = {
    "FFA",
    "TOURNAMENT",
    "SP",
    "TEAM DM",
    "CTF",
    "1FCTF",
    "OVERLOAD",
    "HARVESTER",
    "TEAMTOURNAMENT"
};

static int const numTeamArenaGameTypes = sizeof(teamArenaGameTypes) / sizeof(const char*);


static const char *teamArenaGameNames[] = {
    "Free For All",
    "Tournament",
    "Single Player",
    "Team Deathmatch",
    "Capture the Flag",
    "One Flag CTF",
    "Overload",
    "Harvester",
    "Team Tournament",
};

static int const numTeamArenaGameNames = sizeof(teamArenaGameNames) / sizeof(const char*);


static const int numServerFilters = sizeof(serverFilters) / sizeof(serverFilter_t);

static const char *sortKeys[] = {
    "Server Name",
    "Map Name",
    "Open Player Spots",
    "Game Type",
    "Ping Time"
};
static const int numSortKeys = sizeof(sortKeys) / sizeof(const char*);

static char* netnames[] = {
    "???",
    "UDP",
    "IPX",
    NULL
};

#ifndef MISSIONPACK // bk001206
static char quake3worldMessage[] = "Visit www.quake3world.com - News, Community, Events, Files";
#endif

static int gamecodetoui[] = {4,2,3,0,5,1,6};
static int uitogamecode[] = {4,6,2,3,1,5,7};


static void UI_StartServerRefresh(qboolean full);
static void UI_StopServerRefresh( void );
static void UI_DoServerRefresh( void );
static void UI_FeederSelection(float feederID, int index);
static void UI_BuildServerDisplayList(qboolean force);
static void UI_BuildServerStatus(qboolean force);
static void UI_BuildFindPlayerList(qboolean force);
static int QDECL UI_ServersQsortCompare( const void *arg1, const void *arg2 );
static int UI_MapCountByGameType(qboolean singlePlayer);
static int UI_HeadCountByTeam( void );
static void UI_ParseGameInfo(const char *teamFile);
static void UI_ParseTeamInfo(const char *teamFile);
static const char *UI_SelectedMap(int index, int *actual);
static const char *UI_SelectedHead(int index, int *actual);
static int UI_GetIndexFromSelection(int actual);

int ProcessNewUI( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6 );

/*
================
vmMain

This is the only way control passes into the module.
This must be the very first function compiled into the .qvm file
================
*/
vmCvar_t  ui_new;
vmCvar_t  ui_debug;
vmCvar_t  ui_initialized;
vmCvar_t  ui_teamArenaFirstRun;

void _UI_Init( qboolean );
void _UI_Shutdown( void );
void _UI_KeyEvent( int key, qboolean down );
void _UI_MouseEvent( int dx, int dy );
void _UI_Refresh( int realtime );
qboolean _UI_IsFullscreen( void );
int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) {
  switch ( command ) {
      case UI_GETAPIVERSION:
          return UI_API_VERSION;

      case UI_INIT:
          _UI_Init(arg0);
          return 0;

      case UI_SHUTDOWN:
          _UI_Shutdown();
          return 0;

      case UI_KEY_EVENT:
          _UI_KeyEvent( arg0, arg1 );
          return 0;

      case UI_MOUSE_EVENT:
          _UI_MouseEvent( arg0, arg1 );
          return 0;

      case UI_REFRESH:
          _UI_Refresh( arg0 );
          return 0;

      case UI_IS_FULLSCREEN:
          return _UI_IsFullscreen();

      case UI_SET_ACTIVE_MENU:
          _UI_SetActiveMenu( arg0 );
          return 0;

      case UI_CONSOLE_COMMAND:
          return UI_ConsoleCommand(arg0);

      case UI_DRAW_CONNECT_SCREEN:
          UI_DrawConnectScreen( arg0 );
          return 0;
      case UI_HASUNIQUECDKEY: // mod authors need to observe this
        return qtrue; // bk010117 - change this to qfalse for mods!

    }

    return -1;
}



void AssetCache() {
    int n;
    //if (Assets.textFont == NULL) {
    //}
    //Assets.background = trap_R_RegisterShaderNoMip( ASSET_BACKGROUND );
    //Com_Printf("Menu Size: %i bytes\n", sizeof(Menus));
    uiInfo.uiDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
    uiInfo.uiDC.Assets.fxBasePic = trap_R_RegisterShaderNoMip( ART_FX_BASE );
    uiInfo.uiDC.Assets.fxPic[0] = trap_R_RegisterShaderNoMip( ART_FX_RED );
    uiInfo.uiDC.Assets.fxPic[1] = trap_R_RegisterShaderNoMip( ART_FX_YELLOW );
    uiInfo.uiDC.Assets.fxPic[2] = trap_R_RegisterShaderNoMip( ART_FX_GREEN );
    uiInfo.uiDC.Assets.fxPic[3] = trap_R_RegisterShaderNoMip( ART_FX_TEAL );
    uiInfo.uiDC.Assets.fxPic[4] = trap_R_RegisterShaderNoMip( ART_FX_BLUE );
    uiInfo.uiDC.Assets.fxPic[5] = trap_R_RegisterShaderNoMip( ART_FX_CYAN );
    uiInfo.uiDC.Assets.fxPic[6] = trap_R_RegisterShaderNoMip( ART_FX_WHITE );
    uiInfo.uiDC.Assets.scrollBar = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR );
    uiInfo.uiDC.Assets.scrollBarArrowDown = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
    uiInfo.uiDC.Assets.scrollBarArrowUp = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
    uiInfo.uiDC.Assets.scrollBarArrowLeft = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
    uiInfo.uiDC.Assets.scrollBarArrowRight = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
    uiInfo.uiDC.Assets.scrollBarThumb = trap_R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
    uiInfo.uiDC.Assets.sliderBar = trap_R_RegisterShaderNoMip( ASSET_SLIDER_BAR );
    uiInfo.uiDC.Assets.sliderThumb = trap_R_RegisterShaderNoMip( ASSET_SLIDER_THUMB );

    for( n = 0; n < NUM_CROSSHAIRS; n++ ) {
        uiInfo.uiDC.Assets.crosshairShader[n] = trap_R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a' + n ) );
    }

    uiInfo.newHighScoreSound = trap_S_RegisterSound("sound/feedback/voc_newhighscore.wav", qfalse);
}

void _UI_DrawSides(float x, float y, float w, float h, float size) {
    UI_AdjustFrom640( &x, &y, &w, &h );
    size *= uiInfo.uiDC.xscale;
    trap_R_DrawStretchPic( x, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
    trap_R_DrawStretchPic( x + w - size, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
}

void _UI_DrawTopBottom(float x, float y, float w, float h, float size) {
    UI_AdjustFrom640( &x, &y, &w, &h );
    size *= uiInfo.uiDC.yscale;
    trap_R_DrawStretchPic( x, y, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
    trap_R_DrawStretchPic( x, y + h - size, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
}
/*
================
UI_DrawRect

Coordinates are 640*480 virtual values
=================
*/
void _UI_DrawRect( float x, float y, float width, float height, float size, const float *color ) {
    trap_R_SetColor( color );

  _UI_DrawTopBottom(x, y, width, height, size);
  _UI_DrawSides(x, y, width, height, size);

    trap_R_SetColor( NULL );
}

int Text_Width(const char *text, float scale, int limit) {
  int count,len;
    float out;
    glyphInfo_t *glyph;
    float useScale;
    const char *s = text;
    fontInfo_t *font = &uiInfo.uiDC.Assets.textFont;
    if (scale <= ui_smallFont.value) {
        font = &uiInfo.uiDC.Assets.smallFont;
    } else if (scale >= ui_bigFont.value) {
        font = &uiInfo.uiDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  out = 0;
  if (text) {
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            if ( Q_IsColorString(s) ) {
                s += 2;
                continue;
            } else {
                glyph = &font->glyphs[(int)*s];
                out += glyph->xSkip;
                s++;
                count++;
            }
    }
  }
  return out * useScale;
}

int Text_Height(const char *text, float scale, int limit) {
  int len, count;
    float max;
    glyphInfo_t *glyph;
    float useScale;
    const char *s = text; // bk001206 - unsigned
    fontInfo_t *font = &uiInfo.uiDC.Assets.textFont;
    if (scale <= ui_smallFont.value) {
        font = &uiInfo.uiDC.Assets.smallFont;
    } else if (scale >= ui_bigFont.value) {
        font = &uiInfo.uiDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  max = 0;
  if (text) {
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            if ( Q_IsColorString(s) ) {
                s += 2;
                continue;
            } else {
                glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
          if (max < glyph->height) {
              max = glyph->height;
              }
                s++;
                count++;
            }
    }
  }
  return max * useScale;
}

void Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader) {
  float w, h;
  w = width * scale;
  h = height * scale;
  UI_AdjustFrom640( &x, &y, &w, &h );
  trap_R_DrawStretchPic( x, y, w, h, s, t, s2, t2, hShader );
}

void Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style) {
  int len, count;
    vec4_t newColor;
    glyphInfo_t *glyph;
    float useScale;
    fontInfo_t *font = &uiInfo.uiDC.Assets.textFont;
    if (scale <= ui_smallFont.value) {
        font = &uiInfo.uiDC.Assets.smallFont;
    } else if (scale >= ui_bigFont.value) {
        font = &uiInfo.uiDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  if (text) {
    const char *s = text; // bk001206 - unsigned
        trap_R_SetColor( color );
        memcpy(&newColor[0], &color[0], sizeof(vec4_t));
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
      //int yadj = Assets.textFont.glyphs[text[i]].bottom + Assets.textFont.glyphs[text[i]].top;
      //float yadj = scale * (Assets.textFont.glyphs[text[i]].imageHeight - Assets.textFont.glyphs[text[i]].height);
            if ( Q_IsColorString( s ) ) {
                memcpy( newColor, g_color_table[ColorIndex(*(s+1))], sizeof( newColor ) );
                newColor[3] = color[3];
                trap_R_SetColor( newColor );
                s += 2;
                continue;
            } else {
                float yadj = useScale * glyph->top;
                if (style == ITEM_TEXTSTYLE_SHADOWED || style == ITEM_TEXTSTYLE_SHADOWEDMORE) {
                    int ofs = style == ITEM_TEXTSTYLE_SHADOWED ? 1 : 2;
                    colorBlack[3] = newColor[3];
                    trap_R_SetColor( colorBlack );
                    Text_PaintChar(x + ofs, y - yadj + ofs, 
                                                        glyph->imageWidth,
                                                        glyph->imageHeight,
                                                        useScale, 
                                                        glyph->s,
                                                        glyph->t,
                                                        glyph->s2,
                                                        glyph->t2,
                                                        glyph->glyph);
                    trap_R_SetColor( newColor );
                    colorBlack[3] = 1.0;
                }
                Text_PaintChar(x, y - yadj, 
                                                    glyph->imageWidth,
                                                    glyph->imageHeight,
                                                    useScale, 
                                                    glyph->s,
                                                    glyph->t,
                                                    glyph->s2,
                                                    glyph->t2,
                                                    glyph->glyph);

                x += (glyph->xSkip * useScale) + adjust;
                s++;
                count++;
            }
    }
      trap_R_SetColor( NULL );
  }
}

void Text_PaintWithCursor(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int limit, int style) {
  int len, count;
    vec4_t newColor;
    glyphInfo_t *glyph, *glyph2;
    float yadj;
    float useScale;
    fontInfo_t *font = &uiInfo.uiDC.Assets.textFont;
    if (scale <= ui_smallFont.value) {
        font = &uiInfo.uiDC.Assets.smallFont;
    } else if (scale >= ui_bigFont.value) {
        font = &uiInfo.uiDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  if (text) {
    const char *s = text; // bk001206 - unsigned
        trap_R_SetColor( color );
        memcpy(&newColor[0], &color[0], sizeof(vec4_t));
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        glyph2 = &font->glyphs[ (int) cursor]; // bk001206 - possible signed char
        while (s && *s && count < len) {
            glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
      //int yadj = Assets.textFont.glyphs[text[i]].bottom + Assets.textFont.glyphs[text[i]].top;
      //float yadj = scale * (Assets.textFont.glyphs[text[i]].imageHeight - Assets.textFont.glyphs[text[i]].height);
            if ( Q_IsColorString( s ) ) {
                memcpy( newColor, g_color_table[ColorIndex(*(s+1))], sizeof( newColor ) );
                newColor[3] = color[3];
                trap_R_SetColor( newColor );
                s += 2;
                continue;
            } else {
                yadj = useScale * glyph->top;
                if (style == ITEM_TEXTSTYLE_SHADOWED || style == ITEM_TEXTSTYLE_SHADOWEDMORE) {
                    int ofs = style == ITEM_TEXTSTYLE_SHADOWED ? 1 : 2;
                    colorBlack[3] = newColor[3];
                    trap_R_SetColor( colorBlack );
                    Text_PaintChar(x + ofs, y - yadj + ofs, 
                                                        glyph->imageWidth,
                                                        glyph->imageHeight,
                                                        useScale, 
                                                        glyph->s,
                                                        glyph->t,
                                                        glyph->s2,
                                                        glyph->t2,
                                                        glyph->glyph);
                    colorBlack[3] = 1.0;
                    trap_R_SetColor( newColor );
                }
                Text_PaintChar(x, y - yadj, 
                                                    glyph->imageWidth,
                                                    glyph->imageHeight,
                                                    useScale, 
                                                    glyph->s,
                                                    glyph->t,
                                                    glyph->s2,
                                                    glyph->t2,
                                                    glyph->glyph);

          yadj = useScale * glyph2->top;
            if (count == cursorPos && !((uiInfo.uiDC.realTime/BLINK_DIVISOR) & 1)) {
                    Text_PaintChar(x, y - yadj, 
                                                        glyph2->imageWidth,
                                                        glyph2->imageHeight,
                                                        useScale, 
                                                        glyph2->s,
                                                        glyph2->t,
                                                        glyph2->s2,
                                                        glyph2->t2,
                                                        glyph2->glyph);
                }

                x += (glyph->xSkip * useScale);
                s++;
                count++;
            }
    }
    // need to paint cursor at end of text
    if (cursorPos == len && !((uiInfo.uiDC.realTime/BLINK_DIVISOR) & 1)) {
        yadj = useScale * glyph2->top;
        Text_PaintChar(x, y - yadj, 
                          glyph2->imageWidth,
                          glyph2->imageHeight,
                          useScale, 
                          glyph2->s,
                          glyph2->t,
                          glyph2->s2,
                          glyph2->t2,
                          glyph2->glyph);

    }

      trap_R_SetColor( NULL );
  }
}


static void Text_Paint_Limit(float *maxX, float x, float y, float scale, vec4_t color, const char* text, float adjust, int limit) {
  int len, count;
    vec4_t newColor;
    glyphInfo_t *glyph;
  if (text) {
    const char *s = text; // bk001206 - unsigned
        float max = *maxX;
        float useScale;
        fontInfo_t *font = &uiInfo.uiDC.Assets.textFont;
        if (scale <= ui_smallFont.value) {
            font = &uiInfo.uiDC.Assets.smallFont;
        } else if (scale > ui_bigFont.value) {
            font = &uiInfo.uiDC.Assets.bigFont;
        }
        useScale = scale * font->glyphScale;
        trap_R_SetColor( color );
    len = strlen(text);                  
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
            if ( Q_IsColorString( s ) ) {
                memcpy( newColor, g_color_table[ColorIndex(*(s+1))], sizeof( newColor ) );
                newColor[3] = color[3];
                trap_R_SetColor( newColor );
                s += 2;
                continue;
            } else {
          float yadj = useScale * glyph->top;
                if (Text_Width(s, useScale, 1) + x > max) {
                    *maxX = 0;
                    break;
                }
            Text_PaintChar(x, y - yadj, 
                             glyph->imageWidth,
                               glyph->imageHeight,
                               useScale, 
                                   glyph->s,
                                       glyph->t,
                                       glyph->s2,
                                         glyph->t2,
                                           glyph->glyph);
          x += (glyph->xSkip * useScale) + adjust;
                *maxX = x;
                count++;
                s++;
        }
        }
      trap_R_SetColor( NULL );
  }

}


void UI_ShowPostGame(qboolean newHigh) {
    trap_Cvar_Set ("cg_cameraOrbit", "0");
    trap_Cvar_Set("cg_thirdPerson", "0");
    trap_Cvar_Set( "sv_killserver", "1" );
    uiInfo.soundHighScore = newHigh;
  _UI_SetActiveMenu(UIMENU_POSTGAME);
}
/*
=================
_UI_Refresh
=================
*/

void UI_DrawCenteredPic(qhandle_t image, int w, int h) {
  int x, y;
  x = (SCREEN_WIDTH - w) / 2;
  y = (SCREEN_HEIGHT - h) / 2;
  UI_DrawHandlePic(x, y, w, h, image);
}

int frameCount = 0;
int startTime;

#define UI_FPS_FRAMES   4
void _UI_Refresh( int realtime )
{
    static int index;
    static int  previousTimes[UI_FPS_FRAMES];

    //if ( !( trap_Key_GetCatcher() & KEYCATCH_UI ) ) {
    //  return;
    //}

    uiInfo.uiDC.frameTime = realtime - uiInfo.uiDC.realTime;
    uiInfo.uiDC.realTime = realtime;

    previousTimes[index % UI_FPS_FRAMES] = uiInfo.uiDC.frameTime;
    index++;
    if ( index > UI_FPS_FRAMES ) {
        int i, total;
        // average multiple frames together to smooth changes out a bit
        total = 0;
        for ( i = 0 ; i < UI_FPS_FRAMES ; i++ ) {
            total += previousTimes[i];
        }
        if ( !total ) {
            total = 1;
        }
        uiInfo.uiDC.FPS = 1000 * UI_FPS_FRAMES / total;
    }



    UI_UpdateCvars();

    if (Menu_Count() > 0) {
        // paint all the menus
        Menu_PaintAll();
        // refresh server browser list
        UI_DoServerRefresh();
        // refresh server status
        UI_BuildServerStatus(qfalse);
        // refresh find player list
        UI_BuildFindPlayerList(qfalse);
    } 
    
    // draw cursor
    UI_SetColor( NULL );
    if (Menu_Count() > 0) {
        UI_DrawHandlePic( uiInfo.uiDC.cursorx-16, uiInfo.uiDC.cursory-16, 32, 32, uiInfo.uiDC.Assets.cursor);
    }

#ifndef NDEBUG
    if (uiInfo.uiDC.debug)
    {
        // cursor coordinates
        //FIXME
        //UI_DrawString( 0, 0, va("(%d,%d)",uis.cursorx,uis.cursory), UI_LEFT|UI_SMALLFONT, colorRed );
    }
#endif

}

/*
=================
_UI_Shutdown
=================
*/
void _UI_Shutdown( void ) {
    trap_LAN_SaveCachedServers();
}

char *defaultMenu = NULL;

char *GetMenuBuffer(const char *filename) {
    int len;
    fileHandle_t    f;
    static char buf[MAX_MENUFILE];

    len = trap_FS_FOpenFile( filename, &f, FS_READ );
    if ( !f ) {
        trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", filename ) );
        return defaultMenu;
    }
    if ( len >= MAX_MENUFILE ) {
        trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", filename, len, MAX_MENUFILE ) );
        trap_FS_FCloseFile( f );
        return defaultMenu;
    }

    trap_FS_Read( buf, len, f );
    buf[len] = 0;
    trap_FS_FCloseFile( f );
    //COM_Compress(buf);
  return buf;

}

qboolean Asset_Parse(int handle) {
    pc_token_t token;
    const char *tempStr;

    if (!trap_PC_ReadToken(handle, &token))
        return qfalse;
    if (Q_stricmp(token.string, "{") != 0) {
        return qfalse;
    }
    
    while ( 1 ) {

        memset(&token, 0, sizeof(pc_token_t));

        if (!trap_PC_ReadToken(handle, &token))
            return qfalse;

        if (Q_stricmp(token.string, "}") == 0) {
            return qtrue;
        }

        // font
        if (Q_stricmp(token.string, "font") == 0) {
            int pointSize;
            if (!PC_String_Parse(handle, &tempStr) || !PC_Int_Parse(handle,&pointSize)) {
                return qfalse;
            }
            trap_R_RegisterFont(tempStr, pointSize, &uiInfo.uiDC.Assets.textFont);
            uiInfo.uiDC.Assets.fontRegistered = qtrue;
            continue;
        }

        if (Q_stricmp(token.string, "smallFont") == 0) {
            int pointSize;
            if (!PC_String_Parse(handle, &tempStr) || !PC_Int_Parse(handle,&pointSize)) {
                return qfalse;
            }
            trap_R_RegisterFont(tempStr, pointSize, &uiInfo.uiDC.Assets.smallFont);
            continue;
        }

        if (Q_stricmp(token.string, "bigFont") == 0) {
            int pointSize;
            if (!PC_String_Parse(handle, &tempStr) || !PC_Int_Parse(handle,&pointSize)) {
                return qfalse;
            }
            trap_R_RegisterFont(tempStr, pointSize, &uiInfo.uiDC.Assets.bigFont);
            continue;
        }


        // gradientbar
        if (Q_stricmp(token.string, "gradientbar") == 0) {
            if (!PC_String_Parse(handle, &tempStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.gradientBar = trap_R_RegisterShaderNoMip(tempStr);
            continue;
        }

        // enterMenuSound
        if (Q_stricmp(token.string, "menuEnterSound") == 0) {
            if (!PC_String_Parse(handle, &tempStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.menuEnterSound = trap_S_RegisterSound( tempStr, qfalse );
            continue;
        }

        // exitMenuSound
        if (Q_stricmp(token.string, "menuExitSound") == 0) {
            if (!PC_String_Parse(handle, &tempStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.menuExitSound = trap_S_RegisterSound( tempStr, qfalse );
            continue;
        }

        // itemFocusSound
        if (Q_stricmp(token.string, "itemFocusSound") == 0) {
            if (!PC_String_Parse(handle, &tempStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.itemFocusSound = trap_S_RegisterSound( tempStr, qfalse );
            continue;
        }

        // menuBuzzSound
        if (Q_stricmp(token.string, "menuBuzzSound") == 0) {
            if (!PC_String_Parse(handle, &tempStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.menuBuzzSound = trap_S_RegisterSound( tempStr, qfalse );
            continue;
        }

        if (Q_stricmp(token.string, "cursor") == 0) {
            if (!PC_String_Parse(handle, &uiInfo.uiDC.Assets.cursorStr)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.cursor = trap_R_RegisterShaderNoMip( uiInfo.uiDC.Assets.cursorStr);
            continue;
        }

        if (Q_stricmp(token.string, "fadeClamp") == 0) {
            if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.fadeClamp)) {
                return qfalse;
            }
            continue;
        }

        if (Q_stricmp(token.string, "fadeCycle") == 0) {
            if (!PC_Int_Parse(handle, &uiInfo.uiDC.Assets.fadeCycle)) {
                return qfalse;
            }
            continue;
        }

        if (Q_stricmp(token.string, "fadeAmount") == 0) {
            if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.fadeAmount)) {
                return qfalse;
            }
            continue;
        }

        if (Q_stricmp(token.string, "shadowX") == 0) {
            if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.shadowX)) {
                return qfalse;
            }
            continue;
        }

        if (Q_stricmp(token.string, "shadowY") == 0) {
            if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.shadowY)) {
                return qfalse;
            }
            continue;
        }

        if (Q_stricmp(token.string, "shadowColor") == 0) {
            if (!PC_Color_Parse(handle, &uiInfo.uiDC.Assets.shadowColor)) {
                return qfalse;
            }
            uiInfo.uiDC.Assets.shadowFadeClamp = uiInfo.uiDC.Assets.shadowColor[3];
            continue;
        }

    }
    return qfalse;
}

void Font_Report() {
  int i;
  Com_Printf("Font Info\n");
  Com_Printf("=========\n");
  for ( i = 32; i < 96; i++) {
    Com_Printf("Glyph handle %i: %i\n", i, uiInfo.uiDC.Assets.textFont.glyphs[i].glyph);
  }
}

void UI_Report() {
  String_Report();
  //Font_Report();

}

void UI_ParseMenu(const char *menuFile) {
    int handle;
    pc_token_t token;

    Com_Printf("Parsing menu file:%s\n", menuFile);

    handle = trap_PC_LoadSource(menuFile);
    if (!handle) {
        return;
    }

    while ( 1 ) {
        memset(&token, 0, sizeof(pc_token_t));
        if (!trap_PC_ReadToken( handle, &token )) {
            break;
        }

        //if ( Q_stricmp( token, "{" ) ) {
        //  Com_Printf( "Missing { in menu file\n" );
        //  break;
        //}

        //if ( menuCount == MAX_MENUS ) {
        //  Com_Printf( "Too many menus!\n" );
        //  break;
        //}

        if ( token.string[0] == '}' ) {
            break;
        }

        if (Q_stricmp(token.string, "assetGlobalDef") == 0) {
            if (Asset_Parse(handle)) {
                continue;
            } else {
                break;
            }
        }

        if (Q_stricmp(token.string, "menudef") == 0) {
            // start a new menu
            Menu_New(handle);
        }
    }
    trap_PC_FreeSource(handle);
}

qboolean Load_Menu(int handle) {
    pc_token_t token;

    if (!trap_PC_ReadToken(handle, &token))
        return qfalse;
    if (token.string[0] != '{') {
        return qfalse;
    }

    while ( 1 ) {

        if (!trap_PC_ReadToken(handle, &token))
            return qfalse;
    
        if ( token.string[0] == 0 ) {
            return qfalse;
        }

        if ( token.string[0] == '}' ) {
            return qtrue;
        }

        UI_ParseMenu(token.string); 
    }
    return qfalse;
}

void UI_LoadMenus(const char *menuFile, qboolean reset) {
    pc_token_t token;
    int handle;
    int start;

    start = trap_Milliseconds();

    handle = trap_PC_LoadSource( menuFile );
    if (!handle) {
        trap_Error( va( S_COLOR_YELLOW "menu file not found: %s, using default\n", menuFile ) );
        handle = trap_PC_LoadSource( "ui/menus.txt" );
        if (!handle) {
            trap_Error( va( S_COLOR_RED "default menu file not found: ui/menus.txt, unable to continue!\n", menuFile ) );
        }
    }

    ui_new.integer = 1;

    if (reset) {
        Menu_Reset();
    }

    while ( 1 ) {
        if (!trap_PC_ReadToken(handle, &token))
            break;
        if( token.string[0] == 0 || token.string[0] == '}') {
            break;
        }

        if ( token.string[0] == '}' ) {
            break;
        }

        if (Q_stricmp(token.string, "loadmenu") == 0) {
            if (Load_Menu(handle)) {
                continue;
            } else {
                break;
            }
        }
    }

    Com_Printf("UI menu load time = %d milli seconds\n", trap_Milliseconds() - start);

    trap_PC_FreeSource( handle );
}

void UI_Load() {
    char lastName[1024];
  menuDef_t *menu = Menu_GetFocused();
    char *menuSet = UI_Cvar_VariableString("ui_menuFiles");
    if (menu && menu->window.name) {
        strcpy(lastName, menu->window.name);
    }
    if (menuSet == NULL || menuSet[0] == '\0') {
        menuSet = "ui/menus.txt";
    }

    String_Init();

#ifdef PRE_RELEASE_TADEMO
    UI_ParseGameInfo("demogameinfo.txt");
#else
    UI_ParseGameInfo("gameinfo.txt");
    UI_LoadArenas();
#endif

    UI_LoadMenus(menuSet, qtrue);
    Menus_CloseAll();
    Menus_ActivateByName(lastName);

}

static const char *handicapValues[] = {"None","95","90","85","80","75","70","65","60","55","50","45","40","35","30","25","20","15","10","5",NULL};
#ifndef MISSIONPACK // bk001206
static int numHandicaps = sizeof(handicapValues) / sizeof(const char*);
#endif

static void UI_DrawHandicap(rectDef_t *rect, float scale, vec4_t color, int textStyle) {
  int i, h;

  h = Com_Clamp( 5, 100, trap_Cvar_VariableValue("handicap") );
  i = 20 - h / 5;

  Text_Paint(rect->x, rect->y, scale, color, handicapValues[i], 0, 0, textStyle);
}

static void UI_DrawClanName(rectDef_t *rect, float scale, vec4_t color, int textStyle) {
  Text_Paint(rect->x, rect->y, scale, color, UI_Cvar_VariableString("ui_teamName"), 0, 0, textStyle);
}


static void UI_SetCapFragLimits(qboolean uiVars) {
    int cap = 5;
    int frag = 10;
    if (uiInfo.gameTypes[ui_gameType.integer].gtEnum == GT_OBELISK) {
        cap = 4;
    } else if (uiInfo.gameTypes[ui_gameType.integer].gtEnum == GT_HARVESTER) {
        cap = 15;
    }
    if (uiVars) {
        trap_Cvar_Set("ui_captureLimit", va("%d", cap));
        trap_Cvar_Set("ui_fragLimit", va("%d", frag));
    } else {
        trap_Cvar_Set("capturelimit", va("%d", cap));
        trap_Cvar_Set("fraglimit", va("%d", frag));
    }
}
// ui_gameType assumes gametype 0 is -1 ALL and will not show
static void UI_DrawGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle) {
  Text_Paint(rect->x, rect->y, scale, color, uiInfo.gameTypes[ui_gameType.integer].gameType, 0, 0, textStyle);
}

static void UI_DrawNetGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle) {
    if (ui_netGameType.integer < 0 || ui_netGameType.integer > uiInfo.numGameTypes) {
        trap_Cvar_Set("ui_netGameType", "0");
        trap_Cvar_Set("ui_actualNetGameType", "0");
    }
  Text_Paint(rect->x, rect->y, scale, color, uiInfo.