/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2000-2013 Darklegion Development
 
This file is part of Tremulous.
 
Tremulous is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
 
Tremulous is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with Tremulous; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

/*
=======================================================================
 
USER INTERFACE MAIN
 
=======================================================================
*/

#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 *netSources[ ] =
{
  "Internet",
  "Mplayer",
  "LAN",
  "Favorites"
};

static const size_t numNetSources = ARRAY_LEN( netSources );

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

/*
================
cvars
================
*/

typedef struct
{
  vmCvar_t  *vmCvar;
  char    *cvarName;
  char    *defaultString;
  int     cvarFlags;
}

cvarTable_t;

vmCvar_t  ui_browserShowFull;
vmCvar_t  ui_browserShowEmpty;

vmCvar_t  ui_dedicated;
vmCvar_t  ui_netSource;
vmCvar_t  ui_selectedMap;
vmCvar_t  ui_lastServerRefresh_0;
vmCvar_t  ui_lastServerRefresh_1;
vmCvar_t  ui_lastServerRefresh_2;
vmCvar_t  ui_lastServerRefresh_3;
vmCvar_t  ui_lastServerRefresh_0_time;
vmCvar_t  ui_lastServerRefresh_1_time;
vmCvar_t  ui_lastServerRefresh_2_time;
vmCvar_t  ui_lastServerRefresh_3_time;
vmCvar_t  ui_smallFont;
vmCvar_t  ui_bigFont;
vmCvar_t  ui_findPlayer;
vmCvar_t  ui_serverStatusTimeOut;
vmCvar_t  ui_textWrapCache;
vmCvar_t  ui_developer;

vmCvar_t  ui_emoticons;
vmCvar_t  ui_winner;
vmCvar_t  ui_chatCommands;

static cvarTable_t    cvarTable[ ] =
{
  { &ui_browserShowFull, "ui_browserShowFull", "1", CVAR_ARCHIVE },
  { &ui_browserShowEmpty, "ui_browserShowEmpty", "1", CVAR_ARCHIVE },

  { &ui_dedicated, "ui_dedicated", "0", CVAR_ARCHIVE },
  { &ui_netSource, "ui_netSource", "0", CVAR_ARCHIVE },
  { &ui_selectedMap, "ui_selectedMap", "0", CVAR_ARCHIVE },
  { &ui_lastServerRefresh_0, "ui_lastServerRefresh_0", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_1, "ui_lastServerRefresh_1", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_2, "ui_lastServerRefresh_2", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_3, "ui_lastServerRefresh_3", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_0, "ui_lastServerRefresh_0_time", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_1, "ui_lastServerRefresh_1_time", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_2, "ui_lastServerRefresh_2_time", "", CVAR_ARCHIVE},
  { &ui_lastServerRefresh_3, "ui_lastServerRefresh_3_time", "", CVAR_ARCHIVE},
  { &ui_smallFont, "ui_smallFont", "0.2", CVAR_ARCHIVE | CVAR_LATCH },
  { &ui_bigFont, "ui_bigFont", "0.5", CVAR_ARCHIVE | CVAR_LATCH },
  { &ui_findPlayer, "ui_findPlayer", "", CVAR_ARCHIVE},
  { &ui_serverStatusTimeOut, "ui_serverStatusTimeOut", "7000", CVAR_ARCHIVE},
  { &ui_textWrapCache, "ui_textWrapCache", "1", CVAR_ARCHIVE },
  { &ui_developer, "ui_developer", "0", CVAR_ARCHIVE | CVAR_CHEAT },
  { &ui_emoticons, "cg_emoticons", "1", CVAR_LATCH | CVAR_ARCHIVE },
  { &ui_winner, "ui_winner", "", CVAR_ROM },
  { &ui_chatCommands, "ui_chatCommands", "1", CVAR_ARCHIVE }
};

static size_t cvarTableSize = ARRAY_LEN( cvarTable );

/*
================
vmMain
 
This is the only way control passes into the module.
This must be the very first function compiled into the .qvm file
================
*/
void UI_Init( qboolean );
void UI_Shutdown( void );
void UI_KeyEvent( int key, qboolean down );
void UI_MouseEvent( int dx, int dy );
int UI_MousePosition( void );
void UI_SetMousePosition( int x, int y );
void UI_Refresh( int realtime );
qboolean UI_IsFullscreen( void );
void UI_SetActiveMenu( uiMenuCommand_t menu );
Q_EXPORT intptr_t 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_MOUSE_POSITION:
      return UI_MousePosition( );

    case UI_SET_MOUSE_POSITION:
      UI_SetMousePosition( 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;
  }

  return -1;
}



void AssetCache( void )
{
  int i;

  uiInfo.uiDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
  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 );

  if( ui_emoticons.integer ) 
  {
    uiInfo.uiDC.Assets.emoticonCount = BG_LoadEmoticons(
      uiInfo.uiDC.Assets.emoticons, MAX_EMOTICONS );
  }
  else
    uiInfo.uiDC.Assets.emoticonCount = 0;

  for( i = 0; i < uiInfo.uiDC.Assets.emoticonCount; i++ )
  {
    uiInfo.uiDC.Assets.emoticons[ i ].shader = trap_R_RegisterShaderNoMip( 
      va( "emoticons/%s_%dx1.tga", uiInfo.uiDC.Assets.emoticons[ i ].name,
          uiInfo.uiDC.Assets.emoticons[ i ].width ) );
  }
}

void UI_DrawSides( float x, float y, float w, float h, float size )
{
  float sizeY;

  UI_AdjustFrom640( &x, &y, &w, &h );
  sizeY = size * uiInfo.uiDC.yscale;
  size *= uiInfo.uiDC.xscale;

  trap_R_DrawStretchPic( x, y + sizeY, size, h - ( sizeY * 2.0f ), 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
  trap_R_DrawStretchPic( x + w - size, y + sizeY, size, h - ( sizeY * 2.0f ), 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 );
}

/*
==================
UI_ServerInfoIsValid

Return false if the infostring contains nonprinting characters, 
 or if the hostname is blank/undefined
==================
*/
static qboolean UI_ServerInfoIsValid( char *info )
{
  char *c;
  int  len = 0;

  for( c = info; *c; c++ )
  {
    if( !isprint( *c ) )
      return qfalse;
  }

  for( c = Info_ValueForKey( info, "hostname" ); *c; c++ )
  {
    if( isgraph( *c ) )
      len++;
  }

  if( len )
    return qtrue;
  else
    return qfalse;
}

/*
==================
UI_InsertServerIntoDisplayList
==================
*/
static void UI_InsertServerIntoDisplayList( int num, int position )
{
  int         i;
  static char info[MAX_STRING_CHARS];

  if( position < 0 || position > uiInfo.serverStatus.numDisplayServers )
    return;

  trap_LAN_GetServerInfo( ui_netSource.integer, num, info, MAX_STRING_CHARS );

  if( !UI_ServerInfoIsValid( info ) ) // don't list servers with invalid info
    return;

  uiInfo.serverStatus.numDisplayServers++;

  for( i = uiInfo.serverStatus.numDisplayServers; i > position; i-- )
    uiInfo.serverStatus.displayServers[i] = uiInfo.serverStatus.displayServers[i-1];

  uiInfo.serverStatus.displayServers[position] = num;
}

/*
==================
UI_RemoveServerFromDisplayList
==================
*/
static void UI_RemoveServerFromDisplayList( int num )
{
  int i, j;
  static char info[MAX_STRING_CHARS];

  for( i = 0; i < uiInfo.serverStatus.numDisplayServers; i++ )
  {
    if( uiInfo.serverStatus.displayServers[i] == num )
    {
      uiInfo.serverStatus.numDisplayServers--;

      trap_LAN_GetServerInfo( ui_netSource.integer, num, info, MAX_STRING_CHARS );

      for( j = i; j < uiInfo.serverStatus.numDisplayServers; j++ )
        uiInfo.serverStatus.displayServers[j] = uiInfo.serverStatus.displayServers[j+1];

      return;
    }
  }
}

/*
==================
UI_BinaryServerInsertion
==================
*/
static void UI_BinaryServerInsertion( int num )
{
  int mid, offset, res, len;

  // use binary search to insert server
  len = uiInfo.serverStatus.numDisplayServers;
  mid = len;
  offset = 0;
  res = 0;

  while( mid > 0 )
  {
    mid = len >> 1;
    //
    res = trap_LAN_CompareServers( ui_netSource.integer, uiInfo.serverStatus.sortKey,
                                   uiInfo.serverStatus.sortDir, num, uiInfo.serverStatus.displayServers[offset+mid] );
    // if equal

    if( res == 0 )
    {
      UI_InsertServerIntoDisplayList( num, offset + mid );
      return;
    }

    // if larger
    else if( res == 1 )
    {
      offset += mid;
      len -= mid;
    }

    // if smaller
    else
      len -= mid;
  }

  if( res == 1 )
    offset++;

  UI_InsertServerIntoDisplayList( num, offset );
}

typedef struct
{
  char *name, *altName;
}

serverStatusCvar_t;

serverStatusCvar_t serverStatusCvars[] = {
      {"sv_hostname", "Name"},
      {"Address", ""},
      {"gamename", "Game name"},
      {"mapname", "Map"},
      {"version", ""},
      {"protocol", ""},
      {"timelimit", ""},
      {NULL, NULL}
    };

/*
==================
UI_SortServerStatusInfo
==================
*/

static int UI_SortServerStatusCompare( const void *a, const void *b )
{
  const char **la = (const char **)a;
  const char **lb = (const char **)b;

  return strcmp( la[0], lb[0] );
}

static void UI_SortServerStatusInfo( serverStatusInfo_t *info )
{
  int i, j, index;
  char *tmp1, *tmp2;

  index = 0;

  for( i = 0; serverStatusCvars[i].name; i++ )
  {
    for( j = 0; j < info->numLines; j++ )
    {
      if( !info->lines[j][1] || info->lines[j][1][0] )
        continue;

      if( !Q_stricmp( serverStatusCvars[i].name, info->lines[j][0] ) )
      {
        // swap lines
        tmp1 = info->lines[index][0];
        tmp2 = info->lines[index][3];
        info->lines[index][0] = info->lines[j][0];
        info->lines[index][3] = info->lines[j][3];
        info->lines[j][0] = tmp1;
        info->lines[j][3] = tmp2;
        //

        if( strlen( serverStatusCvars[i].altName ) )
          info->lines[index][0] = serverStatusCvars[i].altName;

        index++;
      }
    }
  }

  // sort remaining cvars
  qsort( info->lines + index,
         info->numLines - index, sizeof( info->lines[ 0 ] ),
         UI_SortServerStatusCompare );
}

/*
==================
UI_GetServerStatusInfo
==================
*/
static int UI_GetServerStatusInfo( const char *serverAddress, serverStatusInfo_t *info )
{
  char *p, *score, *ping, *name;
  int i, len;

  if( !info )
  {
    trap_LAN_ServerStatus( serverAddress, NULL, 0 );
    return qfalse;
  }

  memset( info, 0, sizeof( *info ) );

  if( trap_LAN_ServerStatus( serverAddress, info->text, sizeof( info->text ) ) )
  {
    Q_strncpyz( info->address, serverAddress, sizeof( info->address ) );
    p = info->text;
    info->numLines = 0;
    info->lines[info->numLines][0] = "Address";
    info->lines[info->numLines][1] = "";
    info->lines[info->numLines][2] = "";
    info->lines[info->numLines][3] = info->address;
    info->numLines++;
    // get the cvars

    while( p && *p )
    {
      p = strchr( p, '\\' );

      if( !p ) break;

      *p++ = '\0';

      if( *p == '\\' )
        break;

      info->lines[info->numLines][0] = p;
      info->lines[info->numLines][1] = "";
      info->lines[info->numLines][2] = "";

      p = strchr( p, '\\' );

      if( !p ) break;

      *p++ = '\0';

      info->lines[info->numLines][3] = p;
      info->numLines++;

      if( info->numLines >= MAX_SERVERSTATUS_LINES )
        break;
    }

    UI_SortServerStatusInfo( info );

    // get the player list
    if( info->numLines < MAX_SERVERSTATUS_LINES - 3 )
    {
      // empty line
      info->lines[info->numLines][0] = "";
      info->lines[info->numLines][1] = "";
      info->lines[info->numLines][2] = "";
      info->lines[info->numLines][3] = "";
      info->numLines++;
      // header
      info->lines[info->numLines][0] = "num";
      info->lines[info->numLines][1] = "score";
      info->lines[info->numLines][2] = "ping";
      info->lines[info->numLines][3] = "name";
      info->numLines++;
      // parse players
      i = 0;
      len = 0;

      while( p && *p )
      {
        if( *p == '\\' )
          *p++ = '\0';

        if( !p )
          break;

        score = p;

        p = strchr( p, ' ' );

        if( !p )
          break;

        *p++ = '\0';

        ping = p;

        p = strchr( p, ' ' );

        if( !p )
          break;

        *p++ = '\0';

        name = p;

        Com_sprintf( &info->pings[len], sizeof( info->pings ) - len, "%d", i );

        info->lines[info->numLines][0] = &info->pings[len];

        len += strlen( &info->pings[len] ) + 1;

        info->lines[info->numLines][1] = score;
        info->lines[info->numLines][2] = ping;
        info->lines[info->numLines][3] = name;
        info->numLines++;

        if( info->numLines >= MAX_SERVERSTATUS_LINES )
          break;

        p = strchr( p, '\\' );

        if( !p )
          break;

        *p++ = '\0';

        //
        i++;
      }
    }

    return qtrue;
  }

  return qfalse;
}

/*
==================
stristr
==================
*/
static char *stristr( char *str, char *charset )
{
  int i;

  while( *str )
  {
    for( i = 0; charset[i] && str[i]; i++ )
      if( toupper( charset[i] ) != toupper( str[i] ) ) break;

    if( !charset[i] ) return str;

    str++;
  }

  return NULL;
}

/*
==================
UI_BuildFindPlayerList
==================
*/
static void UI_FeederSelection( int feederID, int index );

static void UI_BuildFindPlayerList( qboolean force )
{
  static int numFound, numTimeOuts;
  int i, j, k, resend;
  serverStatusInfo_t info;
  char name[MAX_NAME_LENGTH+2];
  char infoString[MAX_STRING_CHARS];
  qboolean duplicate;

  if( !force )
  {
    if( !uiInfo.nextFindPlayerRefresh || uiInfo.nextFindPlayerRefresh > uiInfo.uiDC.realTime )
      return;
  }
  else
  {
    memset( &uiInfo.pendingServerStatus, 0, sizeof( uiInfo.pendingServerStatus ) );
    uiInfo.numFoundPlayerServers = 0;
    uiInfo.currentFoundPlayerServer = 0;
    trap_Cvar_VariableStringBuffer( "ui_findPlayer", uiInfo.findPlayerName, sizeof( uiInfo.findPlayerName ) );
    Q_CleanStr( uiInfo.findPlayerName );
    // should have a string of some length

    if( !strlen( uiInfo.findPlayerName ) )
    {
      uiInfo.nextFindPlayerRefresh = 0;
      return;
    }

    // set resend time
    resend = ui_serverStatusTimeOut.integer / 2 - 10;

    if( resend < 50 )
      resend = 50;

    trap_Cvar_Set( "cl_serverStatusResendTime", va( "%d", resend ) );
    // reset all server status requests
    trap_LAN_ServerStatus( NULL, NULL, 0 );
    //
    uiInfo.numFoundPlayerServers = 1;
    Com_sprintf( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                 sizeof( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1] ),
                 "searching %d...", uiInfo.pendingServerStatus.num );
    numFound = 0;
    numTimeOuts++;
  }

  for( i = 0; i < MAX_SERVERSTATUSREQUESTS; i++ )
  {
    // if this pending server is valid

    if( uiInfo.pendingServerStatus.server[i].valid )
    {
      // try to get the server status for this server

      if( UI_GetServerStatusInfo( uiInfo.pendingServerStatus.server[i].adrstr, &info ) )
      {
        //
        numFound++;
        // parse through the server status lines

        for( j = 0; j < info.numLines; j++ )
        {
          // should have ping info

          if( !info.lines[j][2] || !info.lines[j][2][0] )
            continue;

          // clean string first
          Q_strncpyz( name, info.lines[j][3], sizeof( name ) );

          Q_CleanStr( name );

          duplicate = qfalse;

          for( k = 0; k < uiInfo.numFoundPlayerServers - 1; k++ )
          {
            if( Q_strncmp( uiInfo.foundPlayerServerAddresses[ k ],
                           uiInfo.pendingServerStatus.server[ i ].adrstr,
                           MAX_ADDRESSLENGTH ) == 0 )
              duplicate = qtrue;
          }

          // if the player name is a substring
          if( stristr( name, uiInfo.findPlayerName ) && !duplicate )
          {
            // add to found server list if we have space (always leave space for a line with the number found)

            if( uiInfo.numFoundPlayerServers < MAX_FOUNDPLAYER_SERVERS - 1 )
            {
              //
              Q_strncpyz( uiInfo.foundPlayerServerAddresses[uiInfo.numFoundPlayerServers-1],
                          uiInfo.pendingServerStatus.server[i].adrstr,
                          sizeof( uiInfo.foundPlayerServerAddresses[0] ) );
              Q_strncpyz( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                          uiInfo.pendingServerStatus.server[i].name,
                          sizeof( uiInfo.foundPlayerServerNames[0] ) );
              uiInfo.numFoundPlayerServers++;
            }
            else
            {
              // can't add any more so we're done
              uiInfo.pendingServerStatus.num = uiInfo.serverStatus.numDisplayServers;
            }
          }
        }

        Com_sprintf( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                     sizeof( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1] ),
                     "searching %d/%d...", numFound, uiInfo.pendingServerStatus.num );
        // retrieved the server status so reuse this spot
        uiInfo.pendingServerStatus.server[i].valid = qfalse;
      }
    }

    // if empty pending slot or timed out
    if( !uiInfo.pendingServerStatus.server[i].valid ||
         uiInfo.pendingServerStatus.server[i].startTime < uiInfo.uiDC.realTime - ui_serverStatusTimeOut.integer )
    {
      if( uiInfo.pendingServerStatus.server[i].valid )
        numTimeOuts++;

      // reset server status request for this address
      UI_GetServerStatusInfo( uiInfo.pendingServerStatus.server[i].adrstr, NULL );

      // reuse pending slot
      uiInfo.pendingServerStatus.server[i].valid = qfalse;

      // if we didn't try to get the status of all servers in the main browser yet
      if( uiInfo.pendingServerStatus.num < uiInfo.serverStatus.numDisplayServers )
      {
        uiInfo.pendingServerStatus.server[i].startTime = uiInfo.uiDC.realTime;
        trap_LAN_GetServerAddressString( ui_netSource.integer,
                                         uiInfo.serverStatus.displayServers[uiInfo.pendingServerStatus.num],
                                         uiInfo.pendingServerStatus.server[i].adrstr,
                                         sizeof( uiInfo.pendingServerStatus.server[i].adrstr ) );

        trap_LAN_GetServerInfo( ui_netSource.integer,
                                uiInfo.serverStatus.displayServers[uiInfo.pendingServerStatus.num],
                                infoString, sizeof( infoString ) );

        Q_strncpyz( uiInfo.pendingServerStatus.server[i].name,
                    Info_ValueForKey( infoString, "hostname" ),
                    sizeof( uiInfo.pendingServerStatus.server[0].name ) );

        uiInfo.pendingServerStatus.server[i].valid = qtrue;
        uiInfo.pendingServerStatus.num++;
        Com_sprintf( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                     sizeof( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1] ),
                     "searching %d/%d...", numFound, uiInfo.pendingServerStatus.num );
      }
    }
  }

  for( i = 0; i < MAX_SERVERSTATUSREQUESTS; i++ )
  {
    if( uiInfo.pendingServerStatus.server[i].valid )
      break;
  }

  // if still trying to retrieve server status info
  if( i < MAX_SERVERSTATUSREQUESTS )
    uiInfo.nextFindPlayerRefresh = uiInfo.uiDC.realTime + 25;
  else
  {
    // add a line that shows the number of servers found

    if( !uiInfo.numFoundPlayerServers )
    {
      Com_sprintf( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                   sizeof( uiInfo.foundPlayerServerAddresses[0] ), "no servers found" );
    }
    else
    {
      Com_sprintf( uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
                   sizeof( uiInfo.foundPlayerServerAddresses[0] ),
                   "%d server%s found with player %s", uiInfo.numFoundPlayerServers - 1,
                   uiInfo.numFoundPlayerServers == 2 ? "" : "s", uiInfo.findPlayerName );
    }

    uiInfo.nextFindPlayerRefresh = 0;
    // show the server status info for the selected server
    UI_FeederSelection( FEEDER_FINDPLAYER, uiInfo.currentFoundPlayerServer );
  }
}

