qmenu.c File Reference

#include <string.h>
#include <ctype.h>
#include "client.h"
#include "qmenu.h"

Go to the source code of this file.

Macros
#define	RCOLUMN_OFFSET   16 * vid_hudscale->value
#define	LCOLUMN_OFFSET   -16 * vid_hudscale->value
#define	VID_WIDTH   viddef.width
#define	VID_HEIGHT   viddef.height
#define	Draw_Char   re.DrawChar
#define	Draw_Fill   re.DrawFill
#define	SLIDER_RANGE   10

Functions
static void	Action_DoEnter (menuaction_s *a)
static void	Action_Draw (menuaction_s *a)
static void	Menu_DrawStatusBar (const char *string)
static void	Menulist_DoEnter (menulist_s *l)
static void	MenuList_Draw (menulist_s *l)
static void	Separator_Draw (menuseparator_s *s)
static void	Slider_DoSlide (menuslider_s *s, int dir)
static void	Slider_Draw (menuslider_s *s)
static void	SpinControl_DoEnter (menulist_s *s)
static void	SpinControl_Draw (menulist_s *s)
static void	SpinControl_DoSlide (menulist_s *s, int dir)
qboolean	Field_DoEnter (menufield_s *f)
void	Field_Draw (menufield_s *f)
qboolean	Field_Key (menufield_s *f, int key)
void	Menu_AddItem (menuframework_s *menu, void *item)
void	Menu_AdjustCursor (menuframework_s *m, int dir)
void	Menu_Center (menuframework_s *menu)
void	Menu_Draw (menuframework_s *menu)
void	Menu_DrawString (int x, int y, const char *string)
void	Menu_DrawStringDark (int x, int y, const char *string)
void	Menu_DrawStringR2L (int x, int y, const char *string)
void	Menu_DrawStringR2LDark (int x, int y, const char *string)
void *	Menu_ItemAtCursor (menuframework_s *m)
qboolean	Menu_SelectItem (menuframework_s *s)
void	Menu_SetStatusBar (menuframework_s *m, const char *string)
void	Menu_SlideItem (menuframework_s *s, int dir)
int	Menu_TallySlots (menuframework_s *menu)

Variables
refexport_t	re
viddef_t	viddef
cvar_t *	vid_hudscale

Macro Definition Documentation

Draw_Char

#define Draw_Char   re.DrawChar

Definition at line 48 of file qmenu.c.

Draw_Fill

#define Draw_Fill   re.DrawFill

Definition at line 49 of file qmenu.c.

LCOLUMN_OFFSET

#define LCOLUMN_OFFSET   -16 * vid_hudscale->value

Definition at line 39 of file qmenu.c.

RCOLUMN_OFFSET

#define RCOLUMN_OFFSET   16 * vid_hudscale->value

Definition at line 38 of file qmenu.c.

SLIDER_RANGE

#define SLIDER_RANGE   10

Definition at line 605 of file qmenu.c.

VID_HEIGHT

#define VID_HEIGHT   viddef.height

Definition at line 46 of file qmenu.c.

VID_WIDTH

#define VID_WIDTH   viddef.width

Definition at line 45 of file qmenu.c.

Function Documentation

Action_DoEnter()

void Action_DoEnter ( menuaction_s *  a )

static

Definition at line 51 of file qmenu.c.

{
    if ( a->generic.callback )
        a->generic.callback( a );
}

Referenced by Menu_SelectItem().

Action_Draw()

void Action_Draw ( menuaction_s *  a )

static

Definition at line 57 of file qmenu.c.

{
    if ( a->generic.flags & QMF_LEFT_JUSTIFY )
    {
        if ( a->generic.flags & QMF_GRAYED )
            Menu_DrawStringDark( a->generic.x + a->generic.parent->x + LCOLUMN_OFFSET, a->generic.y + a->generic.parent->y, a->generic.name );
        else
            Menu_DrawString( a->generic.x + a->generic.parent->x + LCOLUMN_OFFSET, a->generic.y + a->generic.parent->y, a->generic.name );
    }
    else
    {
        if ( a->generic.flags & QMF_GRAYED )
            Menu_DrawStringR2LDark( a->generic.x + a->generic.parent->x + LCOLUMN_OFFSET, a->generic.y + a->generic.parent->y, a->generic.name );
        else
            Menu_DrawStringR2L( a->generic.x + a->generic.parent->x + LCOLUMN_OFFSET, a->generic.y + a->generic.parent->y, a->generic.name );
    }
    if ( a->generic.ownerdraw )
        a->generic.ownerdraw( a );
}

