/*
===========================================================================
Copyright (C) 1997-2001 Id Software, Inc.

This file is part of Quake 2 source code.

Quake 2 source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake 2 source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Quake 2 source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

// menu_video.c -- the video options menu

#include "../client/client.h"
#include "ui_local.h"

extern cvar_t *vid_ref;

void Menu_Video_Init (void);

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

VIDEO MENU

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

static menuframework_s	s_video_menu;
static menulist_s		s_mode_list;
static menuseparator_s	s_customwidth_title;
static menuseparator_s	s_customheight_title;
static menufield_s		s_customwidth_field;
static menufield_s		s_customheight_field;
static menulist_s  		s_fs_box;
static menuslider_s		s_brightness_slider;
static menulist_s		s_texqual_box;
static menulist_s		s_texfilter_box;
static menulist_s		s_aniso_box;
static menulist_s		s_npot_mipmap_box;
static menulist_s		s_sgis_mipmap_box;
//static menulist_s  		s_texcompress_box;
static menulist_s  		s_vsync_box;
static menulist_s		s_refresh_box;	// Knightmare- refresh rate option
static menulist_s  		s_adjust_fov_box;
static menulist_s  		s_async_box;

static menuaction_s		s_advanced_action;
static menuaction_s		s_defaults_action;
static menuaction_s		s_apply_action;
static menuaction_s		s_backmain_action;

static void VidModeCallback (void *unused)
{
	s_customwidth_title.generic.flags	= (s_mode_list.curvalue != 0) ? QMF_HIDDEN : 0;
	s_customwidth_field.generic.flags	= (s_mode_list.curvalue != 0) ? (QMF_NUMBERSONLY|QMF_HIDDEN) : QMF_NUMBERSONLY;
	s_customheight_title.generic.flags	= (s_mode_list.curvalue != 0) ? QMF_HIDDEN : 0;
	s_customheight_field.generic.flags	= (s_mode_list.curvalue != 0) ? (QMF_NUMBERSONLY|QMF_HIDDEN) : QMF_NUMBERSONLY;
}

static void BrightnessCallback (void *s)
{
	// invert sense so greater = brighter, and scale to a range of 0.3 to 1.3
//	Cvar_SetValue( "vid_gamma", (1.3 - (s_brightness_slider.curvalue/20.0f)) );
	Cvar_SetValue( "vid_gamma", UI_MenuSlider_GetValue(&s_brightness_slider) );
}

static void VsyncCallback (void *unused)
{
	Cvar_SetValue( "r_swapinterval", s_vsync_box.curvalue);
}

static void AdjustFOVCallback (void *unused)
{
	Cvar_SetValue( "cl_widescreen_fov", s_adjust_fov_box.curvalue);
}

static void AsyncCallback (void *unused)
{
	Cvar_SetValue( "cl_async", s_async_box.curvalue);
}

static void AdvancedOptions (void *s)
{
	Menu_Video_Advanced_f ();
}

static void ResetVideoDefaults (void *unused)
{
	Cvar_SetToDefault ("vid_fullscreen");
	Cvar_SetToDefault ("vid_gamma");
	Cvar_SetToDefault ("r_mode");
	Cvar_SetToDefault ("r_texturemode");
	Cvar_SetToDefault ("r_anisotropic");
	Cvar_SetToDefault ("r_picmip");
	Cvar_SetToDefault ("r_nonpoweroftwo_mipmaps");
	Cvar_SetToDefault ("r_sgis_generatemipmap");
	Cvar_SetToDefault ("r_ext_texture_compression");
	Cvar_SetToDefault ("r_swapinterval");
	Cvar_SetToDefault ("r_displayrefresh");
	Cvar_SetToDefault ("cl_widescreen_fov");
	Cvar_SetToDefault ("cl_async");

	Cvar_SetToDefault ("r_modulate");
	Cvar_SetToDefault ("r_intensity");
	Cvar_SetToDefault ("r_rgbscale");
	Cvar_SetToDefault ("r_trans_lighting");
	Cvar_SetToDefault ("r_warp_lighting");
	Cvar_SetToDefault ("r_lightcutoff");
	Cvar_SetToDefault ("r_glass_envmaps");
	Cvar_SetToDefault ("r_solidalpha");
	Cvar_SetToDefault ("r_pixel_shader_warp");
	Cvar_SetToDefault ("r_waterwave");
	Cvar_SetToDefault ("r_caustics");
	Cvar_SetToDefault ("r_particle_overdraw");
	Cvar_SetToDefault ("r_bloom");
	Cvar_SetToDefault ("r_model_shading");
	Cvar_SetToDefault ("r_shadows");
	Cvar_SetToDefault ("r_stencilTwoSide");
	Cvar_SetToDefault ("r_shelltype");
	Cvar_SetToDefault ("r_celshading");
	Cvar_SetToDefault ("r_celshading_width");
//	Cvar_SetToDefault ("r_screenshot_jpeg");
	Cvar_SetToDefault ("r_screenshot_format");
	Cvar_SetToDefault ("r_screenshot_jpeg_quality");
	Cvar_SetToDefault ("r_saveshotsize");
	Cvar_SetToDefault ("r_font_upscale");

	Menu_Video_Init();
}

static void prepareVideoRefresh (void)
{
	// set the right mode for refresh
	Cvar_Set( "vid_ref", "gl" );
	Cvar_Set( "gl_driver", "opengl32" );

	// tell them they're modified so they refresh
	vid_ref->modified = true;
}


static void ApplyChanges (void *unused)
{
	int		temp, customW, customH;
	char	*customStr;

	temp = s_mode_list.curvalue;
	Cvar_SetValue( "r_mode", (temp == 0) ? -1 : temp + 2 ); // offset for eliminating < 640x480 modes
	if (temp == 0)	// Knightmare- use custom mode fields
	{
		customW  = atoi( s_customwidth_field.buffer );
		customH	= atoi( s_customheight_field.buffer );
		Cvar_SetValue( "r_customwidth", ClampCvar( 640, 99999, customW ) );
		Cvar_SetValue ("r_customheight", ClampCvar( 480, 99999, customH ) );

		// update fields in case values were clamped
		customStr = Cvar_VariableString("r_customwidth");
		Q_strncpyz (s_customwidth_field.buffer, sizeof(s_customwidth_field.buffer), customStr);
		s_customwidth_field.cursor = (int)strlen( customStr );
		
		customStr = Cvar_VariableString("r_customheight");
		Q_strncpyz (s_customheight_field.buffer, sizeof(s_customwidth_field.buffer), customStr);
		s_customheight_field.cursor = (int)strlen( customStr );
	}
	Cvar_SetValue( "vid_fullscreen", s_fs_box.curvalue );
	// invert sense so greater = brighter, and scale to a range of 0.3 to 1.3
//	Cvar_SetValue( "vid_gamma", (1.3 - (s_brightness_slider.curvalue/20.0)) );
	Cvar_SetValue( "vid_gamma", UI_MenuSlider_GetValue(&s_brightness_slider) );
	Cvar_SetValue( "r_picmip", 4-s_texqual_box.curvalue );

	// Knightmare- refesh rate option
	switch (s_refresh_box.curvalue)
	{
	case 14:
		Cvar_SetValue ("r_displayrefresh", 240);
		break;
	case 13:
		Cvar_SetValue ("r_displayrefresh", 180);
		break;
	case 12:
		Cvar_SetValue ("r_displayrefresh", 165);
		break;
	case 11:
		Cvar_SetValue ("r_displayrefresh", 160);
		break;
	case 10:
		Cvar_SetValue ("r_displayrefresh", 150);
		break;
	case 9:
		Cvar_SetValue ("r_displayrefresh", 144);
		break;
	case 8:
		Cvar_SetValue ("r_displayrefresh", 120);
		break;
	case 7:
		Cvar_SetValue ("r_displayrefresh", 110);
		break;
	case 6:
		Cvar_SetValue ("r_displayrefresh", 100);
		break;
	case 5:
		Cvar_SetValue ("r_displayrefresh", 85);
		break;
	case 4:
		Cvar_SetValue ("r_displayrefresh", 75);
		break;
	case 3:
		Cvar_SetValue ("r_displayrefresh", 72);
		break;
	case 2:
		Cvar_SetValue ("r_displayrefresh", 70);
		break;
	case 1:
		Cvar_SetValue ("r_displayrefresh", 60);
		break;
	case 0:
	default:
		Cvar_SetValue ("r_displayrefresh", 0);
		break;
	}

	if (s_texfilter_box.curvalue == 0)
		Cvar_Set("r_texturemode", "GL_LINEAR_MIPMAP_NEAREST");
	else if (s_texfilter_box.curvalue == 1)
		Cvar_Set("r_texturemode", "GL_LINEAR_MIPMAP_LINEAR");

	switch ((int)s_aniso_box.curvalue)
	{
		case 1: Cvar_SetValue( "r_anisotropic", 2.0 ); break;
		case 2: Cvar_SetValue( "r_anisotropic", 4.0 ); break;
		case 3: Cvar_SetValue( "r_anisotropic", 8.0 ); break;
		case 4: Cvar_SetValue( "r_anisotropic", 16.0 ); break;
		default:
		case 0: Cvar_SetValue( "r_anisotropic", 0.0 ); break;
	}

	Cvar_SetValue( "r_nonpoweroftwo_mipmaps", s_npot_mipmap_box.curvalue );
	Cvar_SetValue( "r_sgis_generatemipmap", s_sgis_mipmap_box.curvalue );
//	Cvar_SetValue( "r_ext_texture_compression", s_texcompress_box.curvalue );

	Cvar_SetValue( "r_swapinterval", s_vsync_box.curvalue );
	Cvar_SetValue( "cl_widescreen_fov", s_adjust_fov_box.curvalue );
	Cvar_SetValue( "cl_async", s_async_box.curvalue );

	prepareVideoRefresh ();

	//UI_ForceMenuOff();
}


// Knightmare added
int texfilter_box_setval (void)
{
	char *texmode = Cvar_VariableString("r_texturemode");
	if (!Q_strcasecmp(texmode, "GL_LINEAR_MIPMAP_NEAREST"))
		return 0;
	else
		return 1;
}

// Knightmare- refresh rate option
int refresh_box_setval (void)
{
	int refreshVar = (int)Cvar_VariableValue ("r_displayrefresh");

	if (refreshVar == 240)
		return 14;
	else if (refreshVar == 180)
		return 13;
	else if (refreshVar == 165)
		return 12;
	else if (refreshVar == 160)
		return 11;
	else if (refreshVar == 150)
		return 10;
	else if (refreshVar == 144)
		return 9;
	else if (refreshVar == 120)
		return 8;
	else if (refreshVar == 110)
		return 7;
	else if (refreshVar == 100)
		return 6;
	else if (refreshVar == 85)
		return 5;
	else if (refreshVar == 75)
		return 4;
	else if (refreshVar == 72)
		return 3;
	else if (refreshVar == 70)
		return 2;
	else if (refreshVar == 60)
		return 1;
	else
		return 0;
}

static const char *aniso0_names[] =
{
	"not supported",
	0
};

static const char *aniso2_names[] =
{
	"off",
	"2x",
	0
};

static const char *aniso4_names[] =
{
	"off",
	"2x",
	"4x",
	0
};

static const char *aniso8_names[] =
{
	"off",
	"2x",
	"4x",
	"8x",
	0
};

static const char *aniso16_names[] =
{
	"off",
	"2x",
	"4x",
	"8x",
	"16x",
	0
};

static const char **GetAnisoNames (void)
{
	float aniso_avail = Cvar_VariableValue("r_anisotropic_avail");
	if (aniso_avail < 2.0)
		return aniso0_names;
	else if (aniso_avail < 4.0)
		return aniso2_names;
	else if (aniso_avail < 8.0)
		return aniso4_names;
	else if (aniso_avail < 16.0)
		return aniso8_names;
	else // >= 16.0
		return aniso16_names;
}


float GetAnisoCurValue (void)
{
	float aniso_avail = Cvar_VariableValue("r_anisotropic_avail");
	float anisoValue = ClampCvar (0, aniso_avail, Cvar_VariableValue("r_anisotropic"));
	if (aniso_avail == 0) // not available
		return 0;
	if (anisoValue < 2.0)
		return 0;
	else if (anisoValue < 4.0)
		return 1;
	else if (anisoValue < 8.0)
		return 2;
	else if (anisoValue < 16.0)
		return 3;
	else // >= 16.0
		return 4;
}


/*
================
Menu_Video_Init
================
*/
void Menu_Video_Init (void)
{
	static const char *resolutions[] = 
	{
#include "../qcommon/vid_resolutions.h"
	};
	static const char *fullscreen_names[] =
	{
		"windowed",
		"fullscreen",
		"borderless",
		0
	};
	static const char *refreshrate_names[] = 
	{
		"[default]",
		"[60Hz   ]",
		"[70Hz   ]",
		"[72Hz   ]",
		"[75Hz   ]",
		"[85Hz   ]",
		"[100Hz  ]",
		"[110Hz  ]",
		"[120Hz  ]",
		"[144Hz  ]",
		"[150Hz  ]",
		"[160Hz  ]",
		"[165Hz  ]",
		"[180Hz  ]",
		"[240Hz  ]",
		0
	};
	static const char *yesno_names[] =
	{
		"no",
		"yes",
		0
	};
	static const char *mip_names[] =
	{
		"bilinear",
		"trilinear",
		0
	};
	static const char *lmh_names[] =
	{
		"lowest",
		"low",
		"medium",
		"high",
		"highest",
		0
	};
	int		y = 0;
	float	temp;
	char	*customStr;

	if ( !con_font_size )
		con_font_size = Cvar_Get ("con_font_size", "8", CVAR_ARCHIVE);

	s_video_menu.x = SCREEN_WIDTH*0.5;
//	s_video_menu.x = viddef.width * 0.50;
	s_video_menu.y = SCREEN_HEIGHT*0.5 - 80;
	s_video_menu.nitems = 0;

	s_mode_list.generic.type		= MTYPE_SPINCONTROL;
	s_mode_list.generic.textSize	= MENU_FONT_SIZE;
	s_mode_list.generic.name		= "video mode";
	s_mode_list.generic.x			= 0;
	s_mode_list.generic.y			= y;
	s_mode_list.itemnames			= resolutions;
	s_mode_list.generic.callback	= VidModeCallback;
	temp = Cvar_VariableValue("r_mode");
	s_mode_list.curvalue			= (temp == -1) ? 0 : max(temp - 2, 1); // offset for getting rid of < 640x480 resolutions
	s_mode_list.generic.statusbar	= "changes screen resolution";

	s_customwidth_title.generic.type		= MTYPE_SEPARATOR;
	s_customwidth_title.generic.textSize	= MENU_FONT_SIZE;
	s_customwidth_title.generic.flags		= (s_mode_list.curvalue != 0) ? QMF_HIDDEN : 0;
	s_customwidth_title.generic.name		= "custom width";
	s_customwidth_title.generic.x			= -2*MENU_FONT_SIZE;
	s_customwidth_title.generic.y			= y += 1.5*MENU_LINE_SIZE;

	s_customwidth_field.generic.type		= MTYPE_FIELD;
	s_customwidth_field.generic.textSize	= MENU_FONT_SIZE;
	s_customwidth_field.generic.flags		= (s_mode_list.curvalue != 0) ? (QMF_NUMBERSONLY|QMF_HIDDEN) : QMF_NUMBERSONLY;
//	s_customwidth_field.generic.name		= "custom width";
	s_customwidth_field.generic.callback	= 0;
	s_customwidth_field.generic.x			= -14*MENU_FONT_SIZE;
	s_customwidth_field.generic.y			= y + 1.5*MENU_LINE_SIZE;
	s_customwidth_field.length				= 5;
	s_customwidth_field.visible_length		= 6;
	customStr = Cvar_VariableString("r_customwidth");
	Q_strncpyz (s_customwidth_field.buffer, sizeof(s_customwidth_field.buffer), customStr);
	s_customwidth_field.cursor				= (int)strlen( customStr );

	s_customheight_title.generic.type		= MTYPE_SEPARATOR;
	s_customheight_title.generic.textSize	= MENU_FONT_SIZE;
	s_customheight_title.generic.flags		= (s_mode_list.curvalue != 0) ? QMF_HIDDEN : 0;
	s_customheight_title.generic.name		= "custom height";
	s_customheight_title.generic.x			= 14.5*MENU_FONT_SIZE;
	s_customheight_title.generic.y			= y;

	s_customheight_field.generic.type		= MTYPE_FIELD;
	s_customheight_field.generic.textSize	= MENU_FONT_SIZE;
	s_customheight_field.generic.flags		= (s_mode_list.curvalue != 0) ? (QMF_NUMBERSONLY|QMF_HIDDEN) : QMF_NUMBERSONLY;
//	s_customheight_field.generic.name		= "custom height";
	s_customheight_field.generic.callback	= 0;
	s_customheight_field.generic.x			= 2*MENU_FONT_SIZE;
	s_customheight_field.generic.y			= y + 1.5*MENU_LINE_SIZE;
	s_customheight_field.length				= 5;
	s_customheight_field.visible_length		= 6;
	customStr = Cvar_VariableString("r_customheight");
	Q_strncpyz (s_customheight_field.buffer, sizeof(s_customheight_field.buffer), customStr);
	s_customheight_field.cursor				= (int)strlen( customStr );

	s_fs_box.generic.type			= MTYPE_SPINCONTROL;
	s_fs_box.generic.textSize		= MENU_FONT_SIZE;
	s_fs_box.generic.x				= 0;
	s_fs_box.generic.y				= y += 3.5*MENU_LINE_SIZE;
	s_fs_box.generic.name			= "display type";	// "fullscreen"
	s_fs_box.itemnames				= fullscreen_names;	// yesno_names
	s_fs_box.curvalue				= Cvar_VariableValue("vid_fullscreen");
//	s_fs_box.generic.statusbar		= "changes bettween fullscreen and windowed display";
	s_fs_box.generic.statusbar		= "changes bettween fullscreen, borderless window, and windowed display";

	s_brightness_slider.generic.type		= MTYPE_SLIDER;
	s_brightness_slider.generic.textSize	= MENU_FONT_SIZE;
	s_brightness_slider.generic.x			= 0;
	s_brightness_slider.generic.y			= y += MENU_LINE_SIZE;
	s_brightness_slider.generic.name		= "brightness";
	s_brightness_slider.generic.callback	= BrightnessCallback;
//	s_brightness_slider.minvalue			= 0;
//	s_brightness_slider.maxvalue			= 20;
//	s_brightness_slider.curvalue			= (1.3 - Cvar_VariableValue("vid_gamma")) * 20;
	s_brightness_slider.maxPos				= 20;
	s_brightness_slider.baseValue			= 1.3f;
	s_brightness_slider.increment			= -0.05f;
	s_brightness_slider.displayAsPercent	= false;
	UI_MenuSlider_SetValue (&s_brightness_slider, Cvar_VariableValue("vid_gamma"));
	s_brightness_slider.generic.statusbar	= "changes display brightness";

	s_texfilter_box.generic.type		= MTYPE_SPINCONTROL;
	s_texfilter_box.generic.textSize	= MENU_FONT_SIZE;
	s_texfilter_box.generic.x			= 0;
	s_texfilter_box.generic.y			= y += 2*MENU_LINE_SIZE;
	s_texfilter_box.generic.name		= "texture filter";
	s_texfilter_box.curvalue			= texfilter_box_setval();
	s_texfilter_box.itemnames			= mip_names;
	s_texfilter_box.generic.statusbar	= "changes texture filtering mode";

	s_aniso_box.generic.type		= MTYPE_SPINCONTROL;
	s_aniso_box.generic.textSize	= MENU_FONT_SIZE;
	s_aniso_box.generic.x			= 0;
	s_aniso_box.generic.y			= y += MENU_LINE_SIZE;
	s_aniso_box.generic.name		= "anisotropic filter";
	s_aniso_box.curvalue			= GetAnisoCurValue();
	s_aniso_box.itemnames			= GetAnisoNames();
	s_aniso_box.generic.statusbar	= "changes level of anisotropic mipmap filtering";

	s_texqual_box.generic.type		= MTYPE_SPINCONTROL;
	s_texqual_box.generic.textSize	= MENU_FONT_SIZE;
	s_texqual_box.generic.x			= 0;
	s_texqual_box.generic.y			= y += MENU_LINE_SIZE;
	s_texqual_box.generic.name		= "texture quality";
	s_texqual_box.curvalue			= ClampCvar (0, 4, 4-Cvar_VariableValue("r_picmip"));
	s_texqual_box.itemnames			= lmh_names;
	s_texqual_box.generic.statusbar	= "changes maximum texture size (highest = no limit)";

	s_npot_mipmap_box.generic.type		= MTYPE_SPINCONTROL;
	s_npot_mipmap_box.generic.textSize	= MENU_FONT_SIZE;
	s_npot_mipmap_box.generic.x			= 0;
	s_npot_mipmap_box.generic.y			= y += MENU_LINE_SIZE;
	s_npot_mipmap_box.generic.name		= "non-power-of-2 mipmaps";
	s_npot_mipmap_box.itemnames			= yesno_names;
	s_npot_mipmap_box.curvalue			= Cvar_VariableValue("r_nonpoweroftwo_mipmaps");
	s_npot_mipmap_box.generic.statusbar	= "enables non-power-of-2 mipmapped textures (requires driver support)";

	s_sgis_mipmap_box.generic.type		= MTYPE_SPINCONTROL;
	s_sgis_mipmap_box.generic.textSize	= MENU_FONT_SIZE;
	s_sgis_mipmap_box.generic.x			= 0;
	s_sgis_mipmap_box.generic.y			= y += MENU_LINE_SIZE;
	s_sgis_mipmap_box.generic.name		= "SGIS mipmaps";
	s_sgis_mipmap_box.itemnames			= yesno_names;
	s_sgis_mipmap_box.curvalue			= Cvar_VariableValue("r_sgis_generatemipmap");
	s_sgis_mipmap_box.generic.statusbar	= "enables driver-based mipmap generation";
/*
	s_texcompress_box.generic.type		= MTYPE_SPINCONTROL;
	s_texcompress_box.generic.textSize	= MENU_FONT_SIZE;
	s_texcompress_box.generic.x			= 0;
	s_texcompress_box.generic.y			= y += MENU_LINE_SIZE;
	s_texcompress_box.generic.name		= "texture compression";
	s_texcompress_box.curvalue			= Cvar_VariableValue("r_ext_texture_compression");
	s_texcompress_box.itemnames			= yesno_names;
	s_texcompress_box.generic.statusbar	= "reduces quality, increases performance (leave off unless needed)";
*/
	s_vsync_box.generic.type			= MTYPE_SPINCONTROL;
	s_vsync_box.generic.textSize		= MENU_FONT_SIZE;
	s_vsync_box.generic.x				= 0;
	s_vsync_box.generic.y				= y += 2*MENU_LINE_SIZE;
	s_vsync_box.generic.name			= "video sync";
	s_vsync_box.generic.callback		= VsyncCallback;
	s_vsync_box.curvalue				= Cvar_VariableValue("r_swapinterval");
	s_vsync_box.itemnames				= yesno_names;
	s_vsync_box.generic.statusbar		= "sync framerate with monitor refresh";

	// Knightmare- refresh rate option
	s_refresh_box.generic.type			= MTYPE_SPINCONTROL;
	s_refresh_box.generic.textSize		= MENU_FONT_SIZE;
	s_refresh_box.generic.x				= 0;
	s_refresh_box.generic.y				= y += MENU_LINE_SIZE;
	s_refresh_box.generic.name			= "refresh rate";
	s_refresh_box.curvalue				= refresh_box_setval();
	s_refresh_box.itemnames				= refreshrate_names;
	s_refresh_box.generic.statusbar		= "sets refresh rate for fullscreen modes";

	s_adjust_fov_box.generic.type		= MTYPE_SPINCONTROL;
	s_adjust_fov_box.generic.textSize	= MENU_FONT_SIZE;
	s_adjust_fov_box.generic.x			= 0;
	s_adjust_fov_box.generic.y			= y += MENU_LINE_SIZE;
	s_adjust_fov_box.generic.name		= "fov autoscaling";
	s_adjust_fov_box.generic.callback	= AdjustFOVCallback;
	s_adjust_fov_box.curvalue			= Cvar_VariableValue("cl_widescreen_fov");
	s_adjust_fov_box.itemnames			= yesno_names;
	s_adjust_fov_box.generic.statusbar	= "automatic scaling of fov for widescreen modes";

	s_async_box.generic.type			= MTYPE_SPINCONTROL;
	s_async_box.generic.textSize		= MENU_FONT_SIZE;
	s_async_box.generic.x				= 0;
	s_async_box.generic.y				= y += MENU_LINE_SIZE;
	s_async_box.generic.name			= "async refresh";
	s_async_box.generic.callback		= AsyncCallback;
	s_async_box.curvalue				= Cvar_VariableValue("cl_async");
	s_async_box.itemnames				= yesno_names;
	s_async_box.generic.statusbar		= "decouples network framerate from render framerate";

	s_advanced_action.generic.type		= MTYPE_ACTION;
	s_advanced_action.generic.textSize	= MENU_FONT_SIZE;
	s_advanced_action.generic.name		= "advanced options";
	s_advanced_action.generic.x			= 0;
	s_advanced_action.generic.y			= y += 3*MENU_LINE_SIZE;
	s_advanced_action.generic.callback	= AdvancedOptions;

	s_defaults_action.generic.type		= MTYPE_ACTION;
	s_defaults_action.generic.textSize	= MENU_FONT_SIZE;
	s_defaults_action.generic.name		= "reset to defaults";
	s_defaults_action.generic.x			= 0;
	s_defaults_action.generic.y			= y += 3*MENU_LINE_SIZE;
	s_defaults_action.generic.callback	= ResetVideoDefaults;
	s_defaults_action.generic.statusbar	= "resets all video settings to internal defaults";

	// changed cancel to apply changes, thanx to MrG
	s_apply_action.generic.type			= MTYPE_ACTION;
	s_apply_action.generic.textSize		= MENU_FONT_SIZE;
	s_apply_action.generic.name			= "apply changes";
	s_apply_action.generic.x			= 0;
	s_apply_action.generic.y			= y += 2*MENU_LINE_SIZE;
	s_apply_action.generic.callback		= ApplyChanges;

	s_backmain_action.generic.type		= MTYPE_ACTION;
	s_backmain_action.generic.textSize	= MENU_FONT_SIZE;
	s_backmain_action.generic.name		= "back to main";
	s_backmain_action.generic.x			= 0;
	s_backmain_action.generic.y			= y += 2*MENU_LINE_SIZE;
	s_backmain_action.generic.callback	= UI_BackMenu;

	UI_AddMenuItem (&s_video_menu, (void *) &s_mode_list);

	UI_AddMenuItem (&s_video_menu, (void *) &s_customwidth_title);
	UI_AddMenuItem (&s_video_menu, (void *) &s_customwidth_field);
	UI_AddMenuItem (&s_video_menu, (void *) &s_customheight_title);
	UI_AddMenuItem (&s_video_menu, (void *) &s_customheight_field);

	UI_AddMenuItem (&s_video_menu, (void *) &s_fs_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_brightness_slider);
	UI_AddMenuItem (&s_video_menu, (void *) &s_texfilter_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_aniso_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_texqual_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_npot_mipmap_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_sgis_mipmap_box);
//	UI_AddMenuItem (&s_video_menu, (void *) &s_texcompress_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_vsync_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_refresh_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_adjust_fov_box);
	UI_AddMenuItem (&s_video_menu, (void *) &s_async_box);

	UI_AddMenuItem (&s_video_menu, (void *) &s_advanced_action);
	UI_AddMenuItem (&s_video_menu, (void *) &s_defaults_action);
	UI_AddMenuItem (&s_video_menu, (void *) &s_apply_action);
	UI_AddMenuItem (&s_video_menu, (void *) &s_backmain_action);

//	UI_CenterMenu (&s_video_menu);
//	s_video_menu.x -= MENU_FONT_SIZE;
}

/*
================
Menu_Video_Draw
================
*/
void Menu_Video_Draw (void)
{
	//int w, h;

	// draw the banner
	UI_DrawBanner ("m_banner_video");

	// move cursor to a reasonable starting position
	UI_AdjustMenuCursor (&s_video_menu, 1);

	// draw the menu
	UI_DrawMenu (&s_video_menu);
}

/*
================
Video_MenuKey
================
*/
const char *Menu_Video_Key (int key)
{
	return UI_DefaultMenuKey (&s_video_menu, key);
}

void Menu_Video_f (void)
{
	Menu_Video_Init ();
	UI_PushMenu (Menu_Video_Draw, Menu_Video_Key);
}