/*
==================
UI_BuildServerStatus
==================
*/
static void UI_BuildServerStatus( qboolean force )
{
  if( uiInfo.nextFindPlayerRefresh )
    return;

  if( !force )
  {
    if( !uiInfo.nextServerStatusRefresh || uiInfo.nextServerStatusRefresh > uiInfo.uiDC.realTime )
      return;
  }
  else
  {
    Menu_SetFeederSelection( NULL, FEEDER_SERVERSTATUS, 0, NULL );
    uiInfo.serverStatusInfo.numLines = 0;
    // reset all server status requests
    trap_LAN_ServerStatus( NULL, NULL, 0 );
  }

  if( uiInfo.serverStatus.currentServer < 0 ||
      uiInfo.serverStatus.currentServer > uiInfo.serverStatus.numDisplayServers ||
      uiInfo.serverStatus.numDisplayServers == 0 )
    return;

  if( UI_GetServerStatusInfo( uiInfo.serverStatusAddress, &uiInfo.serverStatusInfo ) )
  {
    uiInfo.nextServerStatusRefresh = 0;
    UI_GetServerStatusInfo( uiInfo.serverStatusAddress, NULL );
  }
  else
    uiInfo.nextServerStatusRefresh = uiInfo.uiDC.realTime + 500;
}

/*
==================
UI_BuildServerDisplayList
==================
*/
static void UI_BuildServerDisplayList( qboolean force )
{
  int i, count, clients, maxClients, ping, len, visible;
  char info[MAX_STRING_CHARS];
  static int numinvisible;

  if( !( force || uiInfo.uiDC.realTime > uiInfo.serverStatus.nextDisplayRefresh ) )
    return;

  // if we shouldn't reset
  if( force == 2 )
    force = 0;

  // do motd updates here too
  trap_Cvar_VariableStringBuffer( "cl_motdString", uiInfo.serverStatus.motd, sizeof( uiInfo.serverStatus.motd ) );

  len = strlen( uiInfo.serverStatus.motd );

  if( len != uiInfo.serverStatus.motdLen )
  {
    uiInfo.serverStatus.motdLen = len;
    uiInfo.serverStatus.motdWidth = -1;
  }

  if( force )
  {
    numinvisible = 0;
    // clear number of displayed servers
    uiInfo.serverStatus.numDisplayServers = 0;
    uiInfo.serverStatus.numPlayersOnServers = 0;
    // set list box index to zero
    Menu_SetFeederSelection( NULL, FEEDER_SERVERS, 0, NULL );
    // mark all servers as visible so we store ping updates for them
    trap_LAN_MarkServerVisible( ui_netSource.integer, -1, qtrue );
  }

  // get the server count (comes from the master)
  count = trap_LAN_GetServerCount( ui_netSource.integer );

  if( count == -1 || ( ui_netSource.integer == AS_LOCAL && count == 0 ) )
  {
    // still waiting on a response from the master
    uiInfo.serverStatus.numDisplayServers = 0;
    uiInfo.serverStatus.numPlayersOnServers = 0;
    uiInfo.serverStatus.nextDisplayRefresh = uiInfo.uiDC.realTime + 500;
    return;
  }

  visible = qfalse;

  for( i = 0; i < count; i++ )
  {
    // if we already got info for this server

    if( !trap_LAN_ServerIsVisible( ui_netSource.integer, i ) )
      continue;

    visible = qtrue;
    // get the ping for this server
    ping = trap_LAN_GetServerPing( ui_netSource.integer, i );

    if( ping > 0 || ui_netSource.integer == AS_FAVORITES )
    {
      trap_LAN_GetServerInfo( ui_netSource.integer, i, info, MAX_STRING_CHARS );

      clients = atoi( Info_ValueForKey( info, "clients" ) );
      uiInfo.serverStatus.numPlayersOnServers += clients;

      if( ui_browserShowEmpty.integer == 0 )
      {
        if( clients == 0 )
        {
          trap_LAN_MarkServerVisible( ui_netSource.integer, i, qfalse );
          continue;
        }
      }

      if( ui_browserShowFull.integer == 0 )
      {
        maxClients = atoi( Info_ValueForKey( info, "sv_maxclients" ) );

        if( clients == maxClients )
        {
          trap_LAN_MarkServerVisible( ui_netSource.integer, i, qfalse );
          continue;
        }
      }

      // make sure we never add a favorite server twice
      if( ui_netSource.integer == AS_FAVORITES )
        UI_RemoveServerFromDisplayList( i );

      // insert the server into the list
      UI_BinaryServerInsertion( i );

      // done with this server
      if( ping > 0 )
      {
        trap_LAN_MarkServerVisible( ui_netSource.integer, i, qfalse );
        numinvisible++;
      }
    }
  }

  uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime;

  // if there were no servers visible for ping updates

  if( !visible )
  {
//    UI_StopServerRefresh();
//    uiInfo.serverStatus.nextDisplayRefresh = 0;
  }
}


/*
=================
UI_StopServerRefresh
=================
*/
static void UI_StopServerRefresh( void )
{
  int count;

  if( !uiInfo.serverStatus.refreshActive )
  {
    // not currently refreshing
    return;
  }

  uiInfo.serverStatus.refreshActive = qfalse;
  Com_Printf( "%d servers listed in browser with %d players.\n",
              uiInfo.serverStatus.numDisplayServers,
              uiInfo.serverStatus.numPlayersOnServers );
  count = trap_LAN_GetServerCount( ui_netSource.integer );

  if( count - uiInfo.serverStatus.numDisplayServers > 0 )
  {
    Com_Printf( "%d servers not listed due to packet loss, invalid info,"
                " or pings higher than %d\n",
                count - uiInfo.serverStatus.numDisplayServers,
                ( int ) trap_Cvar_VariableValue( "cl_maxPing" ) );
  }

}

/*
=================
UI_DoServerRefresh
=================
*/
static void UI_DoServerRefresh( void )
{
  qboolean wait = qfalse;

  if( !uiInfo.serverStatus.refreshActive )
    return;

  if( ui_netSource.integer != AS_FAVORITES )
  {
    if( ui_netSource.integer == AS_LOCAL )
    {
      if( !trap_LAN_GetServerCount( ui_netSource.integer ) )
        wait = qtrue;
    }
    else
    {
      if( trap_LAN_GetServerCount( ui_netSource.integer ) < 0 )
        wait = qtrue;
    }
  }

  if( uiInfo.uiDC.realTime < uiInfo.serverStatus.refreshtime )
  {
    if( wait )
      return;
  }

  // if still trying to retrieve pings
  if( trap_LAN_UpdateVisiblePings( ui_netSource.integer ) )
    uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;
  else if( !wait )
  {
    // get the last servers in the list
    UI_BuildServerDisplayList( 2 );
    // stop the refresh
    UI_StopServerRefresh();
  }

  //
  UI_BuildServerDisplayList( qfalse );
}

/*
=================
UI_UpdatePendingPings
=================
*/
static void UI_UpdatePendingPings( void )
{
  trap_LAN_ResetPings( ui_netSource.integer );
  uiInfo.serverStatus.refreshActive = qtrue;
  uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;

}