Referenced by Menu_Draw().

Field_DoEnter()

qboolean Field_DoEnter

(

menufield_s *

f

)

Definition at line 77 of file qmenu.c.

{
    if ( f->generic.callback )
    {
        f->generic.callback( f );
        return true;
    }
    return false;
}

Referenced by Menu_SelectItem().

Field_Draw()

void Field_Draw

(

menufield_s *

f

)

Definition at line 87 of file qmenu.c.

{
    int i;
    char tempbuffer[128]="";
 
    if ( f->generic.name )
        Menu_DrawStringR2LDark( f->generic.x + f->generic.parent->x + LCOLUMN_OFFSET, f->generic.y + f->generic.parent->y, f->generic.name );
 
    strncpy( tempbuffer, f->buffer + f->visible_offset, f->visible_length );
 
    Draw_Char( f->generic.x + f->generic.parent->x + 16 * vid_hudscale->value, f->generic.y + f->generic.parent->y - 4 * vid_hudscale->value, 18 );
    Draw_Char( f->generic.x + f->generic.parent->x + 16 * vid_hudscale->value, f->generic.y + f->generic.parent->y + 4 * vid_hudscale->value, 24 );
 
    Draw_Char( f->generic.x + f->generic.parent->x + 24 * vid_hudscale->value + f->visible_length * 8 * vid_hudscale->value, f->generic.y + f->generic.parent->y - 4 * vid_hudscale->value, 20 );
    Draw_Char( f->generic.x + f->generic.parent->x + 24 * vid_hudscale->value + f->visible_length * 8 * vid_hudscale->value, f->generic.y + f->generic.parent->y + 4 * vid_hudscale->value, 26 );
 
    for ( i = 0; i < f->visible_length; i++ )
    {
        Draw_Char( f->generic.x + f->generic.parent->x + 24 * vid_hudscale->value + i * 8 * vid_hudscale->value, f->generic.y + f->generic.parent->y - 4 * vid_hudscale->value, 19 );
        Draw_Char( f->generic.x + f->generic.parent->x + 24 * vid_hudscale->value + i * 8 * vid_hudscale->value, f->generic.y + f->generic.parent->y + 4 * vid_hudscale->value, 25 );
    }
 
    Menu_DrawString( f->generic.x + f->generic.parent->x + 24 * vid_hudscale->value, f->generic.y + f->generic.parent->y, tempbuffer );
 
    if ( Menu_ItemAtCursor( f->generic.parent ) == f )
    {
        int offset;
 
        if ( f->visible_offset )
            offset = f->visible_length;
        else
            offset = f->cursor;
 
        if ( ( ( int ) ( Sys_Milliseconds() / 250 ) ) & 1 )
        {
            Draw_Char( f->generic.x + f->generic.parent->x + ( offset + 2 ) * 8 * vid_hudscale->value + 8 * vid_hudscale->value,
                       f->generic.y + f->generic.parent->y,
                       11 );
        }
        else
        {
            Draw_Char( f->generic.x + f->generic.parent->x + ( offset + 2 ) * 8 * vid_hudscale->value + 8 * vid_hudscale->value,
                       f->generic.y + f->generic.parent->y,
                       ' ' );
        }
    }
}

Referenced by Menu_Draw().

Field_Key()

qboolean Field_Key	(	menufield_s *	f,
		int	key
	)

Definition at line 135 of file qmenu.c.

{
    extern int keydown[];
 
    switch ( key )
    {
    case K_KP_SLASH:
        key = '/';
        break;
    case K_KP_MINUS:
        key = '-';
        break;
    case K_KP_PLUS:
        key = '+';
        break;
    case K_KP_HOME:
        key = '7';
        break;
    case K_KP_UPARROW:
        key = '8';
        break;
    case K_KP_PGUP:
        key = '9';
        break;
    case K_KP_LEFTARROW:
        key = '4';
        break;
    case K_KP_5:
        key = '5';
        break;
    case K_KP_RIGHTARROW:
        key = '6';
        break;
    case K_KP_END:
        key = '1';
        break;
    case K_KP_DOWNARROW:
        key = '2';
        break;
    case K_KP_PGDN:
        key = '3';
        break;
    case K_KP_INS:
        key = '0';
        break;
    case K_KP_DEL:
        key = '.';
        break;
    }
 
    if ( key > 127 )
    {
        switch ( key )
        {
        case K_DEL:
        default:
            return false;
        }
    }
 
    /*
    ** support pasting from the clipboard
    */
    if ( ( toupper( key ) == 'V' && keydown[K_CTRL] ) ||
         ( ( ( key == K_INS ) || ( key == K_KP_INS ) ) && keydown[K_SHIFT] ) )
    {
        char *cbd;
        
        if ( ( cbd = Sys_GetClipboardData() ) != 0 )
        {
            strtok( cbd, "\n\r\b" );
 
            strncpy( f->buffer, cbd, f->length - 1 );
            f->cursor = (int)strlen( f->buffer );
            f->visible_offset = f->cursor - f->visible_length;
            if ( f->visible_offset < 0 )
                f->visible_offset = 0;
 
            free( cbd );
        }
        return true;
    }
 
    switch ( key )
    {
    case K_KP_LEFTARROW:
    case K_LEFTARROW:
    case K_BACKSPACE:
        if ( f->cursor > 0 )
        {
            memmove( &f->buffer[f->cursor-1], &f->buffer[f->cursor], strlen( &f->buffer[f->cursor] ) + 1 );
            f->cursor--;
 
            if ( f->visible_offset )
            {
                f->visible_offset--;
            }
        }
        break;
 
    case K_KP_DEL:
    case K_DEL:
        memmove( &f->buffer[f->cursor], &f->buffer[f->cursor+1], strlen( &f->buffer[f->cursor+1] ) + 1 );
        break;
 
    case K_KP_ENTER:
    case K_ENTER:
    case K_ESCAPE:
    case K_TAB:
        return false;
 
    case K_SPACE:
    default:
        if ( !isdigit( key ) && ( f->generic.flags & QMF_NUMBERSONLY ) )
            return false;
 
        if ( f->cursor < f->length )
        {
            f->buffer[f->cursor++] = key;
            f->buffer[f->cursor] = 0;
 
            if ( f->cursor > f->visible_length )
            {
                f->visible_offset++;
            }
        }
    }
 
    return true;
}

Referenced by Default_MenuKey().

Menu_AddItem()

void Menu_AddItem	(	menuframework_s *	menu,
		void *	item
	)

Definition at line 266 of file qmenu.c.

{
    if ( menu->nitems == 0 )
        menu->nslots = 0;
 
    if ( menu->nitems < MAXMENUITEMS )
    {
        menu->items[menu->nitems] = item;
        ( ( menucommon_s * ) menu->items[menu->nitems] )->parent = menu;
        menu->nitems++;
    }
 
    menu->nslots = Menu_TallySlots( menu );
}

Referenced by AddressBook_MenuInit(), DMOptions_MenuInit(), DownloadOptions_MenuInit(), Game_MenuInit(), JoinServer_MenuInit(), Keys_MenuInit(), LoadGame_MenuInit(), Multiplayer_MenuInit(), Options_MenuInit(), PlayerConfig_MenuInit(), SaveGame_MenuInit(), StartServer_MenuInit(), and VID_MenuInit().

Menu_AdjustCursor()

void Menu_AdjustCursor	(	menuframework_s *	m,
		int	dir
	)

Definition at line 288 of file qmenu.c.

{
    menucommon_s *citem;
 
    /*
    ** see if it's in a valid spot
    */
    if ( m->cursor >= 0 && m->cursor < m->nitems )
    {
        if ( ( citem = Menu_ItemAtCursor( m ) ) != 0 )
        {
            if ( citem->type != MTYPE_SEPARATOR )
                return;
        }
    }
 
    /*
    ** it's not in a valid spot, so crawl in the direction indicated until we
    ** find a valid spot
    */
    if ( dir == 1 )
    {
        while ( 1 )
        {
            citem = Menu_ItemAtCursor( m );
            if ( citem )
                if ( citem->type != MTYPE_SEPARATOR )
                    break;
            m->cursor += dir;
            if ( m->cursor >= m->nitems )
                m->cursor = 0;
        }
    }
    else
    {
        while ( 1 )
        {
            citem = Menu_ItemAtCursor( m );
            if ( citem )
                if ( citem->type != MTYPE_SEPARATOR )
                    break;
            m->cursor += dir;
            if ( m->cursor < 0 )
                m->cursor = m->nitems - 1;
        }
    }
}