/*
=================
UI_StartServerRefresh
=================
*/
static void UI_StartServerRefresh( qboolean full )
{
  int   time;
  qtime_t q;

  time = trap_RealTime( &q );
  trap_Cvar_Set( va( "ui_lastServerRefresh_%i_time", ui_netSource.integer ),
                 va( "%i", time ) );
  trap_Cvar_Set( va( "ui_lastServerRefresh_%i", ui_netSource.integer ),
                 va( "%s-%i, %i at %i:%02i", MonthAbbrev[q.tm_mon],
                     q.tm_mday, 1900 + q.tm_year, q.tm_hour, q.tm_min ) );

  if( !full )
  {
    UI_UpdatePendingPings();
    return;
  }

  uiInfo.serverStatus.refreshActive = qtrue;
  uiInfo.serverStatus.nextDisplayRefresh = uiInfo.uiDC.realTime + 1000;
  // clear number of displayed servers
  uiInfo.serverStatus.numDisplayServers = 0;
  uiInfo.serverStatus.numPlayersOnServers = 0;
  // mark all servers as visible so we store ping updates for them
  trap_LAN_MarkServerVisible( ui_netSource.integer, -1, qtrue );
  // reset all the pings
  trap_LAN_ResetPings( ui_netSource.integer );
  //

  if( ui_netSource.integer == AS_LOCAL )
  {
    trap_Cmd_ExecuteText( EXEC_APPEND, "localservers\n" );
    uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;
    return;
  }

  uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 5000;

  if( ui_netSource.integer == AS_GLOBAL || ui_netSource.integer == AS_MPLAYER )
  {
    qboolean global = ui_netSource.integer == AS_GLOBAL;

    trap_Cmd_ExecuteText( EXEC_APPEND, va( "globalservers %d full empty\n",
                          global ? 0 : 1 ) );
  }
}

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 )
  {
    Menu_UpdateAll( );
    Menu_PaintAll( );
    UI_DoServerRefresh( );
    UI_BuildServerStatus( qfalse );
    UI_BuildFindPlayerList( qfalse );
    UI_UpdateNews( qfalse );
  }

  // draw cursor
  UI_SetColor( NULL );

  if( trap_Key_GetCatcher( ) == KEYCATCH_UI && !trap_Cvar_VariableValue( "ui_hideCursor" ) )
  {
    UI_DrawHandlePic( uiInfo.uiDC.cursorx - ( 16.0f * uiInfo.uiDC.aspectScale ), uiInfo.uiDC.cursory - 16.0f,
                      32.0f * uiInfo.uiDC.aspectScale, 32.0f, uiInfo.uiDC.Assets.cursor );
  }
}

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

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

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

  if( Q_stricmp( token.string, "{" ) != 0 )
    return qfalse;

  while( 1 )
  {
    memset( &token, 0, sizeof( pc_token_t ) );

    if( !trap_Parse_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 UI_Report( void )
{
  String_Report();
}

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

  handle = trap_Parse_LoadSource( menuFile );

  if( !handle )
  {
    Com_Printf( S_COLOR_YELLOW "WARNING: Menu file %s not found\n",
                menuFile );
    return;
  }

  while( 1 )
  {
    memset( &token, 0, sizeof( pc_token_t ) );

    if( !trap_Parse_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_Parse_FreeSource( handle );
}

qboolean Load_Menu( int handle )
{
  pc_token_t token;

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

  if( token.string[0] != '{' )
    return qfalse;

  while( 1 )
  {
    if( !trap_Parse_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_Parse_LoadSource( menuFile );

  if( !handle )
    trap_Error( va( S_COLOR_RED "menu list '%s' not found, unable to continue!\n", menuFile ) );

  if( reset )
    Menu_Reset();

  while( 1 )
  {
    if( !trap_Parse_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 file '%s' loaded in %d msec\n", menuFile, trap_Milliseconds() - start );

  trap_Parse_FreeSource( handle );
}

void UI_LoadHelp( const char *helpFile )
{
  pc_token_t token;
  int handle, start;
  char title[ 32 ], buffer[ 1024 ];

  start = trap_Milliseconds();
  
  handle = trap_Parse_LoadSource( helpFile );
  if( !handle )
  {
    Com_Printf( S_COLOR_YELLOW "WARNING: help file '%s' not found!\n",
                helpFile );
    return;
  }

  if( !trap_Parse_ReadToken( handle, &token ) ||
      token.string[0] == 0 || token.string[0] != '{' )
  {
    Com_Printf( S_COLOR_YELLOW "WARNING: help file '%s' does not start with "
                "'{'\n", helpFile );
    return;
  }

  uiInfo.helpCount = 0;
  title[ 0 ] = 0;
  while( 1 )
  {
    if( !trap_Parse_ReadToken( handle, &token ) ||
        token.string[0] == 0 || token.string[0] == '}' )
      break;
      
    if( token.string[0] == '{' )
    {
      buffer[ 0 ] = 0;
      Q_strcat( buffer, sizeof( buffer ), title );
      Q_strcat( buffer, sizeof( buffer ), "\n\n" );
      while( trap_Parse_ReadToken( handle, &token ) &&
             token.string[0] != 0 && token.string[0] != '}' )
      {
        Q_strcat( buffer, sizeof( buffer ), token.string );
      }

      uiInfo.helpList[ uiInfo.helpCount ].text = String_Alloc( title );
      uiInfo.helpList[ uiInfo.helpCount ].v.text = String_Alloc( buffer );
      uiInfo.helpList[ uiInfo.helpCount ].type = INFOTYPE_TEXT;
      uiInfo.helpCount++;
      title[ 0 ] = 0;
    }
    else
      Q_strcat( title, sizeof( title ), token.string );
  }

  trap_Parse_FreeSource( handle );

  Com_Printf( "UI help file '%s' loaded in %d msec (%d infopanes)\n",
              helpFile, trap_Milliseconds() - start, uiInfo.helpCount );                   
}

void UI_Load( void )
{
  char lastName[1024];
  menuDef_t *menu = Menu_GetFocused();

  if( menu && menu->window.name )
    strcpy( lastName, menu->window.name );

  String_Init();

  UI_LoadMenus( "ui/menus.txt", qtrue );
  UI_LoadMenus( "ui/ingame.txt", qfalse );
  UI_LoadMenus( "ui/tremulous.txt", qfalse );
  UI_LoadHelp( "ui/help.txt" );
  Menus_CloseAll( );
  Menus_ActivateByName( lastName );

}

/*
===============
UI_GetCurrentAlienStage
===============
*/
static stage_t UI_GetCurrentAlienStage( void )
{
  char    buffer[ MAX_TOKEN_CHARS ];
  stage_t stage, dummy;

  trap_Cvar_VariableStringBuffer( "ui_stages", buffer, sizeof( buffer ) );
  sscanf( buffer, "%d %d", ( int * ) & stage , ( int * ) & dummy );

  return stage;
}

/*
===============
UI_GetCurrentHumanStage
===============
*/
static stage_t UI_GetCurrentHumanStage( void )
{
  char    buffer[ MAX_TOKEN_CHARS ];
  stage_t stage, dummy;

  trap_Cvar_VariableStringBuffer( "ui_stages", buffer, sizeof( buffer ) );
  sscanf( buffer, "%d %d", ( int * ) & dummy, ( int * ) & stage );

  return stage;
}

/*
===============
UI_DrawInfoPane
===============
*/
static void UI_DrawInfoPane( menuItem_t *item, rectDef_t *rect, float text_x, float text_y,
                             float scale, int textalign, int textvalign, vec4_t color, int textStyle )
{
  int         value = 0;
  const char  *s = "";
  char        *string = "";

  int         class, credits;
  char        ui_currentClass[ MAX_STRING_CHARS ];

  trap_Cvar_VariableStringBuffer( "ui_currentClass", ui_currentClass, MAX_STRING_CHARS );

  sscanf( ui_currentClass, "%d %d", &class, &credits );

  switch( item->type )
  {
    case INFOTYPE_TEXT:
      s = item->v.text;
      break;

    case INFOTYPE_CLASS:
      value = ( BG_ClassCanEvolveFromTo( class, item->v.pclass, credits,
                                         UI_GetCurrentAlienStage(), 0 ) +
                ALIEN_CREDITS_PER_KILL - 1 ) / ALIEN_CREDITS_PER_KILL;

      if( value < 1 )
      {
        s = va( "%s\n\n%s",
                BG_ClassConfig( item->v.pclass )->humanName,
                BG_Class( item->v.pclass )->info );
      }
      else
      {
        s = va( "%s\n\n%s\n\nFrags: %d",
                BG_ClassConfig( item->v.pclass )->humanName,
                BG_Class( item->v.pclass )->info,
                value );
      }

      break;

    case INFOTYPE_WEAPON:
      value = BG_Weapon( item->v.weapon )->price;

      if( value == 0 )
      {
        s = va( "%s\n\n%s\n\nCredits: Free",
                BG_Weapon( item->v.weapon )->humanName,
                BG_Weapon( item->v.weapon )->info );
      }
      else
      {
        s = va( "%s\n\n%s\n\nCredits: %d",
                BG_Weapon( item->v.weapon )->humanName,
                BG_Weapon( item->v.weapon )->info,
                value );
      }

      break;

    case INFOTYPE_UPGRADE:
      value = BG_Upgrade( item->v.upgrade )->price;

      if( value == 0 )
      {
        s = va( "%s\n\n%s\n\nCredits: Free",
                BG_Upgrade( item->v.upgrade )->humanName,
                BG_Upgrade( item->v.upgrade )->info );
      }
      else
      {
        s = va( "%s\n\n%s\n\nCredits: %d",
                BG_Upgrade( item->v.upgrade )->humanName,
                BG_Upgrade( item->v.upgrade )->info,
                value );
      }

      break;

    case INFOTYPE_BUILDABLE:
      value = BG_Buildable( item->v.buildable )->buildPoints;

      switch( BG_Buildable( item->v.buildable )->team )
      {
        case TEAM_ALIENS:
          string = "Sentience";
          break;

        case TEAM_HUMANS:
          string = "Power";
          break;

        default:
          break;
      }

      if( value == 0 )
      {
        s = va( "%s\n\n%s",
                BG_Buildable( item->v.buildable )->humanName,
                BG_Buildable( item->v.buildable )->info );
      }
      else
      {
        s = va( "%s\n\n%s\n\n%s: %d",
                BG_Buildable( item->v.buildable )->humanName,
                BG_Buildable( item->v.buildable )->info,
                string, value );
      }

      break;
  }

  UI_DrawTextBlock( rect, text_x, text_y, color, scale,
                    textalign, textvalign, textStyle, s );
}


static void UI_DrawServerMapPreview( rectDef_t *rect, float scale, vec4_t color )
{
  if( uiInfo.serverStatus.currentServerCinematic >= 0 )
  {
    trap_CIN_RunCinematic( uiInfo.serverStatus.currentServerCinematic );
    trap_CIN_SetExtents( uiInfo.serverStatus.currentServerCinematic, rect->x, rect->y, rect->w, rect->h );
    trap_CIN_DrawCinematic( uiInfo.serverStatus.currentServerCinematic );
  }
  else if( uiInfo.serverStatus.currentServerPreview > 0 )
    UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.serverStatus.currentServerPreview );
  else
    UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, trap_R_RegisterShaderNoMip( "gfx/2d/load_screen" ) );
}

static void UI_DrawSelectedMapPreview( rectDef_t *rect, float scale, vec4_t color )
{
  int map = ui_selectedMap.integer;

  if( map < 0 || map > uiInfo.mapCount )
  {
    ui_selectedMap.integer = 0;
    trap_Cvar_Set( "ui_selectedMap", "0" );
    map = 0;
  }

  if( uiInfo.mapList[map].cinematic >= -1 )
  {
    if( uiInfo.mapList[map].cinematic == -1 )
      uiInfo.mapList[map].cinematic = trap_CIN_PlayCinematic( va( "%s.roq", uiInfo.mapList[map].mapLoadName ),
                                                              0, 0, 0, 0, ( CIN_loop | CIN_silent ) );

    if( uiInfo.mapList[map].cinematic >= 0 )
    {
      trap_CIN_RunCinematic( uiInfo.mapList[map].cinematic );
      trap_CIN_SetExtents( uiInfo.mapList[map].cinematic, rect->x, rect->y, rect->w, rect->h );
      trap_CIN_DrawCinematic( uiInfo.mapList[map].cinematic );
    }
    else
      uiInfo.mapList[map].cinematic = -2;
  }
  else
  {
    if( uiInfo.mapList[map].levelShot == -1 )
      uiInfo.mapList[map].levelShot = trap_R_RegisterShaderNoMip( uiInfo.mapList[map].imageName );

    if( uiInfo.mapList[map].levelShot > 0 )
      UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.mapList[map].levelShot );
    else
      UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, trap_R_RegisterShaderNoMip( "gfx/2d/load_screen" ) );
  }
}

static void UI_DrawSelectedMapName( rectDef_t *rect, float scale, vec4_t color, int textStyle )
{
  int map = ui_selectedMap.integer;

  if( map >= 0 && map < uiInfo.mapCount )
    UI_Text_Paint( rect->x, rect->y, scale, color, uiInfo.mapList[map].mapName, 0, 0, textStyle );
}

static const char *UI_OwnerDrawText( int ownerDraw )
{
  const char *s = NULL;

  switch( ownerDraw )
  {
    case UI_NETSOURCE:
      if( ui_netSource.integer < 0 || ui_netSource.integer >= numNetSources )
        ui_netSource.integer = 0;

      s = netSources[ui_netSource.integer];
      break;

    case UI_KEYBINDSTATUS:
      if( Display_KeyBindPending() )
        s = "Waiting for new key... Press ESCAPE to cancel";
      else
        s = "Press ENTER or CLICK to change, Press BACKSPACE to clear";

      break;

    case UI_SERVERREFRESHDATE:
      if( uiInfo.serverStatus.refreshActive )
      {
#define MAX_DOTS 5
        int numServers = trap_LAN_GetServerCount( ui_netSource.integer );
        int numDots = ( uiInfo.uiDC.realTime / 500 ) % ( MAX_DOTS + 1 );
        char dots[ MAX_DOTS + 1 ];
        int i;

        for( i = 0; i < numDots; i++ )
          dots[ i ] = '.';

        dots[ i ] = '\0';

        s = numServers < 0 ? va( "Waiting for response%s", dots ) :
            va( "Getting info for %d servers (ESC to cancel)%s", numServers, dots );
      }
      else
        s = va( "Refresh Time: %s", UI_Cvar_VariableString( va( "ui_lastServerRefresh_%i", ui_netSource.integer ) ) );

      break;

    case UI_SERVERMOTD:
      s = uiInfo.serverStatus.motd;
      break;

    default:
      break;
  }

  return s;
}

static int UI_OwnerDrawWidth( int ownerDraw, float scale )
{
  const char *s = NULL;

  switch( ownerDraw )
  {
    case UI_NETSOURCE:
    case UI_KEYBINDSTATUS:
    case UI_SERVERREFRESHDATE:
    case UI_SERVERMOTD:
      s = UI_OwnerDrawText( ownerDraw );
      break;

    default:
      break;
  }

  if( s )
    return UI_Text_Width( s, scale );

  return 0;
}

/*
===============
UI_BuildPlayerList
===============
*/
static void UI_BuildPlayerList( void )
{
  uiClientState_t cs;
  int   n, count, team, team2;
  char  info[MAX_INFO_STRING];

  trap_GetClientState( &cs );
  trap_GetConfigString( CS_PLAYERS + cs.clientNum, info, MAX_INFO_STRING );
  uiInfo.playerNumber = cs.clientNum;
  team = atoi( Info_ValueForKey( info, "t" ) );
  trap_GetConfigString( CS_SERVERINFO, info, sizeof( info ) );
  count = atoi( Info_ValueForKey( info, "sv_maxclients" ) );
  uiInfo.playerCount = 0;
  uiInfo.myTeamCount = 0;
  uiInfo.myPlayerIndex = 0;

  for( n = 0; n < count; n++ )
  {
    trap_GetConfigString( CS_PLAYERS + n, info, MAX_INFO_STRING );

    if( info[0] )
    {
      Com_ClientListParse( &uiInfo.ignoreList[ uiInfo.playerCount ],
                          Info_ValueForKey( info, "ig" ) );
      Q_strncpyz( uiInfo.rawPlayerNames[uiInfo.playerCount],
                  Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
      Q_strncpyz( uiInfo.playerNames[uiInfo.playerCount],
                  Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
      Q_CleanStr( uiInfo.playerNames[uiInfo.playerCount] );
      uiInfo.clientNums[uiInfo.playerCount] = n;

      if( n == uiInfo.playerNumber )
        uiInfo.myPlayerIndex = uiInfo.playerCount;

      uiInfo.playerCount++;

      team2 = atoi( Info_ValueForKey( info, "t" ) );

      if( team2 == team )
      {
        Q_strncpyz( uiInfo.rawTeamNames[uiInfo.myTeamCount],
                    Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
        Q_strncpyz( uiInfo.teamNames[uiInfo.myTeamCount],
                    Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
        Q_CleanStr( uiInfo.teamNames[uiInfo.myTeamCount] );
        uiInfo.teamClientNums[uiInfo.myTeamCount] = n;

        uiInfo.myTeamCount++;
      }
    }
  }
}

static void UI_DrawGLInfo( rectDef_t *rect, float scale, int textalign, int textvalign,
                           vec4_t color, int textStyle, float text_x, float text_y )
{
  char      buffer[ 4096 ];

  Com_sprintf( buffer, sizeof( buffer ), "VENDOR: %s\nVERSION: %s\n"
               "PIXELFORMAT: color(%d-bits) Z(%d-bits) stencil(%d-bits)\n%s",
               uiInfo.uiDC.glconfig.vendor_string, uiInfo.uiDC.glconfig.renderer_string,
               uiInfo.uiDC.glconfig.colorBits, uiInfo.uiDC.glconfig.depthBits,
               uiInfo.uiDC.glconfig.stencilBits, uiInfo.uiDC.glconfig.extensions_string );

  UI_DrawTextBlock( rect, text_x, text_y, color, scale,
                    textalign, textvalign, textStyle, buffer );
}

// FIXME: table drive
//
static void UI_OwnerDraw( float x, float y, float w, float h,
                          float text_x, float text_y, int ownerDraw,
                          int ownerDrawFlags, int align,
                          int textalign, int textvalign, float borderSize,
                          float scale, vec4_t foreColor, vec4_t backColor,
                          qhandle_t shader,
                          int textStyle )
{
  rectDef_t       rect;

  rect.x = x;
  rect.y = y;
  rect.w = w;
  rect.h = h;

  switch( ownerDraw )
  {
    case UI_TEAMINFOPANE:
      UI_DrawInfoPane( &uiInfo.teamList[ uiInfo.teamIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_ACLASSINFOPANE:
      UI_DrawInfoPane( &uiInfo.alienClassList[ uiInfo.alienClassIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_AUPGRADEINFOPANE:
      UI_DrawInfoPane( &uiInfo.alienUpgradeList[ uiInfo.alienUpgradeIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_HITEMINFOPANE:
      UI_DrawInfoPane( &uiInfo.humanItemList[ uiInfo.humanItemIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_HBUYINFOPANE:
      UI_DrawInfoPane( &uiInfo.humanArmouryBuyList[ uiInfo.humanArmouryBuyIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_HSELLINFOPANE:
      UI_DrawInfoPane( &uiInfo.humanArmourySellList[ uiInfo.humanArmourySellIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_ABUILDINFOPANE:
      UI_DrawInfoPane( &uiInfo.alienBuildList[ uiInfo.alienBuildIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_HBUILDINFOPANE:
      UI_DrawInfoPane( &uiInfo.humanBuildList[ uiInfo.humanBuildIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_HELPINFOPANE:
      UI_DrawInfoPane( &uiInfo.helpList[ uiInfo.helpIndex ],
                       &rect, text_x, text_y, scale, textalign, textvalign, foreColor, textStyle );
      break;

    case UI_NETMAPPREVIEW:
      UI_DrawServerMapPreview( &rect, scale, foreColor );
      break;

    case UI_SELECTEDMAPPREVIEW:
      UI_DrawSelectedMapPreview( &rect, scale, foreColor );
      break;

    case UI_SELECTEDMAPNAME:
      UI_DrawSelectedMapName( &rect, scale, foreColor, textStyle );
      break;

    case UI_GLINFO:
      UI_DrawGLInfo( &rect, scale, textalign, textvalign, foreColor, textStyle, text_x, text_y );
      break;

    default:
      break;
  }

}

static qboolean UI_OwnerDrawVisible( int flags )
{
  qboolean vis = qtrue;
  uiClientState_t cs;
  team_t          team;
  char            info[ MAX_INFO_STRING ];

  trap_GetClientState( &cs );
  trap_GetConfigString( CS_PLAYERS + cs.clientNum, info, MAX_INFO_STRING );
  team = atoi( Info_ValueForKey( info, "t" ) );


  while( flags )
  {
    if( flags & UI_SHOW_NOTSPECTATING )
    {
      if( team == TEAM_NONE )
        vis = qfalse;

      flags &= ~UI_SHOW_NOTSPECTATING;
    }

    if( flags & UI_SHOW_VOTEACTIVE )
    {
      if( !trap_Cvar_VariableValue( "ui_voteActive" ) )
        vis = qfalse;

      flags &= ~UI_SHOW_VOTEACTIVE;
    }

    if( flags & UI_SHOW_CANVOTE )
    {
      if( trap_Cvar_VariableValue( "ui_voteActive" ) )
        vis = qfalse;

      flags &= ~UI_SHOW_CANVOTE;
    }

    if( flags & UI_SHOW_TEAMVOTEACTIVE )
    {
      if( team == TEAM_ALIENS )
      {
        if( !trap_Cvar_VariableValue( "ui_alienTeamVoteActive" ) )
          vis = qfalse;
      }
      else if( team == TEAM_HUMANS )
      {
        if( !trap_Cvar_VariableValue( "ui_humanTeamVoteActive" ) )
          vis = qfalse;
      }

      flags &= ~UI_SHOW_TEAMVOTEACTIVE;
    }

    if( flags & UI_SHOW_CANTEAMVOTE )
    {
      if( team == TEAM_ALIENS )
      {
        if( trap_Cvar_VariableValue( "ui_alienTeamVoteActive" ) )
          vis = qfalse;
      }
      else if( team == TEAM_HUMANS )
      {
        if( trap_Cvar_VariableValue( "ui_humanTeamVoteActive" ) )
          vis = qfalse;
      }

      flags &= ~UI_SHOW_CANTEAMVOTE;
    }

    if( flags & UI_SHOW_FAVORITESERVERS )
    {
      // this assumes you only put this type of display flag on something showing in the proper context

      if( ui_netSource.integer != AS_FAVORITES )
        vis = qfalse;

      flags &= ~UI_SHOW_FAVORITESERVERS;
    }

    if( flags & UI_SHOW_NOTFAVORITESERVERS )
    {
      // this assumes you only put this type of display flag on something showing in the proper context

      if( ui_netSource.integer == AS_FAVORITES )
        vis = qfalse;

      flags &= ~UI_SHOW_NOTFAVORITESERVERS;
    }
    else
      flags = 0;
  }

  return vis;
}

static qboolean UI_NetSource_HandleKey( int key )
{
  if( key == K_MOUSE1 || key == K_MOUSE2 || key == K_ENTER || key == K_KP_ENTER )
  {
    if( key == K_MOUSE2 )
    {
      ui_netSource.integer--;

      if( ui_netSource.integer == AS_MPLAYER )
        ui_netSource.integer--;
    }
    else
    {
      ui_netSource.integer++;

      if( ui_netSource.integer == AS_MPLAYER )
        ui_netSource.integer++;
    }

    if( ui_netSource.integer >= numNetSources )
      ui_netSource.integer = 0;
    else if( ui_netSource.integer < 0 )
      ui_netSource.integer = numNetSources - 1;

    UI_BuildServerDisplayList( qtrue );

    if( ui_netSource.integer != AS_GLOBAL )
      UI_StartServerRefresh( qtrue );

    trap_Cvar_Set( "ui_netSource", va( "%d", ui_netSource.integer ) );
    return qtrue;
  }

  return qfalse;
}

static qboolean UI_OwnerDrawHandleKey( int ownerDraw, int key )
{
  switch( ownerDraw )
  {
    case UI_NETSOURCE:
      UI_NetSource_HandleKey( key );
      break;

    default:
      break;
  }

  return qfalse;
}


/*
=================
UI_ServersQsortCompare
=================
*/
static int QDECL UI_ServersQsortCompare( const void *arg1, const void *arg2 )
{
  return trap_LAN_CompareServers( ui_netSource.integer, uiInfo.serverStatus.sortKey,
                                  uiInfo.serverStatus.sortDir, *( int* )arg1, *( int* )arg2 );
}


/*
=================
UI_ServersSort
=================
*/
void UI_ServersSort( int column, qboolean force )
{
  if( !force )
  {
    if( uiInfo.serverStatus.sortKey == column )
      return;
  }

  uiInfo.serverStatus.sortKey = column;
  qsort( &uiInfo.serverStatus.displayServers[0], uiInfo.serverStatus.numDisplayServers,
          sizeof( int ), UI_ServersQsortCompare );
}

/*
===============
UI_LoadTeams
===============
*/
static void UI_LoadTeams( void )
{
  uiInfo.teamCount = 4;

  uiInfo.teamList[ 0 ].text = "Aliens";
  uiInfo.teamList[ 0 ].cmd = "cmd team aliens\n";
  uiInfo.teamList[ 0 ].type = INFOTYPE_TEXT;
  uiInfo.teamList[ 0 ].v.text =
    "The Alien Team\n\n"
    "The Aliens' strengths are in movement and the ability to "
    "quickly construct new bases quickly. They possess a range "
    "of abilities including basic melee attacks, movement-"
    "crippling poisons and more.";

  uiInfo.teamList[ 1 ].text = "Humans";
  uiInfo.teamList[ 1 ].cmd = "cmd team humans\n";
  uiInfo.teamList[ 1 ].type = INFOTYPE_TEXT;
  uiInfo.teamList[ 1 ].v.text =
    "The Human Team\n\n"
    "The humans are the masters of technology. Although their "
    "bases take long to construct, their automated defense "
    "ensures they stay built. A wide range of upgrades and "
    "weapons are available to the humans, each contributing "
    "to eradicate the alien threat.";

  uiInfo.teamList[ 2 ].text = "Spectate";
  uiInfo.teamList[ 2 ].cmd = "cmd team spectate\n";
  uiInfo.teamList[ 2 ].type = INFOTYPE_TEXT;
  uiInfo.teamList[ 2 ].v.text = "Watch the game without playing.";

  uiInfo.teamList[ 3 ].text = "Auto select";
  uiInfo.teamList[ 3 ].cmd = "cmd team auto\n";
  uiInfo.teamList[ 3 ].type = INFOTYPE_TEXT;
  uiInfo.teamList[ 3 ].v.text = "Join the team with the least players.";
}

/*
===============
UI_AddClass
===============
*/

static void UI_AddClass( class_t class )
{
  uiInfo.alienClassList[ uiInfo.alienClassCount ].text =
    BG_ClassConfig( class )->humanName;
  uiInfo.alienClassList[ uiInfo.alienClassCount ].cmd =
    String_Alloc( va( "cmd class %s\n", BG_Class( class )->name ) );
  uiInfo.alienClassList[ uiInfo.alienClassCount ].type = INFOTYPE_CLASS;

  uiInfo.alienClassList[ uiInfo.alienClassCount ].v.pclass = class;

  uiInfo.alienClassCount++;
}

/*
===============
UI_LoadAlienClasses
===============
*/
static void UI_LoadAlienClasses( void )
{
  uiInfo.alienClassCount = 0;

  if( BG_ClassIsAllowed( PCL_ALIEN_LEVEL0 ) )
    UI_AddClass( PCL_ALIEN_LEVEL0 );

  if( BG_ClassIsAllowed( PCL_ALIEN_BUILDER0_UPG ) &&
      BG_ClassAllowedInStage( PCL_ALIEN_BUILDER0_UPG, UI_GetCurrentAlienStage( ) ) )
    UI_AddClass( PCL_ALIEN_BUILDER0_UPG );
  else if( BG_ClassIsAllowed( PCL_ALIEN_BUILDER0 ) )
    UI_AddClass( PCL_ALIEN_BUILDER0 );
}

/*
===============
UI_AddItem
===============
*/
static void UI_AddItem( weapon_t weapon )
{
  uiInfo.humanItemList[ uiInfo.humanItemCount ].text =
    BG_Weapon( weapon )->humanName;
  uiInfo.humanItemList[ uiInfo.humanItemCount ].cmd =
    String_Alloc( va( "cmd class %s\n", BG_Weapon( weapon )->name ) );
  uiInfo.humanItemList[ uiInfo.humanItemCount ].type = INFOTYPE_WEAPON;
  uiInfo.humanItemList[ uiInfo.humanItemCount ].v.weapon = weapon;

  uiInfo.humanItemCount++;
}

/*
===============
UI_LoadHumanItems
===============
*/
static void UI_LoadHumanItems( void )
{
  uiInfo.humanItemCount = 0;

  if( BG_WeaponIsAllowed( WP_MACHINEGUN ) )
    UI_AddItem( WP_MACHINEGUN );

  if( BG_WeaponIsAllowed( WP_HBUILD ) )
    UI_AddItem( WP_HBUILD );
}

/*
===============
UI_ParseCarriageList
===============
*/
static void UI_ParseCarriageList( void )
{
  int  i;
  char carriageCvar[ MAX_TOKEN_CHARS ];
  char *iterator;
  char buffer[ MAX_TOKEN_CHARS ];
  char *bufPointer;

  trap_Cvar_VariableStringBuffer( "ui_carriage", carriageCvar, sizeof( carriageCvar ) );
  iterator = carriageCvar;

  uiInfo.weapons = 0;
  uiInfo.upgrades = 0;

  //simple parser to give rise to weapon/upgrade list

  while( iterator && iterator[ 0 ] != '$' )
  {
    bufPointer = buffer;

    if( iterator[ 0 ] == 'W' )
    {
      iterator++;

      while( iterator[ 0 ] != ' ' )
        *bufPointer++ = *iterator++;

      *bufPointer++ = '\n';

      i = atoi( buffer );

      uiInfo.weapons |= ( 1 << i );
    }
    else if( iterator[ 0 ] == 'U' )
    {
      iterator++;

      while( iterator[ 0 ] != ' ' )
        *bufPointer++ = *iterator++;

      *bufPointer++ = '\n';

      i = atoi( buffer );

      uiInfo.upgrades |= ( 1 << i );
    }

    iterator++;
  }
}

/*
===============
UI_LoadHumanArmouryBuys
===============
*/
static void UI_LoadHumanArmouryBuys( void )
{
  int i, j = 0;
  stage_t stage = UI_GetCurrentHumanStage( );
  int slots = 0;

  UI_ParseCarriageList( );

  for( i = WP_NONE + 1; i < WP_NUM_WEAPONS; i++ )
  {
    if( uiInfo.weapons & ( 1 << i ) )
      slots |= BG_Weapon( i )->slots;
  }

  for( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
  {
    if( uiInfo.upgrades & ( 1 << i ) )
      slots |= BG_Upgrade( i )->slots;
  }

  uiInfo.humanArmouryBuyCount = 0;

  for( i = WP_NONE + 1; i < WP_NUM_WEAPONS; i++ )
  {
    if( BG_Weapon( i )->team == TEAM_HUMANS &&
        BG_Weapon( i )->purchasable &&
        BG_WeaponAllowedInStage( i, stage ) &&
        BG_WeaponIsAllowed( i ) &&
        !( BG_Weapon( i )->slots & slots ) &&
        !( uiInfo.weapons & ( 1 << i ) ) )
    {
      uiInfo.humanArmouryBuyList[ j ].text = BG_Weapon( i )->humanName;
      uiInfo.humanArmouryBuyList[ j ].cmd =
        String_Alloc( va( "cmd buy %s\n", BG_Weapon( i )->name ) );
      uiInfo.humanArmouryBuyList[ j ].type = INFOTYPE_WEAPON;
      uiInfo.humanArmouryBuyList[ j ].v.weapon = i;

      j++;

      uiInfo.humanArmouryBuyCount++;
    }
  }

  for( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
  {
    if( BG_Upgrade( i )->team == TEAM_HUMANS &&
        BG_Upgrade( i )->purchasable &&
        BG_UpgradeAllowedInStage( i, stage ) &&
        BG_UpgradeIsAllowed( i ) &&
        !( BG_Upgrade( i )->slots & slots ) &&
        !( uiInfo.upgrades & ( 1 << i ) ) )
    {
      uiInfo.humanArmouryBuyList[ j ].text = BG_Upgrade( i )->humanName;
      uiInfo.humanArmouryBuyList[ j ].cmd =
        String_Alloc( va( "cmd buy %s\n", BG_Upgrade( i )->name ) );
      uiInfo.humanArmouryBuyList[ j ].type = INFOTYPE_UPGRADE;
      uiInfo.humanArmouryBuyList[ j ].v.upgrade = i;

      j++;

      uiInfo.humanArmouryBuyCount++;
    }
  }
}

/*
===============
UI_LoadHumanArmourySells
===============
*/
static void UI_LoadHumanArmourySells( void )
{
  int i, j = 0;

  uiInfo.humanArmourySellCount = 0;
  UI_ParseCarriageList( );

  for( i = WP_NONE + 1; i < WP_NUM_WEAPONS; i++ )
  {
    if( uiInfo.weapons & ( 1 << i ) )
    {
      uiInfo.humanArmourySellList[ j ].text = BG_Weapon( i )->humanName;
      uiInfo.humanArmourySellList[ j ].cmd =
        String_Alloc( va( "cmd sell %s\n", BG_Weapon( i )->name ) );
      uiInfo.humanArmourySellList[ j ].type = INFOTYPE_WEAPON;
      uiInfo.humanArmourySellList[ j ].v.weapon = i;

      j++;

      uiInfo.humanArmourySellCount++;
    }
  }

  for( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
  {
    if( uiInfo.upgrades & ( 1 << i ) )
    {
      uiInfo.humanArmourySellList[ j ].text = BG_Upgrade( i )->humanName;
      uiInfo.humanArmourySellList[ j ].cmd =
        String_Alloc( va( "cmd sell %s\n", BG_Upgrade( i )->name ) );
      uiInfo.humanArmourySellList[ j ].type = INFOTYPE_UPGRADE;
      uiInfo.humanArmourySellList[ j ].v.upgrade = i;

      j++;

      uiInfo.humanArmourySellCount++;
    }
  }
}

/*
===============
UI_ArmouryRefreshCb
===============
*/
static void UI_ArmouryRefreshCb( void *data )
{
  int oldWeapons  = uiInfo.weapons;
  int oldUpgrades = uiInfo.upgrades;

  UI_ParseCarriageList( );

  if( uiInfo.weapons != oldWeapons || uiInfo.upgrades != oldUpgrades )
  {
    UI_LoadHumanArmouryBuys( );
    UI_LoadHumanArmourySells( );
    UI_RemoveCaptureFunc( );
  }
}

/*
===============
UI_LoadAlienUpgrades
===============
*/
static void UI_LoadAlienUpgrades( void )
{
  int     i, j = 0;

  int     class, credits;
  char    ui_currentClass[ MAX_STRING_CHARS ];
  stage_t stage = UI_GetCurrentAlienStage( );

  trap_Cvar_VariableStringBuffer( "ui_currentClass", ui_currentClass, MAX_STRING_CHARS );

  sscanf( ui_currentClass, "%d %d", &class, &credits );

  uiInfo.alienUpgradeCount = 0;

  for( i = PCL_NONE + 1; i < PCL_NUM_CLASSES; i++ )
  {
    if( BG_ClassCanEvolveFromTo( class, i, credits, stage, 0 ) >= 0 )
    {
      uiInfo.alienUpgradeList[ j ].text = BG_ClassConfig( i )->humanName;
      uiInfo.alienUpgradeList[ j ].cmd =
        String_Alloc( va( "cmd class %s\n", BG_Class( i )->name ) );
      uiInfo.alienUpgradeList[ j ].type = INFOTYPE_CLASS;
      uiInfo.alienUpgradeList[ j ].v.pclass = i;

      j++;

      uiInfo.alienUpgradeCount++;
    }
  }
}

/*
===============
UI_LoadAlienBuilds
===============
*/
static void UI_LoadAlienBuilds( void )
{
  int     i, j = 0;
  stage_t stage;

  UI_ParseCarriageList( );
  stage = UI_GetCurrentAlienStage( );

  uiInfo.alienBuildCount = 0;

  for( i = BA_NONE + 1; i < BA_NUM_BUILDABLES; i++ )
  {
    if( BG_Buildable( i )->team == TEAM_ALIENS &&
        BG_Buildable( i )->buildWeapon & uiInfo.weapons &&
        BG_BuildableAllowedInStage( i, stage ) &&
        BG_BuildableIsAllowed( i ) )
    {
      uiInfo.alienBuildList[ j ].text = BG_Buildable( i )->humanName;
      uiInfo.alienBuildList[ j ].cmd =
        String_Alloc( va( "cmd build %s\n", BG_Buildable( i )->name ) );
      uiInfo.alienBuildList[ j ].type = INFOTYPE_BUILDABLE;
      uiInfo.alienBuildList[ j ].v.buildable = i;

      j++;

      uiInfo.alienBuildCount++;
    }
  }
}

/*
===============
UI_LoadHumanBuilds
===============
*/
static void UI_LoadHumanBuilds( void )
{
  int     i, j = 0;
  stage_t stage;

  UI_ParseCarriageList( );
  stage = UI_GetCurrentHumanStage( );

  uiInfo.humanBuildCount = 0;

  for( i = BA_NONE + 1; i < BA_NUM_BUILDABLES; i++ )
  {
    if( BG_Buildable( i )->team == TEAM_HUMANS &&
        BG_Buildable( i )->buildWeapon & uiInfo.weapons &&
        BG_BuildableAllowedInStage( i, stage ) &&
        BG_BuildableIsAllowed( i ) )
    {
      uiInfo.humanBuildList[ j ].text = BG_Buildable( i )->humanName;
      uiInfo.humanBuildList[ j ].cmd =
        String_Alloc( va( "cmd build %s\n", BG_Buildable( i )->name ) );
      uiInfo.humanBuildList[ j ].type = INFOTYPE_BUILDABLE;
      uiInfo.humanBuildList[ j ].v.buildable = i;

      j++;

      uiInfo.humanBuildCount++;
    }
  }
}

/*
===============
UI_LoadMods
===============
*/
static void UI_LoadMods( void )
{
  int   numdirs;
  char  dirlist[2048];
  char  *dirptr;
  char  *descptr;
  int   i;
  int   dirlen;

  uiInfo.modCount = 0;
  numdirs = trap_FS_GetFileList( "$modlist", "", dirlist, sizeof( dirlist ) );
  dirptr  = dirlist;

  for( i = 0; i < numdirs; i++ )
  {
    dirlen = strlen( dirptr ) + 1;
    descptr = dirptr + dirlen;
    uiInfo.modList[uiInfo.modCount].modName = String_Alloc( dirptr );
    uiInfo.modList[uiInfo.modCount].modDescr = String_Alloc( descptr );
    dirptr += dirlen + strlen( descptr ) + 1;
    uiInfo.modCount++;

    if( uiInfo.modCount >= MAX_MODS )
      break;
  }

}


/*
===============
UI_LoadMovies
===============
*/
static void UI_LoadMovies( void )
{
  char  movielist[4096];
  char  *moviename;
  int   i, len;

  uiInfo.movieCount = trap_FS_GetFileList( "video", "roq", movielist, 4096 );

  if( uiInfo.movieCount )
  {
    if( uiInfo.movieCount > MAX_MOVIES )
      uiInfo.movieCount = MAX_MOVIES;

    moviename = movielist;

    for( i = 0; i < uiInfo.movieCount; i++ )
    {
      len = strlen( moviename );

      if( !Q_stricmp( moviename +  len - 4, ".roq" ) )
        moviename[len-4] = '\0';

      Q_strupr( moviename );
      uiInfo.movieList[i] = String_Alloc( moviename );
      moviename += len + 1;
    }
  }

}



/*
===============
UI_LoadDemos
===============
*/
static void UI_LoadDemos( void )
{
  char  demolist[4096];
  char demoExt[32];
  char  *demoname;
  int   i, len;

  Com_sprintf( demoExt, sizeof( demoExt ), "%s%d", DEMOEXT, (int)trap_Cvar_VariableValue( "protocol" ) );

  uiInfo.demoCount = trap_FS_GetFileList( "demos", demoExt, demolist, 4096 );

  Com_sprintf( demoExt, sizeof( demoExt ), ".%s%d", DEMOEXT, (int)trap_Cvar_VariableValue( "protocol" ) );

  if( uiInfo.demoCount )
  {
    if( uiInfo.demoCount > MAX_DEMOS )
      uiInfo.demoCount = MAX_DEMOS;

    demoname = demolist;

    for( i = 0; i < uiInfo.demoCount; i++ )
    {
      len = strlen( demoname );

      if( !Q_stricmp( demoname +  len - strlen( demoExt ), demoExt ) )
        demoname[len-strlen( demoExt )] = '\0';

      uiInfo.demoList[i] = String_Alloc( demoname );
      demoname += len + 1;
    }
  }

}

static void UI_Update( const char *name )
{
  int val = trap_Cvar_VariableValue( name );

  if( Q_stricmp( name, "ui_SetName" ) == 0 )
    trap_Cvar_Set( "name", UI_Cvar_VariableString( "ui_Name" ) );
  else if( Q_stricmp( name, "ui_setRate" ) == 0 )
  {
    float rate = trap_Cvar_VariableValue( "rate" );

    if( rate >= 5000 )
    {
      trap_Cvar_Set( "cl_maxpackets", "30" );
      trap_Cvar_Set( "cl_packetdup", "1" );
    }
    else if( rate >= 4000 )
    {
      trap_Cvar_Set( "cl_maxpackets", "15" );
      trap_Cvar_Set( "cl_packetdup", "2" );   // favor less prediction errors when there's packet loss
    }
    else
    {
      trap_Cvar_Set( "cl_maxpackets", "15" );
      trap_Cvar_Set( "cl_packetdup", "1" );   // favor lower bandwidth
    }
  }
  else if( Q_stricmp( name, "ui_GetName" ) == 0 )
    trap_Cvar_Set( "ui_Name", UI_Cvar_VariableString( "name" ) );
  else if( Q_stricmp( name, "r_colorbits" ) == 0 )
  {
    switch( val )
    {
      case 0:
        trap_Cvar_SetValue( "r_depthbits", 0 );
        trap_Cvar_SetValue( "r_stencilbits", 0 );
        break;

      case 16:
        trap_Cvar_SetValue( "r_depthbits", 16 );
        trap_Cvar_SetValue( "r_stencilbits", 0 );
        break;

      case 32:
        trap_Cvar_SetValue( "r_depthbits", 24 );
        break;
    }
  }
  else if( Q_stricmp( name, "r_lodbias" ) == 0 )
  {
    switch( val )
    {
      case 0:
        trap_Cvar_SetValue( "r_subdivisions", 4 );
        break;

      case 1:
        trap_Cvar_SetValue( "r_subdivisions", 12 );
        break;

      case 2:
        trap_Cvar_SetValue( "r_subdivisions", 20 );
        break;
    }
  }
  else if( Q_stricmp( name, "ui_glCustom" ) == 0 )
  {
    switch( val )
    {
      case 0: // high quality
        trap_Cvar_SetValue( "r_subdivisions", 4 );
        trap_Cvar_SetValue( "r_vertexlight", 0 );
        trap_Cvar_SetValue( "r_lodbias", 0 );
        trap_Cvar_SetValue( "r_colorbits", 32 );
        trap_Cvar_SetValue( "r_depthbits", 24 );
        trap_Cvar_SetValue( "r_picmip", 0 );
        trap_Cvar_SetValue( "r_texturebits", 32 );
        trap_Cvar_SetValue( "r_fastSky", 0 );
        trap_Cvar_SetValue( "r_inGameVideo", 1 );
        trap_Cvar_SetValue( "cg_shadows", 1 );
        trap_Cvar_SetValue( "cg_bounceParticles", 1 );
        trap_Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
        break;

      case 1: // normal
        trap_Cvar_SetValue( "r_subdivisions", 12 );
        trap_Cvar_SetValue( "r_vertexlight", 0 );
        trap_Cvar_SetValue( "r_lodbias", 0 );
        trap_Cvar_SetValue( "r_colorbits", 0 );
        trap_Cvar_SetValue( "r_depthbits", 24 );
        trap_Cvar_SetValue( "r_picmip", 1 );
        trap_Cvar_SetValue( "r_texturebits", 0 );
        trap_Cvar_SetValue( "r_fastSky", 0 );
        trap_Cvar_SetValue( "r_inGameVideo", 1 );
        trap_Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
        trap_Cvar_SetValue( "cg_shadows", 0 );
        trap_Cvar_SetValue( "cg_bounceParticles", 0 );
        break;

      case 2: // fast
        trap_Cvar_SetValue( "r_subdivisions", 8 );
        trap_Cvar_SetValue( "r_vertexlight", 0 );
        trap_Cvar_SetValue( "r_lodbias", 1 );
        trap_Cvar_SetValue( "r_colorbits", 0 );
        trap_Cvar_SetValue( "r_depthbits", 0 );
        trap_Cvar_SetValue( "r_picmip", 1 );
        trap_Cvar_SetValue( "r_texturebits", 0 );
        trap_Cvar_SetValue( "cg_shadows", 0 );
        trap_Cvar_SetValue( "r_fastSky", 1 );
        trap_Cvar_SetValue( "r_inGameVideo", 0 );
        trap_Cvar_SetValue( "cg_bounceParticles", 0 );
        trap_Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
        break;

      case 3: // fastest
        trap_Cvar_SetValue( "r_subdivisions", 20 );
        trap_Cvar_SetValue( "r_vertexlight", 1 );
        trap_Cvar_SetValue( "r_lodbias", 2 );
        trap_Cvar_SetValue( "r_colorbits", 16 );
        trap_Cvar_SetValue( "r_depthbits", 16 );
        trap_Cvar_SetValue( "r_picmip", 2 );
        trap_Cvar_SetValue( "r_texturebits", 16 );
        trap_Cvar_SetValue( "cg_shadows", 0 );
        trap_Cvar_SetValue( "r_fastSky", 1 );
        trap_Cvar_SetValue( "r_inGameVideo", 0 );
        trap_Cvar_SetValue( "cg_bounceParticles", 0 );
        trap_Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
        break;
    }
  }
  else if( Q_stricmp( name, "ui_mousePitch" ) == 0 )
  {
    if( val == 0 )
      trap_Cvar_SetValue( "m_pitch", 0.022f );
    else
      trap_Cvar_SetValue( "m_pitch", -0.022f );
  }
}

//FIXME: lookup table
static void UI_RunMenuScript( char **args )
{
  const char *name, *name2;
  char buff[1024];
  const char *cmd;

  if( String_Parse( args, &name ) )
  {
    if( Q_stricmp( name, "StartServer" ) == 0 )
    {
      trap_Cvar_SetValue( "dedicated", Com_Clamp( 0, 2, ui_dedicated.integer ) );
      trap_Cmd_ExecuteText( EXEC_APPEND, va( "wait ; wait ; map %s\n",
                            uiInfo.mapList[ui_selectedMap.integer].mapLoadName ) );
    }
    else if( Q_stricmp( name, "resetDefaults" ) == 0 )
    {
      trap_Cmd_ExecuteText( EXEC_APPEND, "exec default.cfg\n" );
      trap_Cmd_ExecuteText( EXEC_APPEND, "cvar_restart\n" );
      Controls_SetDefaults();
      trap_Cvar_Set( "com_introPlayed", "1" );
      trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart\n" );
    }
    else if( Q_stricmp( name, "loadArenas" ) == 0 )
    {
      UI_LoadArenas();
      Menu_SetFeederSelection( NULL, FEEDER_MAPS, 0, "createserver" );
    }
    else if( Q_stricmp( name, "loadServerInfo" ) == 0 )
      UI_ServerInfo();
    else if( Q_stricmp( name, "getNews" ) == 0 )
      UI_UpdateNews( qtrue );
    else if( Q_stricmp( name, "saveControls" ) == 0 )
      Controls_SetConfig( qtrue );
    else if( Q_stricmp( name, "loadControls" ) == 0 )
      Controls_GetConfig();
    else if (Q_stricmp(name, "clearError") == 0) {
      trap_Cvar_Set("com_errorMessage", "");
    } else if (Q_stricmp(name, "downloadIgnore") == 0) {
      trap_Cvar_Set("com_downloadPrompt", va("%d", DLP_IGNORE));
    } else if (Q_stricmp(name, "downloadCURL") == 0) {
      trap_Cvar_Set("com_downloadPrompt", va("%d", DLP_CURL));
    } else if (Q_stricmp(name, "downloadUDP") == 0) {
      trap_Cvar_Set("com_downloadPrompt", va("%d", DLP_UDP));
    } else if (Q_stricmp(name, "RefreshServers") == 0) {
      UI_StartServerRefresh(qtrue);
      UI_BuildServerDisplayList(qtrue);
    } else if (Q_stricmp(name, "InitServerList") == 0) {
      int time = trap_RealTime( NULL );
      int last;
      int sortColumn;

      // set up default sorting

      if( !uiInfo.serverStatus.sorted && Int_Parse( args, &sortColumn ) )
      {
        uiInfo.serverStatus.sortKey = sortColumn;
        uiInfo.serverStatus.sortDir = 0;
      }

      // refresh if older than 3 days or if list is empty
      last = atoi( UI_Cvar_VariableString( va( "ui_lastServerRefresh_%i_time",
                                           ui_netSource.integer ) ) );

      if( trap_LAN_GetServerCount( ui_netSource.integer ) < 1 ||
          ( time - last ) > 3600 )
      {
        UI_StartServerRefresh( qtrue );
        UI_BuildServerDisplayList( qtrue );
      }
    }
    else if( Q_stricmp( name, "RefreshFilter" ) == 0 )
    {
      UI_StartServerRefresh( qfalse );
      UI_BuildServerDisplayList( qtrue );
    }
    else if( Q_stricmp( name, "LoadDemos" ) == 0 )
      UI_LoadDemos();
    else if( Q_stricmp( name, "LoadMovies" ) == 0 )
      UI_LoadMovies();
    else if( Q_stricmp( name, "LoadMods" ) == 0 )
      UI_LoadMods();
    else if( Q_stricmp( name, "LoadTeams" ) == 0 )
      UI_LoadTeams( );
    else if( Q_stricmp( name, "JoinTeam" ) == 0 )
    {
      if( ( cmd = uiInfo.teamList[ uiInfo.teamIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "LoadHumanItems" ) == 0 )
      UI_LoadHumanItems( );
    else if( Q_stricmp( name, "SpawnWithHumanItem" ) == 0 )
    {
      if( ( cmd = uiInfo.humanItemList[ uiInfo.humanItemIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "LoadAlienClasses" ) == 0 )
      UI_LoadAlienClasses( );
    else if( Q_stricmp( name, "SpawnAsAlienClass" ) == 0 )
    {
      if( ( cmd = uiInfo.alienClassList[ uiInfo.alienClassIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "LoadHumanArmouryBuys" ) == 0 )
      UI_LoadHumanArmouryBuys( );
    else if( Q_stricmp( name, "BuyFromArmoury" ) == 0 )
    {
      if( ( cmd = uiInfo.humanArmouryBuyList[ uiInfo.humanArmouryBuyIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );

      UI_InstallCaptureFunc( UI_ArmouryRefreshCb, NULL, 1000 );
    }
    else if( Q_stricmp( name, "LoadHumanArmourySells" ) == 0 )
      UI_LoadHumanArmourySells( );
    else if( Q_stricmp( name, "SellToArmoury" ) == 0 )
    {
      if( ( cmd = uiInfo.humanArmourySellList[ uiInfo.humanArmourySellIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );

      UI_InstallCaptureFunc( UI_ArmouryRefreshCb, NULL, 1000 );
    }
    else if( Q_stricmp( name, "LoadAlienUpgrades" ) == 0 )
    {
      UI_LoadAlienUpgrades( );

      //disallow the menu if it would be empty

      if( uiInfo.alienUpgradeCount <= 0 )
        Menus_CloseAll( );
    }
    else if( Q_stricmp( name, "UpgradeToNewClass" ) == 0 )
    {
      if( ( cmd = uiInfo.alienUpgradeList[ uiInfo.alienUpgradeIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "LoadAlienBuilds" ) == 0 )
      UI_LoadAlienBuilds( );
    else if( Q_stricmp( name, "BuildAlienBuildable" ) == 0 )
    {
      if( ( cmd = uiInfo.alienBuildList[ uiInfo.alienBuildIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "LoadHumanBuilds" ) == 0 )
      UI_LoadHumanBuilds( );
    else if( Q_stricmp( name, "BuildHumanBuildable" ) == 0 )
    {
      if( ( cmd = uiInfo.humanBuildList[ uiInfo.humanBuildIndex ].cmd ) )
        trap_Cmd_ExecuteText( EXEC_APPEND, cmd );
    }
    else if( Q_stricmp( name, "Say" ) == 0 )
    {
      char buffer[ MAX_CVAR_VALUE_STRING ];
      trap_Cvar_VariableStringBuffer( "ui_sayBuffer", buffer, sizeof( buffer ) );

      if( !buffer[ 0 ] )
        ;
      else if( ui_chatCommands.integer && ( buffer[ 0 ] == '/' ||
        buffer[ 0 ] == '\\' ) )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "%s\n", buffer + 1 ) );
      }
      else if( uiInfo.chatTeam )
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "say_team \"%s\"\n", buffer ) );
      else
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "say \"%s\"\n", buffer ) );
    }
    else if( Q_stricmp( name, "SayKeydown" ) == 0 )
    {
      if( ui_chatCommands.integer )
      {
        char buffer[ MAX_CVAR_VALUE_STRING ];
        trap_Cvar_VariableStringBuffer( "ui_sayBuffer", buffer, sizeof( buffer ) );

        if( buffer[ 0 ] == '/' || buffer[ 0 ] == '\\' )
          Menus_ReplaceActiveByName( "say_command" );
        else if( uiInfo.chatTeam )
          Menus_ReplaceActiveByName( "say_team" );
        else
          Menus_ReplaceActiveByName( "say" );
      }
    }
    else if( Q_stricmp( name, "playMovie" ) == 0 )
    {
      if( uiInfo.previewMovie >= 0 )
        trap_CIN_StopCinematic( uiInfo.previewMovie );

      trap_Cmd_ExecuteText( EXEC_APPEND, va( "cinematic %s.roq 2\n", uiInfo.movieList[uiInfo.movieIndex] ) );
    }
    else if( Q_stricmp( name, "RunMod" ) == 0 )
    {
      trap_Cvar_Set( "fs_game", uiInfo.modList[uiInfo.modIndex].modName );
      trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart;" );
    }
    else if( Q_stricmp( name, "RunDemo" ) == 0 )
      trap_Cmd_ExecuteText( EXEC_APPEND, va( "demo %s\n", uiInfo.demoList[uiInfo.demoIndex] ) );
    else if( Q_stricmp( name, "Tremulous" ) == 0 )
    {
      trap_Cvar_Set( "fs_game", "" );
      trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart;" );
    }
    else if( Q_stricmp( name, "closeJoin" ) == 0 )
    {
      if( uiInfo.serverStatus.refreshActive )
      {
        UI_StopServerRefresh();
        uiInfo.serverStatus.nextDisplayRefresh = 0;
        uiInfo.nextServerStatusRefresh = 0;
        uiInfo.nextFindPlayerRefresh = 0;
        UI_BuildServerDisplayList( qtrue );
      }
      else
      {
        Menus_CloseByName( "joinserver" );
        Menus_ActivateByName( "main" );
      }
    }
    else if( Q_stricmp( name, "StopRefresh" ) == 0 )
    {
      UI_StopServerRefresh();
      uiInfo.serverStatus.nextDisplayRefresh = 0;
      uiInfo.nextServerStatusRefresh = 0;
      uiInfo.nextFindPlayerRefresh = 0;
    }
    else if( Q_stricmp( name, "UpdateFilter" ) == 0 )
    {
      if( ui_netSource.integer == AS_LOCAL )
        UI_StartServerRefresh( qtrue );

      UI_BuildServerDisplayList( qtrue );
      UI_FeederSelection( FEEDER_SERVERS, 0 );
    }
    else if( Q_stricmp( name, "ServerStatus" ) == 0 )
    {
      trap_LAN_GetServerAddressString( ui_netSource.integer,
                                       uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer],
                                       uiInfo.serverStatusAddress, sizeof( uiInfo.serverStatusAddress ) );
      UI_BuildServerStatus( qtrue );
    }
    else if( Q_stricmp( name, "FoundPlayerServerStatus" ) == 0 )
    {
      Q_strncpyz( uiInfo.serverStatusAddress,
                  uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer],
                  sizeof( uiInfo.serverStatusAddress ) );
      UI_BuildServerStatus( qtrue );
      Menu_SetFeederSelection( NULL, FEEDER_FINDPLAYER, 0, NULL );
    }
    else if( Q_stricmp( name, "FindPlayer" ) == 0 )
    {
      UI_BuildFindPlayerList( qtrue );
      // clear the displayed server status info
      uiInfo.serverStatusInfo.numLines = 0;
      Menu_SetFeederSelection( NULL, FEEDER_FINDPLAYER, 0, NULL );
    }
    else if( Q_stricmp( name, "JoinServer" ) == 0 )
    {
      if( uiInfo.serverStatus.currentServer >= 0 &&
          uiInfo.serverStatus.currentServer < uiInfo.serverStatus.numDisplayServers )
      {
        trap_LAN_GetServerAddressString( ui_netSource.integer,
                                          uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer],
                                          buff, 1024 );
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "connect %s\n", buff ) );
      }
    }
    else if( Q_stricmp( name, "FoundPlayerJoinServer" ) == 0 )
    {
      if( uiInfo.currentFoundPlayerServer >= 0 &&
          uiInfo.currentFoundPlayerServer < uiInfo.numFoundPlayerServers )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "connect %s\n",
                              uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer] ) );
      }
    }
    else if( Q_stricmp( name, "Quit" ) == 0 )
      trap_Cmd_ExecuteText( EXEC_APPEND, "quit" );
    else if( Q_stricmp( name, "Leave" ) == 0 )
    {
      trap_Cmd_ExecuteText( EXEC_APPEND, "disconnect\n" );
      trap_Key_SetCatcher( KEYCATCH_UI );
      Menus_CloseAll( );
      Menus_ActivateByName( "main" );
    }
    else if( Q_stricmp( name, "ServerSort" ) == 0 )
    {
      int sortColumn;

      if( Int_Parse( args, &sortColumn ) )
      {
        // if same column we're already sorting on then flip the direction

        if( sortColumn == uiInfo.serverStatus.sortKey )
          uiInfo.serverStatus.sortDir = !uiInfo.serverStatus.sortDir;

        // make sure we sort again
        UI_ServersSort( sortColumn, qtrue );

        uiInfo.serverStatus.sorted = qtrue;
      }
    }
    else if( Q_stricmp( name, "closeingame" ) == 0 )
    {
      trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
      trap_Key_ClearStates();
      trap_Cvar_Set( "cl_paused", "0" );
      Menus_CloseAll( );
    }
    else if( Q_stricmp( name, "voteMap" ) == 0 )
    {
      if( ui_selectedMap.integer >= 0 && ui_selectedMap.integer < uiInfo.mapCount )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callvote map %s\n",
                              uiInfo.mapList[ui_selectedMap.integer].mapLoadName ) );
      }
    }
    else if( Q_stricmp( name, "voteNextMap" ) == 0 )
    {
      if( ui_selectedMap.integer >= 0 && ui_selectedMap.integer < uiInfo.mapCount )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callvote nextmap %s\n",
                              uiInfo.mapList[ui_selectedMap.integer].mapLoadName ) );
      }
    }
    else if( Q_stricmp( name, "voteKick" ) == 0 )
    {
      if( uiInfo.playerIndex >= 0 && uiInfo.playerIndex < uiInfo.playerCount )
      {
        char buffer[ MAX_CVAR_VALUE_STRING ];
        trap_Cvar_VariableStringBuffer( "ui_reason", buffer, sizeof( buffer ) ); 

        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callvote kick %d %s\n",
                                               uiInfo.clientNums[ uiInfo.playerIndex ],
                                               buffer ) );
        trap_Cvar_Set( "ui_reason", "" );
      }
    }
    else if( Q_stricmp( name, "voteMute" ) == 0 )
    {
      if( uiInfo.playerIndex >= 0 && uiInfo.playerIndex < uiInfo.playerCount )
      {
        char buffer[ MAX_CVAR_VALUE_STRING ];
        trap_Cvar_VariableStringBuffer( "ui_reason", buffer, sizeof( buffer ) ); 

        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callvote mute %d %s\n",
                                               uiInfo.clientNums[ uiInfo.playerIndex ],
                                               buffer ) );
        trap_Cvar_Set( "ui_reason", "" );
      }
    }
    else if( Q_stricmp( name, "voteUnMute" ) == 0 )
    {
      if( uiInfo.playerIndex >= 0 && uiInfo.playerIndex < uiInfo.playerCount )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callvote unmute %d\n",
                                               uiInfo.clientNums[ uiInfo.playerIndex ] ) );
      }
    }
    else if( Q_stricmp( name, "voteTeamKick" ) == 0 )
    {
      if( uiInfo.teamPlayerIndex >= 0 && uiInfo.teamPlayerIndex < uiInfo.myTeamCount )
      {
        char buffer[ MAX_CVAR_VALUE_STRING ];
        trap_Cvar_VariableStringBuffer( "ui_reason", buffer, sizeof( buffer ) ); 

        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callteamvote kick %d %s\n",
                                               uiInfo.teamClientNums[ uiInfo.teamPlayerIndex ],
                                               buffer ) );
        trap_Cvar_Set( "ui_reason", "" );
      }
    }
    else if( Q_stricmp( name, "voteTeamDenyBuild" ) == 0 )
    {
      if( uiInfo.teamPlayerIndex >= 0 && uiInfo.teamPlayerIndex < uiInfo.myTeamCount )
      {
        char buffer[ MAX_CVAR_VALUE_STRING ];
        trap_Cvar_VariableStringBuffer( "ui_reason", buffer, sizeof( buffer ) ); 

        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callteamvote denybuild %d %s\n",
                                               uiInfo.teamClientNums[ uiInfo.teamPlayerIndex ],
                                               buffer ) );
        trap_Cvar_Set( "ui_reason", "" );
      }
    }
    else if( Q_stricmp( name, "voteTeamAllowBuild" ) == 0 )
    {
      if( uiInfo.teamPlayerIndex >= 0 && uiInfo.teamPlayerIndex < uiInfo.myTeamCount )
      {
        trap_Cmd_ExecuteText( EXEC_APPEND, va( "callteamvote allowbuild %d\n",
                                               uiInfo.teamClientNums[ uiInfo.teamPlayerIndex ] ) );
      }
    }
    else if( Q_stricmp( name, "addFavorite" ) == 0 )
    {
      if( ui_netSource.integer != AS_FAVORITES )
      {
        char name[MAX_NAME_LENGTH];
        char addr[MAX_NAME_LENGTH];
        int res;

        trap_LAN_GetServerInfo( ui_netSource.integer,
                                uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer],
                                buff, MAX_STRING_CHARS );
        name[0] = addr[0] = '\0';
        Q_strncpyz( name,  Info_ValueForKey( buff, "hostname" ), MAX_NAME_LENGTH );
        Q_strncpyz( addr,  Info_ValueForKey( buff, "addr" ), MAX_NAME_LENGTH );

        if( strlen( name ) > 0 && strlen( addr ) > 0 )
        {
          res = trap_LAN_AddServer( AS_FAVORITES, name, addr );

          if( res == 0 )
          {
            // server already in the list
            Com_Printf( "Favorite already in list\n" );
          }
          else if( res == -1 )
          {
            // list full
            Com_Printf( "Favorite list full\n" );
          }
          else
          {
            // successfully added
            Com_Printf( "Added favorite server %s\n", addr );
          }
        }
      }
    }
    else if( Q_stricmp( name, "deleteFavorite" ) == 0 )
    {
      if( ui_netSource.integer == AS_FAVORITES )
      {
        char addr[MAX_NAME_LENGTH];
        trap_LAN_GetServerInfo( ui_netSource.integer,
                                uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer],
                                buff, MAX_STRING_CHARS );
        addr[0] = '\0';
        Q_strncpyz( addr,  Info_ValueForKey( buff, "addr" ), MAX_NAME_LENGTH );

        if( strlen( addr ) > 0 )
          trap_LAN_RemoveServer( AS_FAVORITES, addr );
      }
    }
    else if( Q_stricmp( name, "createFavorite" ) == 0 )
    {
      if( ui_netSource.integer == AS_FAVORITES )
      {
        char name[MAX_NAME_LENGTH];
        char addr[MAX_NAME_LENGTH];
        int res;

        name[0] = addr[0] = '\0';
        Q_strncpyz( name,  UI_Cvar_VariableString( "ui_favoriteName" ), MAX_NAME_LENGTH );
        Q_strncpyz( addr,  UI_Cvar_VariableString( "ui_favoriteAddress" ), MAX_NAME_LENGTH );

        if( strlen( name ) > 0 && strlen( addr ) > 0 )
        {
          res = trap_LAN_AddServer( AS_FAVORITES, name, addr );

          if( res == 0 )
          {
            // server already in the list
            Com_Printf( "Favorite already in list\n" );
          }
          else if( res == -1 )
          {
            // list full
            Com_Printf( "Favorite list full\n" );
          }
          else
          {
            // successfully added
            Com_Printf( "Added favorite server %s\n", addr );
          }
        }
      }
    }
    else if( Q_stricmp( name, "glCustom" ) == 0 )
      trap_Cvar_Set( "ui_glCustom", "4" );
    else if( Q_stricmp( name, "update" ) == 0 )
    {
      if( String_Parse( args, &name2 ) )
        UI_Update( name2 );
    }
    else if( Q_stricmp( name, "InitIgnoreList" ) == 0 )
      UI_BuildPlayerList();
    else if( Q_stricmp( name, "ToggleIgnore" ) == 0 )
    {
      if( uiInfo.ignoreIndex >= 0 && uiInfo.ignoreIndex < uiInfo.playerCount )
      {
        if( Com_ClientListContains( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                               uiInfo.clientNums[ uiInfo.ignoreIndex ] ) )
        {
          Com_ClientListRemove( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                               uiInfo.clientNums[ uiInfo.ignoreIndex ] );
          trap_Cmd_ExecuteText( EXEC_APPEND, va( "unignore %i\n",
                                              uiInfo.clientNums[ uiInfo.ignoreIndex ] ) );
        }
        else
        {
          Com_ClientListAdd( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                            uiInfo.clientNums[ uiInfo.ignoreIndex ] );
          trap_Cmd_ExecuteText( EXEC_APPEND, va( "ignore %i\n",
                                              uiInfo.clientNums[ uiInfo.ignoreIndex ] ) );
        }
      }
    }
    else if( Q_stricmp( name, "IgnorePlayer" ) == 0 )
    {
      if( uiInfo.ignoreIndex >= 0 && uiInfo.ignoreIndex < uiInfo.playerCount )
      {
        if( !Com_ClientListContains( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                                uiInfo.clientNums[ uiInfo.ignoreIndex ] ) )
        {
          Com_ClientListAdd( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                            uiInfo.clientNums[ uiInfo.ignoreIndex ] );
          trap_Cmd_ExecuteText( EXEC_APPEND, va( "ignore %i\n",
                                              uiInfo.clientNums[ uiInfo.ignoreIndex ] ) );
        }
      }
    }
    else if( Q_stricmp( name, "UnIgnorePlayer" ) == 0 )
    {
      if( uiInfo.ignoreIndex >= 0 && uiInfo.ignoreIndex < uiInfo.playerCount )
      {
        if( Com_ClientListContains( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                               uiInfo.clientNums[ uiInfo.ignoreIndex ] ) )
        {
          Com_ClientListRemove( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                               uiInfo.clientNums[ uiInfo.ignoreIndex ] );
          trap_Cmd_ExecuteText( EXEC_APPEND, va( "unignore %i\n",
                                              uiInfo.clientNums[ uiInfo.ignoreIndex ] ) );
        }
      }
    }
    else
      Com_Printf( "unknown UI script %s\n", name );
  }
}

static int UI_FeederInitialise( int feederID );

/*
==================
UI_FeederCount
==================
*/
static int UI_FeederCount( int feederID )
{
  if( feederID == FEEDER_CINEMATICS )
    return uiInfo.movieCount;
  else if( feederID == FEEDER_MAPS )
    return uiInfo.mapCount;
  else if( feederID == FEEDER_SERVERS )
    return uiInfo.serverStatus.numDisplayServers;
  else if( feederID == FEEDER_SERVERSTATUS )
    return uiInfo.serverStatusInfo.numLines;
  else if( feederID == FEEDER_NEWS )
    return uiInfo.newsInfo.numLines;
  else if( feederID == FEEDER_FINDPLAYER )
    return uiInfo.numFoundPlayerServers;
  else if( feederID == FEEDER_PLAYER_LIST )
  {
    if( uiInfo.uiDC.realTime > uiInfo.playerRefresh )
    {
      uiInfo.playerRefresh = uiInfo.uiDC.realTime + 3000;
      UI_BuildPlayerList();
    }

    return uiInfo.playerCount;
  }
  else if( feederID == FEEDER_TEAM_LIST )
  {
    if( uiInfo.uiDC.realTime > uiInfo.playerRefresh )
    {
      uiInfo.playerRefresh = uiInfo.uiDC.realTime + 3000;
      UI_BuildPlayerList();
    }

    return uiInfo.myTeamCount;
  }
  else if( feederID == FEEDER_IGNORE_LIST )
    return uiInfo.playerCount;
  else if( feederID == FEEDER_HELP_LIST )
    return uiInfo.helpCount;
  else if( feederID == FEEDER_MODS )
    return uiInfo.modCount;
  else if( feederID == FEEDER_DEMOS )
    return uiInfo.demoCount;
  else if( feederID == FEEDER_TREMTEAMS )
    return uiInfo.teamCount;
  else if( feederID == FEEDER_TREMHUMANITEMS )
    return uiInfo.humanItemCount;
  else if( feederID == FEEDER_TREMALIENCLASSES )
    return uiInfo.alienClassCount;
  else if( feederID == FEEDER_TREMHUMANARMOURYBUY )
    return uiInfo.humanArmouryBuyCount;
  else if( feederID == FEEDER_TREMHUMANARMOURYSELL )
    return uiInfo.humanArmourySellCount;
  else if( feederID == FEEDER_TREMALIENUPGRADE )
    return uiInfo.alienUpgradeCount;
  else if( feederID == FEEDER_TREMALIENBUILD )
    return uiInfo.alienBuildCount;
  else if( feederID == FEEDER_TREMHUMANBUILD )
    return uiInfo.humanBuildCount;
  else if( feederID == FEEDER_RESOLUTIONS )
  {
    if( UI_FeederInitialise( feederID ) == uiInfo.numResolutions )
      return uiInfo.numResolutions + 1;
    else
      return uiInfo.numResolutions;
  }

  return 0;
}

static const char *UI_SelectedMap( int index, int *actual )
{
  int i, c;
  c = 0;
  *actual = 0;

  for( i = 0; i < uiInfo.mapCount; i++ )
  {
    if( c == index )
    {
      *actual = i;
      return uiInfo.mapList[i].mapName;
    }
    else
      c++;
  }

  return "";
}

static int GCD( int a, int b )
{
  int c;

  while( b != 0 )
  {
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

static const char *UI_DisplayAspectString( int w, int h )
{
  int gcd = GCD( w, h );

  w /= gcd;
  h /= gcd;

  // For some reason 8:5 is usually referred to as 16:10
  if( w == 8 && h == 5 )
  {
    w = 16;
    h = 10;
  }

  return va( "%d:%d", w, h );
}

static const char *UI_FeederItemText( int feederID, int index, int column, qhandle_t *handle )
{
  if( handle )
    *handle = -1;

  if( feederID == FEEDER_MAPS )
  {
    int actual;
    return UI_SelectedMap( index, &actual );
  }
  else if( feederID == FEEDER_SERVERS )
  {
    if( index >= 0 && index < UI_FeederCount( feederID ) )
    {
      static char info[MAX_STRING_CHARS];
      static char clientBuff[ 32 ];
      static char cleaned[ MAX_STRING_CHARS ];
      static int  lastColumn = -1;
      static int  lastTime = 0;
      int         ping;

      if( lastColumn != column || lastTime > uiInfo.uiDC.realTime + 5000 )
      {
        trap_LAN_GetServerInfo( ui_netSource.integer, uiInfo.serverStatus.displayServers[index],
                                info, MAX_STRING_CHARS );
        lastColumn = column;
        lastTime = uiInfo.uiDC.realTime;
      }

      ping = atoi( Info_ValueForKey( info, "ping" ) );

      UI_EscapeEmoticons( cleaned, Info_ValueForKey( info, "hostname" ), sizeof( cleaned ) );

      switch( column )
      {
        case SORT_HOST:
          if( ping <= 0 )
            return Info_ValueForKey( info, "addr" );
          else
          {
            static char hostname[1024];

            if( ui_netSource.integer == AS_LOCAL )
            {
              Com_sprintf( hostname, sizeof( hostname ), "%s [%s]", cleaned, 
                           netnames[atoi( Info_ValueForKey( info, "nettype" ) )] );
              return hostname;
            }
            else
            {
              char *text;
              char *label;

              label = Info_ValueForKey( info, "label" );
              if( label[0] )
              {
                // First char of the label response is a sorting tag. Skip it.
                label+= 1;

                Com_sprintf( hostname, sizeof( hostname ), "%s %s", 
                             label, cleaned );
              }
              else
              {
                Com_sprintf( hostname, sizeof( hostname ), "%s", 
                             cleaned );
              }

              // Strip leading whitespace
              text = hostname;

              while( *text != '\0' && *text == ' ' )
                text++;

              return text;
            }
          }

        case SORT_GAME:
          return Info_ValueForKey( info, "game" );

        case SORT_MAP:
          return Info_ValueForKey( info, "mapname" );

        case SORT_CLIENTS:
          Com_sprintf( clientBuff, sizeof( clientBuff ), "%s (%s)",
                       Info_ValueForKey( info, "clients" ), Info_ValueForKey( info, "sv_maxclients" ) );
          return clientBuff;

        case SORT_PING:
          if( ping <= 0 )
            return "...";
          else
            return Info_ValueForKey( info, "ping" );
      }
    }
  }
  else if( feederID == FEEDER_SERVERSTATUS )
  {
    if( index >= 0 && index < uiInfo.serverStatusInfo.numLines )
    {
      if( column >= 0 && column < 4 )
        return uiInfo.serverStatusInfo.lines[index][column];
    }
  }
  else if( feederID == FEEDER_NEWS )
  {
    if( index >= 0 && index < uiInfo.newsInfo.numLines )
      return uiInfo.newsInfo.text[index];
  }
  else if( feederID == FEEDER_FINDPLAYER )
  {
    if( index >= 0 && index < uiInfo.numFoundPlayerServers )
      return uiInfo.foundPlayerServerNames[index];
  }
  else if( feederID == FEEDER_PLAYER_LIST )
  {
    if( index >= 0 && index < uiInfo.playerCount )
      return uiInfo.playerNames[index];
  }
  else if( feederID == FEEDER_TEAM_LIST )
  {
    if( index >= 0 && index < uiInfo.myTeamCount )
      return uiInfo.teamNames[index];
  }
  else if( feederID == FEEDER_IGNORE_LIST )
  {
    if( index >= 0 && index < uiInfo.playerCount )
    {
      switch( column )
      {
        case 1:
          // am I ignoring him
          return Com_ClientListContains( &uiInfo.ignoreList[ uiInfo.myPlayerIndex ],
                                         uiInfo.clientNums[ index ] ) ? "X" : "";

        case 2:
          // is he ignoring me
          return Com_ClientListContains( &uiInfo.ignoreList[ index ],
                                         uiInfo.playerNumber ) ? "X" : "";

        default:
          return uiInfo.playerNames[index];
      }
    }
  }
  else if( feederID == FEEDER_HELP_LIST )
  {
    if( index >= 0 && index < uiInfo.helpCount )
      return uiInfo.helpList[ index ].text;
  }
  else if( feederID == FEEDER_MODS )
  {
    if( index >= 0 && index < uiInfo.modCount )
    {
      if( uiInfo.modList[index].modDescr && *uiInfo.modList[index].modDescr )
        return uiInfo.modList[index].modDescr;
      else
        return uiInfo.modList[index].modName;
    }
  }
  else if( feederID == FEEDER_CINEMATICS )
  {
    if( index >= 0 && index < uiInfo.movieCount )
      return uiInfo.movieList[index];
  }
  else if( feederID == FEEDER_DEMOS )
  {
    if( index >= 0 && index < uiInfo.demoCount )
      return uiInfo.demoList[index];
  }
  else if( feederID == FEEDER_TREMTEAMS )
  {
    if( index >= 0 && index < uiInfo.teamCount )
      return uiInfo.teamList[ index ].text;
  }
  else if( feederID == FEEDER_TREMHUMANITEMS )
  {
    if( index >= 0 && index < uiInfo.humanItemCount )
      return uiInfo.humanItemList[ index ].text;
  }
  else if( feederID == FEEDER_TREMALIENCLASSES )
  {
    if( index >= 0 && index < uiInfo.alienClassCount )
      return uiInfo.alienClassList[ index ].text;
  }
  else if( feederID == FEEDER_TREMHUMANARMOURYBUY )
  {
    if( index >= 0 && index < uiInfo.humanArmouryBuyCount )
      return uiInfo.humanArmouryBuyList[ index ].text;
  }
  else if( feederID == FEEDER_TREMHUMANARMOURYSELL )
  {
    if( index >= 0 && index < uiInfo.humanArmourySellCount )
      return uiInfo.humanArmourySellList[ index ].text;
  }
  else if( feederID == FEEDER_TREMALIENUPGRADE )
  {
    if( index >= 0 && index < uiInfo.alienUpgradeCount )
      return uiInfo.alienUpgradeList[ index ].text;
  }
  else if( feederID == FEEDER_TREMALIENBUILD )
  {
    if( index >= 0 && index < uiInfo.alienBuildCount )
      return uiInfo.alienBuildList[ index ].text;
  }
  else if( feederID == FEEDER_TREMHUMANBUILD )
  {
    if( index >= 0 && index < uiInfo.humanBuildCount )
      return uiInfo.humanBuildList[ index ].text;
  }
  else if( feederID == FEEDER_RESOLUTIONS )
  {
    static char resolution[MAX_STRING_CHARS];
    int w, h;

    if( index >= 0 && index < uiInfo.numResolutions )
    {
      w = uiInfo.resolutions[ index ].w;
      h = uiInfo.resolutions[ index ].h;

      Com_sprintf( resolution, sizeof( resolution ), "%dx%d (%s)", w, h,
          UI_DisplayAspectString( w, h ) );

      return resolution;
    }

    w = (int)trap_Cvar_VariableValue( "r_width" );
    h = (int)trap_Cvar_VariableValue( "r_height" );
    Com_sprintf( resolution, sizeof( resolution ), "Custom (%dx%d)", w, h );

    return resolution;
  }

  return "";
}


static qhandle_t UI_FeederItemImage( int feederID, int index )
{
  if( feederID == FEEDER_MAPS )
  {
    int actual;
    UI_SelectedMap( index, &actual );
    index = actual;

    if( index >= 0 && index < uiInfo.mapCount )
    {
      if( uiInfo.mapList[index].levelShot == -1 )
        uiInfo.mapList[index].levelShot = trap_R_RegisterShaderNoMip( uiInfo.mapList[index].imageName );

      return uiInfo.mapList[index].levelShot;
    }
  }

  return 0;
}

static void UI_FeederSelection( int feederID, int index )
{
  static char info[MAX_STRING_CHARS];

  if( feederID == FEEDER_MAPS )
  {
    int actual, map;
    map = ui_selectedMap.integer;

    if( uiInfo.mapList[map].cinematic >= 0 )
    {
      trap_CIN_StopCinematic( uiInfo.mapList[map].cinematic );
      uiInfo.mapList[map].cinematic = -1;
    }

    UI_SelectedMap( index, &actual );

    ui_selectedMap.integer = actual;
    trap_Cvar_Set( "ui_selectedMap", va( "%d", actual ) );
    uiInfo.mapList[ui_selectedMap.integer].cinematic =
      trap_CIN_PlayCinematic( va( "%s.roq", uiInfo.mapList[ui_selectedMap.integer].mapLoadName ),
                              0, 0, 0, 0, ( CIN_loop | CIN_silent ) );
  }
  else if( feederID == FEEDER_SERVERS )
  {
    const char *mapName = NULL;

    uiInfo.serverStatus.currentServer = index;
    trap_LAN_GetServerInfo( ui_netSource.integer, uiInfo.serverStatus.displayServers[index],
                            info, MAX_STRING_CHARS );
    uiInfo.serverStatus.currentServerPreview =
      trap_R_RegisterShaderNoMip( va( "levelshots/%s", Info_ValueForKey( info, "mapname" ) ) );

    if( uiInfo.serverStatus.currentServerCinematic >= 0 )
    {
      trap_CIN_StopCinematic( uiInfo.serverStatus.currentServerCinematic );
      uiInfo.serverStatus.currentServerCinematic = -1;
    }

    mapName = Info_ValueForKey( info, "mapname" );

    if( mapName && *mapName )
    {
      uiInfo.serverStatus.currentServerCinematic =
        trap_CIN_PlayCinematic( va( "%s.roq", mapName ), 0, 0, 0, 0, ( CIN_loop | CIN_silent ) );
    }
  }
  else if( feederID == FEEDER_SERVERSTATUS )
  {
  }
  else if( feederID == FEEDER_FINDPLAYER )
  {
    uiInfo.currentFoundPlayerServer = index;
    //

    if( index < uiInfo.numFoundPlayerServers - 1 )
    {
      // build a new server status for this server
      Q_strncpyz( uiInfo.serverStatusAddress,
                  uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer],
                  sizeof( uiInfo.serverStatusAddress ) );
      Menu_SetFeederSelection( NULL, FEEDER_SERVERSTATUS, 0, NULL );
      UI_BuildServerStatus( qtrue );
    }
  }
  else if( feederID == FEEDER_PLAYER_LIST )
    uiInfo.playerIndex = index;
  else if( feederID == FEEDER_TEAM_LIST )
    uiInfo.teamPlayerIndex = index;
  else if( feederID == FEEDER_IGNORE_LIST )
    uiInfo.ignoreIndex = index;
  else if( feederID == FEEDER_HELP_LIST )
    uiInfo.helpIndex = index;
  else if( feederID == FEEDER_MODS )
    uiInfo.modIndex = index;
  else if( feederID == FEEDER_CINEMATICS )
  {
    uiInfo.movieIndex = index;

    if( uiInfo.previewMovie >= 0 )
      trap_CIN_StopCinematic( uiInfo.previewMovie );

    uiInfo.previewMovie = -1;
  }
  else if( feederID == FEEDER_DEMOS )
    uiInfo.demoIndex = index;
  else if( feederID == FEEDER_TREMTEAMS )
    uiInfo.teamIndex = index;
  else if( feederID == FEEDER_TREMHUMANITEMS )
    uiInfo.humanItemIndex = index;
  else if( feederID == FEEDER_TREMALIENCLASSES )
    uiInfo.alienClassIndex = index;
  else if( feederID == FEEDER_TREMHUMANARMOURYBUY )
    uiInfo.humanArmouryBuyIndex = index;
  else if( feederID == FEEDER_TREMHUMANARMOURYSELL )
    uiInfo.humanArmourySellIndex = index;
  else if( feederID == FEEDER_TREMALIENUPGRADE )
    uiInfo.alienUpgradeIndex = index;
  else if( feederID == FEEDER_TREMALIENBUILD )
    uiInfo.alienBuildIndex = index;
  else if( feederID == FEEDER_TREMHUMANBUILD )
    uiInfo.humanBuildIndex = index;
  else if( feederID == FEEDER_RESOLUTIONS )
  {
    if( index >= 0 && index < uiInfo.numResolutions )
    {
      trap_Cvar_Set( "r_width", va( "%d", uiInfo.resolutions[ index ].w ) );
      trap_Cvar_Set( "r_height", va( "%d", uiInfo.resolutions[ index ].h ) );
    }

    uiInfo.resolutionIndex = index;
  }
}

static int UI_FeederInitialise( int feederID )
{
  if( feederID == FEEDER_RESOLUTIONS )
  {
    int i;
    int w = trap_Cvar_VariableValue( "r_width" );
    int h = trap_Cvar_VariableValue( "r_height" );

    for( i = 0; i < uiInfo.numResolutions; i++ )
    {
      if( w == uiInfo.resolutions[ i ].w && h == uiInfo.resolutions[ i ].h )
        return i;
    }

    return uiInfo.numResolutions;
  }

  return 0;
}

static void UI_Pause( qboolean b )
{
  if( b )
  {
    // pause the game and set the ui keycatcher
    trap_Cvar_Set( "cl_paused", "1" );
    trap_Key_SetCatcher( KEYCATCH_UI );
  }
  else
  {
    // unpause the game and clear the ui keycatcher
    trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
    trap_Key_ClearStates();
    trap_Cvar_Set( "cl_paused", "0" );
  }
}

static int UI_PlayCinematic( const char *name, float x, float y, float w, float h )
{
  return trap_CIN_PlayCinematic( name, x, y, w, h, ( CIN_loop | CIN_silent ) );
}

static void UI_StopCinematic( int handle )
{
  if( handle >= 0 )
    trap_CIN_StopCinematic( handle );
  else
  {
    handle = abs( handle );

    if( handle == UI_NETMAPCINEMATIC )
    {
      if( uiInfo.serverStatus.currentServerCinematic >= 0 )
      {
        trap_CIN_StopCinematic( uiInfo.serverStatus.currentServerCinematic );
        uiInfo.serverStatus.currentServerCinematic = -1;
      }
    }
  }
}

static void UI_DrawCinematic( int handle, float x, float y, float w, float h )
{
  trap_CIN_SetExtents( handle, x, y, w, h );
  trap_CIN_DrawCinematic( handle );
}

static void UI_RunCinematicFrame( int handle )
{
  trap_CIN_RunCinematic( handle );
}

static float UI_GetValue( int ownerDraw )
{
  return 0.0f;
}

/*
=================
UI_ParseResolutions
=================
*/
void UI_ParseResolutions( void )
{
  char        buf[ MAX_STRING_CHARS ];
  char        w[ 16 ], h[ 16 ];
  char        *p;
  const char  *out;
  char        *s = NULL;

  trap_Cvar_VariableStringBuffer( "r_availableModes", buf, sizeof( buf ) );
  p = buf;
  uiInfo.numResolutions = 0;

  while( String_Parse( &p, &out ) )
  {
    Q_strncpyz( w, out, sizeof( w ) );
    s = strchr( w, 'x' );
    if( !s )
      return;

    *s++ = '\0';
    Q_strncpyz( h, s, sizeof( h ) );

    uiInfo.resolutions[ uiInfo.numResolutions ].w = atoi( w );
    uiInfo.resolutions[ uiInfo.numResolutions ].h = atoi( h );
    uiInfo.numResolutions++;
  }
}

/*
=================
UI_Init
=================
*/
void UI_Init( qboolean inGameLoad )
{
  BG_InitClassConfigs( );
  BG_InitAllowedGameElements( );

  uiInfo.inGameLoad = inGameLoad;

  UI_RegisterCvars();
  UI_InitMemory();

  // cache redundant calulations
  trap_GetGlconfig( &uiInfo.uiDC.glconfig );

  // for 640x480 virtualized screen
  uiInfo.uiDC.yscale = uiInfo.uiDC.glconfig.vidHeight * ( 1.0f / 480.0f );
  uiInfo.uiDC.xscale = uiInfo.uiDC.glconfig.vidWidth * ( 1.0f / 640.0f );

  // wide screen
  uiInfo.uiDC.aspectScale = ( ( 640.0f * uiInfo.uiDC.glconfig.vidHeight ) /
      ( 480.0f * uiInfo.uiDC.glconfig.vidWidth ) );

  uiInfo.uiDC.smallFontScale = trap_Cvar_VariableValue( "ui_smallFont" );
  uiInfo.uiDC.bigFontScale = trap_Cvar_VariableValue( "ui_bigFont" );

  uiInfo.uiDC.registerShaderNoMip = &trap_R_RegisterShaderNoMip;
  uiInfo.uiDC.setColor = &UI_SetColor;
  uiInfo.uiDC.drawHandlePic = &UI_DrawHandlePic;
  uiInfo.uiDC.drawStretchPic = &trap_R_DrawStretchPic;
  uiInfo.uiDC.registerModel = &trap_R_RegisterModel;
  uiInfo.uiDC.modelBounds = &trap_R_ModelBounds;
  uiInfo.uiDC.fillRect = &UI_FillRect;
  uiInfo.uiDC.drawRect = &UI_DrawRect;
  uiInfo.uiDC.drawSides = &UI_DrawSides;
  uiInfo.uiDC.drawTopBottom = &UI_DrawTopBottom;
  uiInfo.uiDC.clearScene = &trap_R_ClearScene;
  uiInfo.uiDC.drawSides = &UI_DrawSides;
  uiInfo.uiDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
  uiInfo.uiDC.renderScene = &trap_R_RenderScene;
  uiInfo.uiDC.registerFont = &trap_R_RegisterFont;
  uiInfo.uiDC.ownerDrawItem = &UI_OwnerDraw;
  uiInfo.uiDC.getValue = &UI_GetValue;
  uiInfo.uiDC.ownerDrawVisible = &UI_OwnerDrawVisible;
  uiInfo.uiDC.runScript = &UI_RunMenuScript;
  uiInfo.uiDC.setCVar = trap_Cvar_Set;
  uiInfo.uiDC.getCVarString = trap_Cvar_VariableStringBuffer;
  uiInfo.uiDC.getCVarValue = trap_Cvar_VariableValue;
  uiInfo.uiDC.setOverstrikeMode = &trap_Key_SetOverstrikeMode;
  uiInfo.uiDC.getOverstrikeMode = &trap_Key_GetOverstrikeMode;
  uiInfo.uiDC.startLocalSound = &trap_S_StartLocalSound;
  uiInfo.uiDC.ownerDrawHandleKey = &UI_OwnerDrawHandleKey;
  uiInfo.uiDC.feederCount = &UI_FeederCount;
  uiInfo.uiDC.feederItemImage = &UI_FeederItemImage;
  uiInfo.uiDC.feederItemText = &UI_FeederItemText;
  uiInfo.uiDC.feederSelection = &UI_FeederSelection;
  uiInfo.uiDC.feederInitialise = &UI_FeederInitialise;
  uiInfo.uiDC.setBinding = &trap_Key_SetBinding;
  uiInfo.uiDC.getBindingBuf = &trap_Key_GetBindingBuf;
  uiInfo.uiDC.keynumToStringBuf = &trap_Key_KeynumToStringBuf;
  uiInfo.uiDC.executeText = &trap_Cmd_ExecuteText;
  uiInfo.uiDC.Error = &Com_Error;
  uiInfo.uiDC.Print = &Com_Printf;
  uiInfo.uiDC.Pause = &UI_Pause;
  uiInfo.uiDC.ownerDrawWidth = &UI_OwnerDrawWidth;
  uiInfo.uiDC.ownerDrawText = &UI_OwnerDrawText;
  uiInfo.uiDC.registerSound = &trap_S_RegisterSound;
  uiInfo.uiDC.startBackgroundTrack = &trap_S_StartBackgroundTrack;
  uiInfo.uiDC.stopBackgroundTrack = &trap_S_StopBackgroundTrack;
  uiInfo.uiDC.playCinematic = &UI_PlayCinematic;
  uiInfo.uiDC.stopCinematic = &UI_StopCinematic;
  uiInfo.uiDC.drawCinematic = &UI_DrawCinematic;
  uiInfo.uiDC.runCinematicFrame = &UI_RunCinematicFrame;

  Init_Display( &uiInfo.uiDC );

  String_Init();

  uiInfo.uiDC.whiteShader = trap_R_RegisterShaderNoMip( "white" );

  AssetCache();

  UI_LoadMenus( "ui/menus.txt", qtrue );
  UI_LoadMenus( "ui/ingame.txt", qfalse );
  UI_LoadMenus( "ui/tremulous.txt", qfalse );
  UI_LoadHelp( "ui/help.txt" );

  Menus_CloseAll( );

  trap_LAN_LoadCachedServers();

  // sets defaults for ui temp cvars
  trap_Cvar_Set( "ui_mousePitch", ( trap_Cvar_VariableValue( "m_pitch" ) >= 0 ) ? "0" : "1" );

  uiInfo.serverStatus.currentServerCinematic = -1;
  uiInfo.previewMovie = -1;

  UI_ParseResolutions( );
}


/*
=================
UI_KeyEvent
=================
*/
void UI_KeyEvent( int key, qboolean down )
{
  if( Menu_Count() > 0 )
  {
    menuDef_t *menu = Menu_GetFocused();

    if( menu )
    {
      if( key == K_ESCAPE && down && !Menus_AnyFullScreenVisible() )
        Menus_CloseAll( );
      else
        Menu_HandleKey( menu, key, down );
    }
    else
    {
      trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
      trap_Key_ClearStates();
      trap_Cvar_Set( "cl_paused", "0" );
    }
  }
}

/*
=================
UI_MouseEvent
=================
*/
void UI_MouseEvent( int dx, int dy )
{
  // update mouse screen position
  uiInfo.uiDC.cursorx += ( dx * uiInfo.uiDC.aspectScale );

  if( uiInfo.uiDC.cursorx < 0 )
    uiInfo.uiDC.cursorx = 0;
  else if( uiInfo.uiDC.cursorx > SCREEN_WIDTH )
    uiInfo.uiDC.cursorx = SCREEN_WIDTH;

  uiInfo.uiDC.cursory += dy;

  if( uiInfo.uiDC.cursory < 0 )
    uiInfo.uiDC.cursory = 0;
  else if( uiInfo.uiDC.cursory > SCREEN_HEIGHT )
    uiInfo.uiDC.cursory = SCREEN_HEIGHT;

  if( Menu_Count( ) > 0 )
    Display_MouseMove( NULL, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory );
}

/*
=================
UI_MousePosition
=================
*/
int UI_MousePosition( void )
{
  return (int)rint( uiInfo.uiDC.cursorx ) |
         (int)rint( uiInfo.uiDC.cursory ) << 16;
}

/*
=================
UI_SetMousePosition
=================
*/
void UI_SetMousePosition( int x, int y )
{
  uiInfo.uiDC.cursorx = x;
  uiInfo.uiDC.cursory = y;

  if( Menu_Count( ) > 0 )
    Display_MouseMove( NULL, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory );
}

void UI_SetActiveMenu( uiMenuCommand_t menu )
{
  char buf[256];

  // this should be the ONLY way the menu system is brought up
  // enusure minumum menu data is cached

  if( Menu_Count() > 0 )
  {
    vec3_t v;
    v[0] = v[1] = v[2] = 0;

    switch( menu )
    {
      case UIMENU_NONE:
        trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
        trap_Key_ClearStates();
        trap_Cvar_Set( "cl_paused", "0" );
        Menus_CloseAll( );

        return;

      case UIMENU_MAIN:
        trap_Cvar_Set( "sv_killserver", "1" );
        trap_Key_SetCatcher( KEYCATCH_UI );
        Menus_CloseAll( );
        Menus_ActivateByName( "main" );
        trap_Cvar_VariableStringBuffer( "com_errorMessage", buf, sizeof( buf ) );

        if( strlen( buf ) )
        {
          if( trap_Cvar_VariableValue( "com_errorCode" ) == ERR_SERVERDISCONNECT )
            Menus_ActivateByName( "drop_popmenu" );
          else
            Menus_ActivateByName( "error_popmenu" );
        }

        return;

      case UIMENU_INGAME:
        trap_Cvar_Set( "cl_paused", "1" );
        trap_Key_SetCatcher( KEYCATCH_UI );
        UI_BuildPlayerList();
        Menus_CloseAll( );
        Menus_ActivateByName( "ingame" );
        return;
    }
  }
}

qboolean UI_IsFullscreen( void )
{
  return Menus_AnyFullScreenVisible( );
}



static connstate_t  lastConnState;
static char     lastLoadingText[MAX_INFO_VALUE];

static void UI_ReadableSize ( char *buf, int bufsize, int value )
{
  if( value > 1024 * 1024 * 1024 )
  { // gigs
    Com_sprintf( buf, bufsize, "%d", value / ( 1024 * 1024 * 1024 ) );
    Com_sprintf( buf + strlen( buf ), bufsize - strlen( buf ), ".%02d GB",
        ( value % ( 1024 * 1024 * 1024 ) ) * 100 / ( 1024 * 1024 * 1024 ) );
  }
  else if( value > 1024 * 1024 )
  { // megs
    Com_sprintf( buf, bufsize, "%d", value / ( 1024 * 1024 ) );
    Com_sprintf( buf + strlen( buf ), bufsize - strlen( buf ), ".%02d MB",
        ( value % ( 1024 * 1024 ) ) * 100 / ( 1024 * 1024 ) );
  }
  else if( value > 1024 )
  { // kilos
    Com_sprintf( buf, bufsize, "%d KB", value / 1024 );
  }
  else
  { // bytes
    Com_sprintf( buf, bufsize, "%d bytes", value );
  }
}

// Assumes time is in msec
static void UI_PrintTime ( char *buf, int bufsize, int time )
{
  time /= 1000;  // change to seconds

  if( time > 3600 )
  { // in the hours range
    Com_sprintf( buf, bufsize, "%d hr %d min", time / 3600, ( time % 3600 ) / 60 );
  }
  else if( time > 60 )
  { // mins
    Com_sprintf( buf, bufsize, "%d min %d sec", time / 60, time % 60 );
  }
  else
  { // secs
    Com_sprintf( buf, bufsize, "%d sec", time );
  }
}

// FIXME: move to ui_shared.c?
void Text_PaintCenter( float x, float y, float scale, vec4_t color, const char *text, float adjust )
{
  int len = UI_Text_Width( text, scale );
  UI_Text_Paint( x - len / 2, y, scale, color, text, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE );
}

void Text_PaintCenter_AutoWrapped( float x, float y, float xmax, float ystep, float scale, vec4_t color, const char *str, float adjust )
{
  int width;
  char *s1, *s2, *s3;
  char c_bcp;
  char buf[1024];

  if( !str || str[0] == '\0' )
    return;

  Q_strncpyz( buf, str, sizeof( buf ) );

  s1 = s2 = s3 = buf;

  while( 1 )
  {
    do
      s3++;
    while( *s3 != ' ' && *s3 != '\0' );

    c_bcp = *s3;

    *s3 = '\0';

    width = UI_Text_Width( s1, scale );

    *s3 = c_bcp;

    if( width > xmax )
    {
      if( s1 == s2 )
      {
        // fuck, don't have a clean cut, we'll overflow
        s2 = s3;
      }

      *s2 = '\0';
      Text_PaintCenter( x, y, scale, color, s1, adjust );
      y += ystep;

      if( c_bcp == '\0' )
      {
        // that was the last word
        // we could start a new loop, but that wouldn't be much use
        // even if the word is too long, we would overflow it (see above)
        // so just print it now if needed
        s2++;

        if( *s2 != '\0' ) // if we are printing an overflowing line we have s2 == s3
          Text_PaintCenter( x, y, scale, color, s2, adjust );

        break;
      }

      s2++;
      s1 = s2;
      s3 = s2;
    }
    else
    {
      s2 = s3;

      if( c_bcp == '\0' ) // we reached the end
      {
        Text_PaintCenter( x, y, scale, color, s1, adjust );
        break;
      }
    }
  }
}


static void UI_DisplayDownloadInfo( const char *downloadName, float centerPoint, float yStart, float scale )
{
  static char dlText[]  = "Downloading:";
  static char etaText[] = "Estimated time left:";
  static char xferText[]  = "Transfer rate:";

  int downloadSize, downloadCount, downloadTime;
  char dlSizeBuf[64], totalSizeBuf[64], xferRateBuf[64], dlTimeBuf[64];
  int xferRate;
  int leftWidth;
  const char *s;

  downloadSize = trap_Cvar_VariableValue( "cl_downloadSize" );
  downloadCount = trap_Cvar_VariableValue( "cl_downloadCount" );
  downloadTime = trap_Cvar_VariableValue( "cl_downloadTime" );

  leftWidth = 320;

  UI_SetColor( colorWhite );
  Text_PaintCenter( centerPoint, yStart + 112, scale, colorWhite, dlText, 0 );
  Text_PaintCenter( centerPoint, yStart + 192, scale, colorWhite, etaText, 0 );
  Text_PaintCenter( centerPoint, yStart + 248, scale, colorWhite, xferText, 0 );

  if( downloadSize > 0 )
    s = va( "%s (%d%%)", downloadName, ( int )( ( float )downloadCount * 100.0f / downloadSize ) );
  else
    s = downloadName;

  Text_PaintCenter( centerPoint, yStart + 136, scale, colorWhite, s, 0 );

  UI_ReadableSize( dlSizeBuf,   sizeof dlSizeBuf,   downloadCount );
  UI_ReadableSize( totalSizeBuf,  sizeof totalSizeBuf,  downloadSize );

  if( downloadCount < 4096 || !downloadTime )
  {
    Text_PaintCenter( leftWidth, yStart + 216, scale, colorWhite, "estimating", 0 );
    Text_PaintCenter( leftWidth, yStart + 160, scale, colorWhite, va( "(%s of %s copied)", dlSizeBuf, totalSizeBuf ), 0 );
  }
  else
  {
    if( ( uiInfo.uiDC.realTime - downloadTime ) / 1000 )
      xferRate = downloadCount / ( ( uiInfo.uiDC.realTime - downloadTime ) / 1000 );
    else
      xferRate = 0;

    UI_ReadableSize( xferRateBuf, sizeof xferRateBuf, xferRate );

    // Extrapolate estimated completion time

    if( downloadSize && xferRate )
    {
      int n = downloadSize / xferRate; // estimated time for entire d/l in secs

      // We do it in K (/1024) because we'd overflow around 4MB
      UI_PrintTime ( dlTimeBuf, sizeof dlTimeBuf,
          ( n - ( ( ( downloadCount / 1024 ) * n ) / ( downloadSize / 1024 ) ) ) * 1000 );

      Text_PaintCenter( leftWidth, yStart + 216, scale, colorWhite, dlTimeBuf, 0 );
      Text_PaintCenter( leftWidth, yStart + 160, scale, colorWhite, va( "(%s of %s copied)", dlSizeBuf, totalSizeBuf ), 0 );
    }
    else
    {
      Text_PaintCenter( leftWidth, yStart + 216, scale, colorWhite, "estimating", 0 );

      if( downloadSize )
        Text_PaintCenter( leftWidth, yStart + 160, scale, colorWhite, va( "(%s of %s copied)", dlSizeBuf, totalSizeBuf ), 0 );
      else
        Text_PaintCenter( leftWidth, yStart + 160, scale, colorWhite, va( "(%s copied)", dlSizeBuf ), 0 );
    }

    if( xferRate )
      Text_PaintCenter( leftWidth, yStart + 272, scale, colorWhite, va( "%s/Sec", xferRateBuf ), 0 );
  }
}

/*
========================
UI_DrawConnectScreen
========================
*/
void UI_DrawConnectScreen( qboolean overlay )
{
  char      *s;
  uiClientState_t cstate;
  char      info[MAX_INFO_VALUE];
  char text[256];
  float centerPoint, yStart, scale;

  menuDef_t *menu = Menus_FindByName( "Connect" );


  if( !overlay && menu )
    Menu_Paint( menu, qtrue );

  if( !overlay )
  {
    centerPoint = 320;
    yStart = 130;
    scale = 0.5f;
  }
  else
  {
    centerPoint = 320;
    yStart = 32;
    scale = 0.6f;
    return;
  }

  // see what information we should display
  trap_GetClientState( &cstate );

  info[0] = '\0';

  if( trap_GetConfigString( CS_SERVERINFO, info, sizeof( info ) ) )
    Text_PaintCenter( centerPoint, yStart, scale, colorWhite, va( "Loading %s", Info_ValueForKey( info, "mapname" ) ), 0 );

  if( !Q_stricmp( cstate.servername, "localhost" ) )
    Text_PaintCenter( centerPoint, yStart + 48, scale, colorWhite,
                      "Starting up...", ITEM_TEXTSTYLE_SHADOWEDMORE );
  else
  {
    Com_sprintf( text, sizeof( text ), "Connecting to %s", cstate.servername );
    Text_PaintCenter( centerPoint, yStart + 48, scale, colorWhite, text , ITEM_TEXTSTYLE_SHADOWEDMORE );
  }


  // display global MOTD at bottom
  Text_PaintCenter( centerPoint, 600, scale, colorWhite, Info_ValueForKey( cstate.updateInfoString, "motd" ), 0 );

  // print any server info (server full, bad version, etc)
  if( cstate.connState < CA_CONNECTED )
    Text_PaintCenter( centerPoint, yStart + 176, scale, colorWhite, cstate.messageString, 0 );

  if( lastConnState > cstate.connState )
    lastLoadingText[0] = '\0';

  lastConnState = cstate.connState;

  switch( cstate.connState )
  {
    case CA_CONNECTING:
      s = va( "Awaiting connection...%i", cstate.connectPacketCount );
      break;

    case CA_CHALLENGING:
      s = va( "Awaiting challenge...%i", cstate.connectPacketCount );
      break;

    case CA_CONNECTED:
      {
        char downloadName[MAX_INFO_VALUE];
        int prompt = trap_Cvar_VariableValue( "com_downloadPrompt" );
        
        if( prompt & DLP_SHOW ) {
          Com_Printf("Opening download prompt...\n");
          trap_Key_SetCatcher( KEYCATCH_UI );
          Menus_ActivateByName("download_popmenu");
          trap_Cvar_Set( "com_downloadPrompt", "0" );
        }
        
        trap_Cvar_VariableStringBuffer( "cl_downloadName", downloadName, sizeof( downloadName ) );

        if( *downloadName )
        {
          UI_DisplayDownloadInfo( downloadName, centerPoint, yStart, scale );
          return;
        }
      }

      s = "Awaiting gamestate...";
      break;

    case CA_LOADING:
      return;

    case CA_PRIMED:
      return;

    default:
      return;
  }


  if( Q_stricmp( cstate.servername, "localhost" ) )
    Text_PaintCenter( centerPoint, yStart + 80, scale, colorWhite, s, 0 );

  // password required / connection rejected information goes here
}

/*
=================
UI_RegisterCvars
=================
*/
void UI_RegisterCvars( void )
{
  int     i;
  cvarTable_t *cv;

  for( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ )
    trap_Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags );
}

/*
=================
UI_UpdateCvars
=================
*/
void UI_UpdateCvars( void )
{
  int     i;
  cvarTable_t *cv;

  for( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ )
    trap_Cvar_Update( cv->vmCvar );
}

/*
=================
UI_UpdateNews
=================
*/
void UI_UpdateNews( qboolean begin )
{
  char newsString[ MAX_NEWS_STRING ];
  const char *c;
  const char *wrapped;
  int line = 0;
  int linePos = 0;
  qboolean finished;

  if( begin && !uiInfo.newsInfo.refreshActive ) {
    uiInfo.newsInfo.refreshtime = uiInfo.uiDC.realTime + 10000;
    uiInfo.newsInfo.refreshActive = qtrue;
  }
  else if( !uiInfo.newsInfo.refreshActive ) // do nothing
    return; 
  else if( uiInfo.uiDC.realTime > uiInfo.newsInfo.refreshtime ) {
    strcpy( uiInfo.newsInfo.text[ 0 ], 
      "^1Error: Timed out while contacting the server.");
    uiInfo.newsInfo.numLines = 1;
    return; 
  }

  // start the news fetching
  finished = trap_GetNews( begin );

  // parse what comes back. Parse newlines and otherwise chop when necessary
  trap_Cvar_VariableStringBuffer( "cl_newsString", newsString, 
    sizeof( newsString ) );

  // FIXME remove magic width constant
  wrapped = Item_Text_Wrap( newsString, 0.25f, 325 * uiInfo.uiDC.aspectScale );

  for( c = wrapped; *c != '\0'; ++c ) {
    if( linePos == (MAX_NEWS_LINEWIDTH - 1) || *c == '\n' ) {
      uiInfo.newsInfo.text[ line ][ linePos ] = '\0';

      if( line == ( MAX_NEWS_LINES  - 1 ) )
        break;

      linePos = 0;
      line++;

      if( *c != '\n' ) {
        uiInfo.newsInfo.text[ line ][ linePos ] = *c;
        linePos++;
      }
    } else if( isprint( *c ) ) {
      uiInfo.newsInfo.text[ line ][ linePos ] = *c;
      linePos++;
    }
  }

  uiInfo.newsInfo.text[ line ] [linePos ] = '\0';
  uiInfo.newsInfo.numLines = line + 1;

  if( finished )
    uiInfo.newsInfo.refreshActive = qfalse;
}