Referenced by Default_MenuKey(), Game_MenuDraw(), Keys_MenuDraw(), Multiplayer_MenuDraw(), Options_MenuDraw(), SaveGame_MenuDraw(), VID_MenuDraw(), and VID_MenuKey().

Menu_Center()

void Menu_Center

(

menuframework_s *

menu

)

Definition at line 336 of file qmenu.c.

{
    int height;
 
    height = ( ( menucommon_s * ) menu->items[menu->nitems-1])->y;
    height += 10;
 
    menu->y = ( VID_HEIGHT - height ) / 2;
}

Referenced by DMOptions_MenuInit(), DownloadOptions_MenuInit(), Game_MenuInit(), JoinServer_MenuInit(), Keys_MenuInit(), Multiplayer_MenuInit(), StartServer_MenuInit(), and VID_MenuInit().

Menu_Draw()

void Menu_Draw

(

menuframework_s *

menu

)

Definition at line 346 of file qmenu.c.

{
    int i;
    menucommon_s *item;
 
    /*
    ** draw contents
    */
    for ( i = 0; i < menu->nitems; i++ )
    {
        switch ( ( ( menucommon_s * ) menu->items[i] )->type )
        {
        case MTYPE_FIELD:
            Field_Draw( ( menufield_s * ) menu->items[i] );
            break;
        case MTYPE_SLIDER:
            Slider_Draw( ( menuslider_s * ) menu->items[i] );
            break;
        case MTYPE_LIST:
            MenuList_Draw( ( menulist_s * ) menu->items[i] );
            break;
        case MTYPE_SPINCONTROL:
            SpinControl_Draw( ( menulist_s * ) menu->items[i] );
            break;
        case MTYPE_ACTION:
            Action_Draw( ( menuaction_s * ) menu->items[i] );
            break;
        case MTYPE_SEPARATOR:
            Separator_Draw( ( menuseparator_s * ) menu->items[i] );
            break;
        }
    }
 
    item = Menu_ItemAtCursor( menu );
 
    if ( item && item->cursordraw )
    {
        item->cursordraw( item );
    }
    else if ( menu->cursordraw )
    {
        menu->cursordraw( menu );
    }
    else if ( item && item->type != MTYPE_FIELD )
    {
        if ( item->flags & QMF_LEFT_JUSTIFY )
        {
            Draw_Char( menu->x + item->x - 24*vid_hudscale->value + item->cursor_offset*vid_hudscale->value, menu->y + item->y, 12 + ( ( int ) ( Sys_Milliseconds()/250 ) & 1 ) );
        }
        else
        {
            Draw_Char( menu->x + item->cursor_offset*vid_hudscale->value, menu->y + item->y, 12 + ( ( int ) ( Sys_Milliseconds()/250 ) & 1 ) );
        }
    }
 
    if ( item )
    {
        if ( item->statusbarfunc )
            item->statusbarfunc( ( void * ) item );
        else if ( item->statusbar )
            Menu_DrawStatusBar( item->statusbar );
        else
            Menu_DrawStatusBar( menu->statusbar );
 
    }
    else
    {
        Menu_DrawStatusBar( menu->statusbar );
    }
}

Referenced by AddressBook_MenuDraw(), DMOptions_MenuDraw(), DownloadOptions_MenuDraw(), Game_MenuDraw(), JoinServer_MenuDraw(), Keys_MenuDraw(), LoadGame_MenuDraw(), Multiplayer_MenuDraw(), Options_MenuDraw(), PlayerConfig_MenuDraw(), SaveGame_MenuDraw(), StartServer_MenuDraw(), and VID_MenuDraw().

Menu_DrawStatusBar()

void Menu_DrawStatusBar ( const char *  string )

static

Definition at line 417 of file qmenu.c.

{
    if ( string )
    {
        int l = (int)strlen( string );
        int maxcol = VID_WIDTH / (8*vid_hudscale->value);
        int col = maxcol / 2 - l / 2;
 
        Draw_Fill( 0, VID_HEIGHT-8*vid_hudscale->value, VID_WIDTH, 8*vid_hudscale->value, 4 );
        Menu_DrawString( col*8*vid_hudscale->value, VID_HEIGHT - 8*vid_hudscale->value, string );
    }
    else
    {
        Draw_Fill( 0, VID_HEIGHT-8*vid_hudscale->value, VID_WIDTH, 8*vid_hudscale->value, 0 );
    }
}

Referenced by Menu_Draw().

Menu_DrawString()

void Menu_DrawString	(	int	x,
		int	y,
		const char *	string
	)

Definition at line 434 of file qmenu.c.

{
    unsigned i;
 
    for ( i = 0; i < strlen( string ); i++ )
    {
        Draw_Char( ( x + i*8*vid_hudscale->value ), y, string[i] );
    }
}

Referenced by Action_Draw(), DrawKeyBindingFunc(), Field_Draw(), Menu_DrawStatusBar(), and SpinControl_Draw().

Menu_DrawStringDark()

void Menu_DrawStringDark	(	int	x,
		int	y,
		const char *	string
	)

Definition at line 444 of file qmenu.c.

{
    unsigned i;
 
    for ( i = 0; i < strlen( string ); i++ )
    {
        Draw_Char( ( x + i*8*vid_hudscale->value ), y, string[i] + 128 );
    }
}

Referenced by Action_Draw().

Menu_DrawStringR2L()

void Menu_DrawStringR2L	(	int	x,
		int	y,
		const char *	string
	)

Definition at line 454 of file qmenu.c.

{
    unsigned i;
 
    for ( i = 0; i < strlen( string ); i++ )
    {
        Draw_Char( ( x - i*8*vid_hudscale->value), y, string[strlen(string)-i-1] );
    }
}

Referenced by Action_Draw().

Menu_DrawStringR2LDark()

void Menu_DrawStringR2LDark	(	int	x,
		int	y,
		const char *	string
	)

Definition at line 464 of file qmenu.c.

{
    unsigned i;
 
    for ( i = 0; i < strlen( string ); i++ )
    {
        Draw_Char( ( x - i*8*vid_hudscale->value ), y, string[strlen(string)-i-1]+128 );
    }
}

Referenced by Action_Draw(), Field_Draw(), MenuList_Draw(), Separator_Draw(), Slider_Draw(), and SpinControl_Draw().

Menu_ItemAtCursor()

void* Menu_ItemAtCursor

(

menuframework_s *

m

)

Definition at line 474 of file qmenu.c.

{
    if ( m->cursor < 0 || m->cursor >= m->nitems )
        return 0;
 
    return m->items[m->cursor];
}

Referenced by Default_MenuKey(), Field_Draw(), Keys_MenuKey(), Menu_AdjustCursor(), Menu_Draw(), Menu_SelectItem(), and Menu_SlideItem().

Menu_SelectItem()

qboolean Menu_SelectItem

(

menuframework_s *

s

)

Definition at line 482 of file qmenu.c.

{
    menucommon_s *item = ( menucommon_s * ) Menu_ItemAtCursor( s );
 
    if ( item )
    {
        switch ( item->type )
        {
        case MTYPE_FIELD:
            return Field_DoEnter( ( menufield_s * ) item ) ;
        case MTYPE_ACTION:
            Action_DoEnter( ( menuaction_s * ) item );
            return true;
        case MTYPE_LIST:
//          Menulist_DoEnter( ( menulist_s * ) item );
            return false;
        case MTYPE_SPINCONTROL:
//          SpinControl_DoEnter( ( menulist_s * ) item );
            return false;
        }
    }
    return false;
}

Referenced by Default_MenuKey(), and VID_MenuKey().

Menu_SetStatusBar()

void Menu_SetStatusBar	(	menuframework_s *	m,
		const char *	string
	)

Definition at line 506 of file qmenu.c.

{
    m->statusbar = string;
}

Referenced by DMOptions_MenuInit(), KeyBindingFunc(), Keys_MenuInit(), Keys_MenuKey(), M_Menu_PlayerConfig_f(), and Multiplayer_MenuInit().

Menu_SlideItem()

void Menu_SlideItem	(	menuframework_s *	s,
		int	dir
	)

Definition at line 511 of file qmenu.c.

{
    menucommon_s *item = ( menucommon_s * ) Menu_ItemAtCursor( s );
 
    if ( item )
    {
        switch ( item->type )
        {
        case MTYPE_SLIDER:
            Slider_DoSlide( ( menuslider_s * ) item, dir );
            break;
        case MTYPE_SPINCONTROL:
            SpinControl_DoSlide( ( menulist_s * ) item, dir );
            break;
        }
    }
}

Referenced by Default_MenuKey(), and VID_MenuKey().

Menu_TallySlots()

int Menu_TallySlots

(

menuframework_s *

menu

)

Definition at line 529 of file qmenu.c.

{
    int i;
    int total = 0;
 
    for ( i = 0; i < menu->nitems; i++ )
    {
        if ( ( ( menucommon_s * ) menu->items[i] )->type == MTYPE_LIST )
        {
            int nitems = 0;
            const char **n = ( ( menulist_s * ) menu->items[i] )->itemnames;
 
            while (*n)
                nitems++, n++;
 
            total += nitems;
        }
        else
        {
            total++;
        }
    }
 
    return total;
}

Referenced by Menu_AddItem().

Menulist_DoEnter()

void Menulist_DoEnter ( menulist_s *  l )

static

Definition at line 555 of file qmenu.c.

{
    int start;
 
    start = l->generic.y / 10 + 1;
 
    l->curvalue = l->generic.parent->cursor - start;
 
    if ( l->generic.callback )
        l->generic.callback( l );
}

MenuList_Draw()

void MenuList_Draw ( menulist_s *  l )

static

Definition at line 567 of file qmenu.c.

{
    const char **n;
    int y = 0;
 
    Menu_DrawStringR2LDark( l->generic.x + l->generic.parent->x + LCOLUMN_OFFSET, l->generic.y + l->generic.parent->y, l->generic.name );
 
    n = l->itemnames;
 
    Draw_Fill( l->generic.x - 112 + l->generic.parent->x, l->generic.parent->y + l->generic.y + l->curvalue*10 + 10, 128, 10, 16 );
    while ( *n )
    {
        Menu_DrawStringR2LDark( l->generic.x + l->generic.parent->x + LCOLUMN_OFFSET, l->generic.y + l->generic.parent->y + y + 10, *n );
 
        n++;
        y += 10;
    }
}

Referenced by Menu_Draw().

Separator_Draw()

void Separator_Draw ( menuseparator_s *  s )

static

Definition at line 586 of file qmenu.c.

{
    if ( s->generic.name )
        Menu_DrawStringR2LDark( s->generic.x + s->generic.parent->x, s->generic.y + s->generic.parent->y, s->generic.name );
}

Referenced by Menu_Draw().

Slider_DoSlide()

void Slider_DoSlide ( menuslider_s *  s, int  dir  )

static

Definition at line 592 of file qmenu.c.

{
    s->curvalue += dir;
 
    if ( s->curvalue > s->maxvalue )
        s->curvalue = s->maxvalue;
    else if ( s->curvalue < s->minvalue )
        s->curvalue = s->minvalue;
 
    if ( s->generic.callback )
        s->generic.callback( s );
}

Referenced by Menu_SlideItem().

Slider_Draw()

void Slider_Draw ( menuslider_s *  s )

static

Definition at line 607 of file qmenu.c.

{
    int i;
 
    Menu_DrawStringR2LDark( s->generic.x + s->generic.parent->x + LCOLUMN_OFFSET,
                        s->generic.y + s->generic.parent->y, 
                        s->generic.name );
 
    s->range = ( s->curvalue - s->minvalue ) / ( float ) ( s->maxvalue - s->minvalue );
 
    if ( s->range < 0)
        s->range = 0;
    if ( s->range > 1)
        s->range = 1;
    Draw_Char( s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET, s->generic.y + s->generic.parent->y, 128);
    for ( i = 0; i < SLIDER_RANGE; i++ )
        Draw_Char( RCOLUMN_OFFSET + s->generic.x + i*8*vid_hudscale->value + s->generic.parent->x + 8*vid_hudscale->value, s->generic.y + s->generic.parent->y, 129);
    Draw_Char( RCOLUMN_OFFSET + s->generic.x + i*8*vid_hudscale->value + s->generic.parent->x + 8*vid_hudscale->value, s->generic.y + s->generic.parent->y, 130);
    Draw_Char( ( int ) ( 8*vid_hudscale->value + RCOLUMN_OFFSET + s->generic.parent->x + s->generic.x + (SLIDER_RANGE-1)*8*vid_hudscale->value * s->range ), s->generic.y + s->generic.parent->y, 131);
}

Referenced by Menu_Draw().

SpinControl_DoEnter()

void SpinControl_DoEnter ( menulist_s *  s )

static

Definition at line 628 of file qmenu.c.

{
    s->curvalue++;
    if ( s->itemnames[s->curvalue] == 0 )
        s->curvalue = 0;
 
    if ( s->generic.callback )
        s->generic.callback( s );
}

SpinControl_DoSlide()

void SpinControl_DoSlide ( menulist_s *  s, int  dir  )

static

Definition at line 638 of file qmenu.c.

{
    s->curvalue += dir;
 
    if ( s->curvalue < 0 )
        s->curvalue = 0;
    else if ( s->itemnames[s->curvalue] == 0 )
        s->curvalue--;
 
    if ( s->generic.callback )
        s->generic.callback( s );
}

Referenced by Menu_SlideItem().

SpinControl_Draw()

void SpinControl_Draw ( menulist_s *  s )

static

Definition at line 651 of file qmenu.c.

{
    char buffer[100];
 
    if ( s->generic.name )
    {
        Menu_DrawStringR2LDark( s->generic.x + s->generic.parent->x + LCOLUMN_OFFSET, 
                            s->generic.y + s->generic.parent->y, 
                            s->generic.name );
    }
    if ( !strchr( s->itemnames[s->curvalue], '\n' ) )
    {
        Menu_DrawString( RCOLUMN_OFFSET + s->generic.x + s->generic.parent->x, s->generic.y + s->generic.parent->y, s->itemnames[s->curvalue] );
    }
    else
    {
        strcpy( buffer, s->itemnames[s->curvalue] );
        *strchr( buffer, '\n' ) = 0;
        Menu_DrawString( RCOLUMN_OFFSET + s->generic.x + s->generic.parent->x, s->generic.y + s->generic.parent->y, buffer );
        strcpy( buffer, strchr( s->itemnames[s->curvalue], '\n' ) + 1 );
        Menu_DrawString( RCOLUMN_OFFSET + s->generic.x + s->generic.parent->x, s->generic.y + s->generic.parent->y + 10 * vid_hudscale->value, buffer );
    }
}

Referenced by Menu_Draw().

Variable Documentation

re

refexport_t re

Definition at line 32 of file vid_dll.c.

Referenced by CL_AddPacketEntities(), CL_Disconnect(), CL_DrawInventory(), CL_LoadClientinfo(), CL_ParseConfigString(), CL_PrepRefresh(), CL_RegisterTEntModels(), Con_DrawConsole(), Con_DrawInput(), Con_DrawNotify(), DrawAltString(), DrawHUDString(), DrawString(), GetRefAPI(), Inv_DrawString(), KeyCursorDrawFunc(), M_Banner(), M_Credits_MenuDraw(), M_Draw(), M_DrawCharacter(), M_DrawCursor(), M_DrawPic(), M_Main_Draw(), M_Quit_Draw(), MainWndProc(), PlayerConfig_MenuDraw(), S_RegisterSexedModel(), SCR_DrawCenterString(), SCR_DrawCinematic(), SCR_DrawConsole(), SCR_DrawCrosshair(), SCR_DrawDebugGraph(), SCR_DrawField(), SCR_DrawLoading(), SCR_DrawNet(), SCR_DrawPause(), SCR_ExecuteLayoutString(), SCR_Sky_f(), SCR_StopCinematic(), SCR_TileClear(), SCR_TimeRefresh_f(), SCR_TouchPics(), SCR_UpdateScreen(), V_Gun_Model_f(), V_RenderView(), VID_FreeReflib(), VID_LoadRefresh(), VID_MenuDraw(), and VID_Shutdown().

vid_hudscale

cvar_t* vid_hudscale

Definition at line 48 of file vid_dll.c.

Referenced by Field_Draw(), Menu_Draw(), Menu_DrawStatusBar(), Menu_DrawString(), Menu_DrawStringDark(), Menu_DrawStringR2L(), Menu_DrawStringR2LDark(), Slider_Draw(), SpinControl_Draw(), and VID_NewWindow().

viddef

viddef_t viddef

Definition at line 54 of file vid_dll.c.