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

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
#include "../client/client.h"
#include "../client/qmenu.h"

#define REF_OPENGLX 0
#define REF_SDLGL 1

extern cvar_t *vid_ref;
extern cvar_t *vid_fullscreen;
extern cvar_t *vid_gamma;
extern cvar_t *scr_viewsize;

cvar_t	*r_overbrightbits;
cvar_t	*r_celshading;
static cvar_t *video_menu;

static cvar_t *gl_mode;
static cvar_t *gl_driver;
static cvar_t *gl_picmip;
static cvar_t *gl_texturemode;
static cvar_t *gl_anisotropic;
cvar_t *con_font_size;

static cvar_t *_windowed_mouse;

extern void M_ForceMenuOff( void );
float scaledVideo (float param);
float videoScale (void);

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

MENU INTERACTION

====================================================================
*/
#define OPENGL_MENU   1
static menuframework_s	s_opengl_menu;

static menuframework_s	s_opengl_system_menu;
static menuframework_s	s_opengl_advanced_menu;
static menuframework_s	s_opengl_misc_menu;

static int		s_current_menu_index;

static menulist_s		s_mode_list;
static menulist_s		s_texqual_box;
static menuslider_s		s_screensize_slider;
static menuslider_s		s_brightness_slider;
static menulist_s		s_tfilter_box;
static menulist_s  		s_fs_box;
static menuaction_s		s_apply_action;
static menuaction_s		s_defaults_action;

static menuslider_s		s_lightmapscale_slider;
static menulist_s  		s_overbrights_box;
static menulist_s  		s_vertexlight_box;
static menulist_s  		s_shaders_box;
static menulist_s  		s_texcompress_box;
static menuaction_s		s_back_action;

static menuaction_s		s_vid_system_section;
static menuaction_s		s_vid_advanced_section;
static menuaction_s		s_vid_misc_section;

static menulist_s		s_mode_list;
static menulist_s		s_ref_list;
static menulist_s		s_texqual_box;
static menuslider_s		s_screensize_slider;
static menuslider_s		s_brightness_slider;
static menulist_s		s_tfilter_box;
static menulist_s  		s_fs_box;
static menulist_s  		s_texcompress_box;

static menufield_s		s_particle_field;
static menufield_s		s_decal_field;
static menulist_s  		s_overbrights_box;
static menulist_s  		s_shaders_box;
static menulist_s  		s_celshading_box;
static menulist_s  		s_transsort_box;
static menulist_s  		s_glares_box;
static menulist_s  		s_skyglares_box;
static menulist_s  		s_shellglares_box;

static menulist_s  		s_windowed_mouse;
static menulist_s  		s_shadows_box;
static menulist_s  		s_fps_box;
static menulist_s  		s_netgraph_box;
static menulist_s  		s_netgpos_box;

static menuaction_s		s_apply_action;
static menuaction_s		s_defaults_action;


static menuaction_s		s_back_action;


static float ClampCvar( float min, float max, float value )
{
	if ( value < min ) return min;
	if ( value > max ) return max;
	return value;
}

static void ScreenSizeCallback( void *s )
{
	menuslider_s *slider = ( menuslider_s * ) s;

	Cvar_SetValue( "viewsize", slider->curvalue * 10 );
}

static void BrightnessCallback( void *s )
{
	menuslider_s *slider = ( menuslider_s * ) s;

//	Cvar_SetValue( "vid_gamma", ( 0.8 - ( s_brightness_slider.curvalue/10.0 - 0.5 ) ) + 0.5 );
	if ( stricmp( vid_ref->string, "glx" ) == 0 )
	{
		float gamma = ( 0.8 - ( s_brightness_slider.curvalue/10.0 - 0.5 ) ) + 0.5;
		int ref;

		Cvar_SetValue( "vid_gamma", gamma );
	}
}

static void ResetDefaults( void *unused )
{
	VID_MenuInit();
}


static void prepareVideoRefresh( void )
{
	//set the right mode for refresh
	Cvar_Set( "vid_ref", "glx" );
	Cvar_Set( "gl_driver", "libGL.so" );

	//tell them theyr're modified so they refresh
	if ( vid_gamma->modified )
		vid_ref->modified = true;
	if ( gl_driver->modified )
		vid_ref->modified = true;
}


static void ApplyChanges( void *unused )
{

	float gamma;
	/*
	** invert sense so greater = brighter, and scale to a range of 0.5 to 1.3
	*/

	if (s_tfilter_box.curvalue == 0)
		Cvar_Set("gl_texturemode", "GL_NEAREST");
	else if (s_tfilter_box.curvalue == 1)
		Cvar_Set("gl_texturemode", "GL_NEAREST_MIPMAP_NEAREST");
	else if (s_tfilter_box.curvalue == 2)
		Cvar_Set("gl_texturemode", "GL_LINEAR");
	else if (s_tfilter_box.curvalue == 3)
		Cvar_Set("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST");
	else if (s_tfilter_box.curvalue == 4)
		Cvar_Set("gl_texturemode", "GL_LINEAR_MIPMAP_LINEAR");
	else if (s_tfilter_box.curvalue == 5)
		Cvar_Set("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST");
	else //if (s_tfilter_box.curvalue == 6)
		Cvar_Set("gl_texturemode", "GL_LINEAR_MIPMAP_LINEAR");

	Cvar_SetValue( "gl_anisotropic", (s_tfilter_box.curvalue > 4) );
	Cvar_SetValue( "gl_picmip", 3-s_texqual_box.curvalue );
	Cvar_SetValue( "vid_fullscreen", s_fs_box.curvalue );
	Cvar_SetValue( "gl_mode", s_mode_list.curvalue );
	Cvar_SetValue( "gl_ext_texture_compression", s_texcompress_box.curvalue );
	
	/*
	** must use an if here (instead of a switch), since the REF_'s are now variables
	** and not #DEFINE's (constants)
	*/


	switch ( s_ref_list.curvalue )
	{
	case REF_OPENGLX :
		Cvar_Set( "vid_ref", "glx" );
		Cvar_Set( "gl_driver", "libGL.so" );
		if (gl_driver->modified)
			vid_ref->modified = true;
		break;

	case REF_SDLGL :
		Cvar_Set( "vid_ref", "sdlgl" );
		Cvar_Set( "gl_driver", "libGL.so.so" );
		if (gl_driver->modified)
			vid_ref->modified = true;
		break;
	}
	Cvar_SetValue( "r_shaders", s_shaders_box.curvalue );
	Cvar_SetValue( "r_celshading", s_celshading_box.curvalue );
	Cvar_SetValue( "gl_transrendersort", s_transsort_box.curvalue );
	if (s_overbrights_box.curvalue)
		Cvar_SetValue( "r_overbrightbits", (int)(s_overbrights_box.curvalue)<<1 );
	else
		Cvar_SetValue( "r_overbrightbits", 0 );
	Cvar_SetValue( "r_particles", atoi( s_particle_field.buffer) );
	Cvar_SetValue( "r_decals", atoi( s_decal_field.buffer) );
	Cvar_SetValue( "rs_glares", s_glares_box.curvalue );
	Cvar_SetValue( "rs_glares_sky", s_skyglares_box.curvalue );

	if (s_glares_box.curvalue == 0)
		Cvar_SetValue( "rs_glares", 0 );
	else if (s_glares_box.curvalue ==1)
		Cvar_SetValue( "rs_glares", 1 );
	else if (s_glares_box.curvalue ==2)
		Cvar_SetValue( "rs_glares", 1.5 );
	else
		Cvar_SetValue( "rs_glares", 3 );

	Cvar_SetValue( "gl_shadows", s_shadows_box.curvalue );
	Cvar_SetValue( "cl_drawfps", s_fps_box.curvalue );
	Cvar_SetValue( "netgraph", s_netgraph_box.curvalue );
	Cvar_SetValue( "netgraph_pos", s_netgpos_box.curvalue );

	prepareVideoRefresh ();

	M_ForceMenuOff();
}

static void CancelChanges( void *unused )
{
	extern void M_PopMenu( void );

	M_PopMenu();
}

/*
** VID_MenuInit
*/

static void setMenuSystem ( void *unused )
{
	Cvar_SetValue( "video_menu", 0 );
	refreshCursorLink();
}
static void setMenuAdvanced ( void *unused )
{
	Cvar_SetValue( "video_menu", 1 );
	refreshCursorLink();
}
static void setMenuMiscellaneous ( void *unused )
{
	Cvar_SetValue( "video_menu", 2 );
	refreshCursorLink();
}

void VID_MenuInit( void )
{
	static const char *resolutions[] = 
	{
		"[320 240  ]",
		"[400 300  ]",
		"[512 384  ]",
		"[640 480  ]",
		"[800 600  ]",
		"[960 720  ]",
		"[1024 768 ]",
		"[1152 864 ]",
		"[1280 1024]",
		"[1600 1200]",
		"[2048 1536]",
		"[1024 480 ]", /* sony vaio pocketbook */
		"[1152 768 ]", /* Apple TiBook */
		"[1280 854 ]", /* apple TiBook */
		"[640 400  ]", /* generic 16:10 widescreen resolutions */
 		"[800 500  ]", /* as found on many modern notebooks    */
 		"[1024 640 ]",
 		"[1280 800 ]",
 		"[1680 1050]",
 		"[1920 1200]",
		0
	};
	static const char *refs[] =
	{
		"[OpenGL GLX]",
		"[OpenGL SDL]",
		0
	};
	static const char *yesno_names[] =
	{
		"no",
		"yes",
		0
	};
	static const char *mip_names[] =
	{
		"none",
		"nearest",
		"linear",
		"bilinear",
		"trilinear",
		"bilinear anisotropic",
		"trilinear anisotopic",		
		0
	};
	static const char *lmh_names[] =
	{
		"low",
		"medium",
		"high",
		"highest",
		0
	};
	static const char *sort_names[] =
	{
		"off",
		"by depth",
		"by depth w/ surfaces",
		0
	};
	static const char *overbright_names[] =
	{
		"off",
		"low",
		"high",
		0
	};
	static const char *glares_names[] =
	{
		"off",
		"low",
		"medium",
		"high",
		0
	};
	static const char *shadow_names[] =
	{
		"off",
		"static",
		"projected",
		0
	};
	static const char *netgraph_names[] =
	{
		"bottom right",
		"bottom left",
		"top right",
		"top left",
		0
	};
	int y;
	if (!video_menu)
		video_menu = Cvar_Get ("video_menu", "0", 0);

	if ( !gl_driver )
		gl_driver = Cvar_Get( "gl_driver", "libGL.so", 0 );
	if ( !gl_picmip )
		gl_picmip = Cvar_Get( "gl_picmip", "0", 0 );
	if ( !gl_mode )
		gl_mode = Cvar_Get( "gl_mode", "0", 0 );
	if ( !gl_texturemode )
		gl_texturemode = Cvar_Get( "gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", CVAR_ARCHIVE );
	if ( !gl_anisotropic )
		gl_anisotropic = Cvar_Get( "gl_anisotropic", "0", CVAR_ARCHIVE );
	if ( !r_overbrightbits )
		r_overbrightbits = Cvar_Get( "r_overbrightbits", "2", CVAR_ARCHIVE );
	if ( !_windowed_mouse)
        _windowed_mouse = Cvar_Get( "_windowed_mouse", "0", CVAR_ARCHIVE );

	s_mode_list.curvalue = gl_mode->value;

	if ( !scr_viewsize )
		scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);

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

	s_screensize_slider.curvalue = scr_viewsize->value/10;
	
	if ( strcmp( vid_ref->string, "glx" ) == 0 )
	{
		if ( strcmp( gl_driver->string, "libGL.so" ) == 0 )
			s_ref_list.curvalue = REF_OPENGLX;

	}
	else if ( strcmp( vid_ref->string, "sdlgl" ) == 0 )
	{
		if ( strcmp( gl_driver->string, "libGL.so." ) == 0 )
			s_ref_list.curvalue = REF_OPENGLX;
	}
	
	s_opengl_menu.x = viddef.width/2;
	s_opengl_menu.y = viddef.height/2 - scaledVideo(58);
	s_opengl_menu.nitems = 0;
	s_opengl_system_menu.x = viddef.width/2;
	s_opengl_system_menu.y = viddef.height/2 - scaledVideo(58);
	s_opengl_system_menu.nitems = 0;
	s_opengl_advanced_menu.x = viddef.width/2;
	s_opengl_advanced_menu.y = viddef.height/2 - scaledVideo(58);
	s_opengl_advanced_menu.nitems = 0;
	s_opengl_misc_menu.x = viddef.width/2;
	s_opengl_misc_menu.y = viddef.height/2 - scaledVideo(58);
	s_opengl_misc_menu.nitems = 0;

	//SECTION SELECTORS
	{
	s_vid_system_section.generic.type				= MTYPE_ACTION;
	s_vid_system_section.generic.name				= "system";
	s_vid_system_section.generic.x					= -MENU_FONT_SIZE * 10;
	s_vid_system_section.generic.y					= 0;
	s_vid_system_section.generic.callback			= setMenuSystem;
	s_vid_system_section.generic.cursor_offset		= s_vid_system_section.generic.x - 
	MENU_FONT_SIZE*(strlen(s_vid_system_section.generic.name)+3);

	s_vid_advanced_section.generic.type				= MTYPE_ACTION;
	s_vid_advanced_section.generic.name				= "advanced";
	s_vid_advanced_section.generic.x				= MENU_FONT_SIZE * 1;
	s_vid_advanced_section.generic.y				= 0;
	s_vid_advanced_section.generic.callback			= setMenuAdvanced;
	s_vid_advanced_section.generic.cursor_offset	= s_vid_advanced_section.generic.x - 
	MENU_FONT_SIZE*(strlen(s_vid_advanced_section.generic.name)+3);

	s_vid_misc_section.generic.type				= MTYPE_ACTION;
	s_vid_misc_section.generic.name				= "miscellaneous";
	s_vid_misc_section.generic.x				= MENU_FONT_SIZE * 17;
	s_vid_misc_section.generic.y				= 0;
	s_vid_misc_section.generic.callback			= setMenuMiscellaneous;
	s_vid_misc_section.generic.cursor_offset	= s_vid_misc_section.generic.x - 
	MENU_FONT_SIZE*(strlen(s_vid_misc_section.generic.name)+3);

	}
	//SYSTEM
	{
	s_ref_list.generic.type = MTYPE_SPINCONTROL;
	s_ref_list.generic.name = "driver";
	s_ref_list.generic.x = 0;
	s_ref_list.generic.y = MENU_FONT_SIZE*y+2;;
	s_ref_list.itemnames = refs;
	s_ref_list.generic.statusbar	= "video renderer";
			
		s_mode_list.generic.type = MTYPE_SPINCONTROL;
		s_mode_list.generic.name = "video mode";
		s_mode_list.generic.x = 0;
		s_mode_list.generic.y = MENU_FONT_SIZE*3+2;
		s_mode_list.itemnames = resolutions;
		s_mode_list.generic.statusbar	= "video resolution";
		
		s_fs_box.generic.type = MTYPE_SPINCONTROL;
		s_fs_box.generic.x	= 0;
		s_fs_box.generic.y	= MENU_FONT_SIZE*4+2;
		s_fs_box.generic.name	= "fullscreen";
		s_fs_box.itemnames = yesno_names;
		s_fs_box.curvalue = vid_fullscreen->value;

		s_screensize_slider.generic.type	= MTYPE_SLIDER;
		s_screensize_slider.generic.x		= 0;
		s_screensize_slider.generic.y		= MENU_FONT_SIZE*5+2;
		s_screensize_slider.generic.name	= "screen size";
		s_screensize_slider.minvalue = 3;
		s_screensize_slider.maxvalue = 12;
		s_screensize_slider.generic.callback = ScreenSizeCallback;

		s_brightness_slider.generic.type	= MTYPE_SLIDER;
		s_brightness_slider.generic.x	= 0;
		s_brightness_slider.generic.y	= MENU_FONT_SIZE*7+2;
		s_brightness_slider.generic.name	= "brightness";
		s_brightness_slider.generic.callback = BrightnessCallback;
		s_brightness_slider.minvalue = 5;
		s_brightness_slider.maxvalue = 13;
		s_brightness_slider.curvalue = ( 1.3 - vid_gamma->value + 0.5 ) * 10;

		s_tfilter_box.generic.type = MTYPE_SPINCONTROL;
		s_tfilter_box.generic.x	= 0;
		s_tfilter_box.generic.y	= MENU_FONT_SIZE*9+2;
		s_tfilter_box.generic.name	= "texture filter";
		s_tfilter_box.itemnames = mip_names;
		if (!Q_strcasecmp(gl_texturemode->string, "GL_NEAREST"))
			s_tfilter_box.curvalue = 0;
		else if (!Q_strcasecmp(gl_texturemode->string, "GL_NEAREST_MIPMAP_NEAREST"))
			s_tfilter_box.curvalue = 1;
		else if (!Q_strcasecmp(gl_texturemode->string, "GL_LINEAR"))
			s_tfilter_box.curvalue = 2;
		else if (!Q_strcasecmp(gl_texturemode->string, "GL_LINEAR_MIPMAP_NEAREST"))
			s_tfilter_box.curvalue = (gl_anisotropic->value)? 5 :3;
		else // if (!Q_strcasecmp(gl_texturemode->string, "GL_LINEAR_MIPMAP_LINEAR"))
			s_tfilter_box.curvalue = (gl_anisotropic->value)? 6 :4;

		s_windowed_mouse.generic.type = MTYPE_SPINCONTROL;
		s_windowed_mouse.generic.x  = 0;
		s_windowed_mouse.generic.y  = MENU_FONT_SIZE*y+2;
		s_windowed_mouse.generic.name   = "windowed mouse";
		s_windowed_mouse.curvalue = _windowed_mouse->value;
		s_windowed_mouse.itemnames = yesno_names;
		
		s_texqual_box.generic.type	= MTYPE_SPINCONTROL;
		s_texqual_box.generic.x		= 0;
		s_texqual_box.generic.y		= MENU_FONT_SIZE*10+2;
		s_texqual_box.generic.name	= "texture quality";
		s_texqual_box.itemnames = lmh_names;
		s_texqual_box.curvalue = ClampCvar( 0, 3, 3-gl_picmip->value );

		s_texcompress_box.generic.type		= MTYPE_SPINCONTROL;
		s_texcompress_box.generic.x			= 0;
		s_texcompress_box.generic.y			= MENU_FONT_SIZE*11+2;
		s_texcompress_box.generic.name		= "texture compression";
		s_texcompress_box.itemnames			= yesno_names;
		s_texcompress_box.curvalue			= Cvar_VariableValue("gl_ext_texture_compression");
		s_texcompress_box.generic.statusbar	= "low quality textures";

	}
	//ADVACNED
	{
		s_shaders_box.generic.type		= MTYPE_SPINCONTROL;
		s_shaders_box.generic.x			= 0;
		s_shaders_box.generic.y			= MENU_FONT_SIZE*3+2;
		s_shaders_box.generic.name		= "shaders";
		s_shaders_box.itemnames			= yesno_names;
		s_shaders_box.curvalue			= Cvar_VariableValue("r_shaders");
		s_shaders_box.generic.statusbar	= "dynamic texturing";

		s_glares_box.generic.type		= MTYPE_SPINCONTROL;
		s_glares_box.generic.x			= 0;
		s_glares_box.generic.y			= MENU_FONT_SIZE*5+2;
		s_glares_box.generic.name		= "screen glares";
		s_glares_box.itemnames			= glares_names;
		s_glares_box.curvalue			= Cvar_VariableValue("rs_glares");
		s_glares_box.generic.statusbar	= "light flare glaring";
		
		if (s_glares_box.curvalue >= 3)
			s_glares_box.curvalue = 3;
		else if (s_glares_box.curvalue >= 1.5)
			s_glares_box.curvalue = 2;
		else if (s_glares_box.curvalue)
			s_glares_box.curvalue = 1;
		else 
			s_glares_box.curvalue = 0;

		s_skyglares_box.generic.type		= MTYPE_SPINCONTROL;
		s_skyglares_box.generic.x			= 0;
		s_skyglares_box.generic.y			= MENU_FONT_SIZE*6+2;
		s_skyglares_box.generic.name		= "sky glares";
		s_skyglares_box.itemnames			= yesno_names;
		s_skyglares_box.curvalue			= Cvar_VariableValue("rs_glares_sky");

		s_shellglares_box.generic.type		= MTYPE_SPINCONTROL;
		s_shellglares_box.generic.x			= 0;
		s_shellglares_box.generic.y			= MENU_FONT_SIZE*7+2;
		s_shellglares_box.generic.name		= "shell glares";
		s_shellglares_box.itemnames			= yesno_names;
		s_shellglares_box.curvalue			= Cvar_VariableValue("rs_glares_shell");

		s_overbrights_box.generic.type 		= MTYPE_SPINCONTROL;
		s_overbrights_box.generic.x			= 0;
		s_overbrights_box.generic.y			= MENU_FONT_SIZE*9+2;
		s_overbrights_box.generic.name		= "overbrights";
		s_overbrights_box.itemnames 			= overbright_names;
		s_overbrights_box.curvalue 			= (int)(r_overbrightbits->value)>>1;

		s_transsort_box.generic.type		= MTYPE_SPINCONTROL;
		s_transsort_box.generic.x			= 0;
		s_transsort_box.generic.y			= MENU_FONT_SIZE*11+2;
		s_transsort_box.generic.name		= "transparency";
		s_transsort_box.itemnames			= sort_names;
		s_transsort_box.curvalue			= Cvar_VariableValue("gl_transrendersort");
		s_transsort_box.generic.statusbar	= "depth sorting routine";

		s_celshading_box.generic.type		= MTYPE_SPINCONTROL;
		s_celshading_box.generic.x			= 0;
		s_celshading_box.generic.y			= MENU_FONT_SIZE*13+2;
		s_celshading_box.generic.name		= "celshading";
		s_celshading_box.itemnames			= yesno_names;
		s_celshading_box.curvalue			= Cvar_VariableValue("r_celshading");
		s_celshading_box.generic.statusbar	= "cartoon style rendering";
	}
	//MISC
	{
		s_shadows_box.generic.type		= MTYPE_SPINCONTROL;
		s_shadows_box.generic.x			= 0;
		s_shadows_box.generic.y			= MENU_FONT_SIZE*3+2;
		s_shadows_box.generic.name		= "shadows";
		s_shadows_box.itemnames			= shadow_names;
		s_shadows_box.curvalue			= Cvar_VariableValue("gl_shadows");

		s_fps_box.generic.type			= MTYPE_SPINCONTROL;
		s_fps_box.generic.x			= 0;
		s_fps_box.generic.y			= MENU_FONT_SIZE*5+2;
		s_fps_box.generic.name			= "fps counter";
		s_fps_box.itemnames			= yesno_names;
		s_fps_box.curvalue			= Cvar_VariableValue("cl_drawfps");

		s_netgraph_box.generic.type		= MTYPE_SPINCONTROL;
		s_netgraph_box.generic.x		= 0;
		s_netgraph_box.generic.y		= MENU_FONT_SIZE*7+2;
		s_netgraph_box.generic.name		= "netgraph";
		s_netgraph_box.itemnames		= yesno_names;
		s_netgraph_box.curvalue			= Cvar_VariableValue("netgraph");
		
		s_netgpos_box.generic.type		= MTYPE_SPINCONTROL;
		s_netgpos_box.generic.x			= 0;
		s_netgpos_box.generic.y			= MENU_FONT_SIZE*8+2;
		s_netgpos_box.generic.name		= "netgraph position";
		s_netgpos_box.itemnames			= netgraph_names;
		s_netgpos_box.curvalue			= Cvar_VariableValue("netgraph_pos");

		s_particle_field.generic.type = MTYPE_FIELD;
		s_particle_field.generic.name = "particles";
		s_particle_field.generic.flags = QMF_NUMBERSONLY;
		s_particle_field.generic.x	= 0;
		s_particle_field.generic.y	= MENU_FONT_SIZE*10+4;
		s_particle_field.length = 4;
		s_particle_field.visible_length = 4;
		strcpy( s_particle_field.buffer, Cvar_VariableString("r_particles") );

		s_decal_field.generic.type = MTYPE_FIELD;
		s_decal_field.generic.name = "decals";
		s_decal_field.generic.flags = QMF_NUMBERSONLY;
		s_decal_field.generic.x	= 0;
		s_decal_field.generic.y	= MENU_FONT_SIZE*12+4;
		s_decal_field.length = 4;
		s_decal_field.visible_length =4;
		strcpy( s_decal_field.buffer, Cvar_VariableString("r_decals") );
	}


	s_defaults_action.generic.type = MTYPE_ACTION;
	s_defaults_action.generic.name = "reset to defaults";
	s_defaults_action.generic.x    = 0;
	s_defaults_action.generic.y    = MENU_FONT_SIZE*15+2;
	s_defaults_action.generic.callback = ResetDefaults;

	s_apply_action.generic.type = MTYPE_ACTION;
	s_apply_action.generic.name = "apply changes";
	s_apply_action.generic.x    = 0;
	s_apply_action.generic.y    = MENU_FONT_SIZE*16+2;
	s_apply_action.generic.callback = ApplyChanges;

//SYSTEM

	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_vid_system_section );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_vid_advanced_section );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_vid_misc_section );


	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_mode_list );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_fs_box );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_screensize_slider );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_brightness_slider );

	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_tfilter_box );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_texqual_box );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_texcompress_box );


	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_defaults_action );
	Menu_AddItem( &s_opengl_system_menu, ( void * ) &s_apply_action );
//ADVANCED

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_vid_system_section );
	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_vid_advanced_section );
	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_vid_misc_section );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_shaders_box );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_glares_box );
	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_skyglares_box );
	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_shellglares_box );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_overbrights_box );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_transsort_box );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_celshading_box );

	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_defaults_action );
	Menu_AddItem( &s_opengl_advanced_menu, ( void * ) &s_apply_action );
//MISC
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_vid_system_section );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_vid_advanced_section );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_vid_misc_section );


	
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_shadows_box );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_fps_box );

	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_netgraph_box );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_netgpos_box );

	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_particle_field );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_decal_field );

	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_defaults_action );
	Menu_AddItem( &s_opengl_misc_menu, ( void * ) &s_apply_action );

//CONFIG
	Menu_Center( &s_opengl_system_menu );
	Menu_Center( &s_opengl_advanced_menu );
	Menu_Center( &s_opengl_misc_menu );

	s_opengl_system_menu.x -= 8;
	s_opengl_advanced_menu.x -= 8;
	s_opengl_misc_menu.x -= 8;
}

/*
================
VID_MenuDraw
================
*/
void M_Banner( char *name );

void VID_MenuDraw (void)
{
	int w, h;

	/*
	** draw the banner
	*/
	M_Banner("m_banner_video");
	/*
	** move cursor to a reasonable starting position
	*/

	if (video_menu->value == 0)
	{
		s_vid_system_section.generic.name		= "^2system";
		s_vid_advanced_section.generic.name		= "advanced";
		s_vid_misc_section.generic.name			= "miscellaneous";

		s_vid_system_section.generic.x			= MENU_FONT_SIZE * (-10+1);
		s_vid_advanced_section.generic.x		= MENU_FONT_SIZE * 1;
		s_vid_misc_section.generic.x			= MENU_FONT_SIZE * 17;

		Menu_AdjustCursor( &s_opengl_system_menu, 1 );
		Menu_Draw( &s_opengl_system_menu );
	}
	else if (video_menu->value == 1)
	{
		s_vid_system_section.generic.name		= "system";
		s_vid_advanced_section.generic.name		= "^2advanced";
		s_vid_misc_section.generic.name			= "miscellaneous";

		s_vid_system_section.generic.x			= MENU_FONT_SIZE * -10+1;
		s_vid_advanced_section.generic.x		= MENU_FONT_SIZE * (1+1);
		s_vid_misc_section.generic.x			= MENU_FONT_SIZE * 17;

		Menu_AdjustCursor( &s_opengl_advanced_menu, 1 );
		Menu_Draw( &s_opengl_advanced_menu );
	}
	else
	{
		s_vid_system_section.generic.name		= "system";
		s_vid_advanced_section.generic.name		= "advanced";
		s_vid_misc_section.generic.name			= "^2miscellaneous";

		s_vid_system_section.generic.x			= MENU_FONT_SIZE * -10;
		s_vid_advanced_section.generic.x		= MENU_FONT_SIZE * 1;
		s_vid_misc_section.generic.x			= MENU_FONT_SIZE * (17+1);

		Menu_AdjustCursor( &s_opengl_misc_menu, 1 );
		Menu_Draw( &s_opengl_misc_menu );
	}
}

/*
================
VID_MenuKey
================
*/

void vid_MoveMenuSelect (menuframework_s *m, int dir)
{

	if (m->cursor<3)
	{
		if (dir > 0)
		{
			m->cursor = 3;
			refreshCursorLink();
			Menu_AdjustCursor( m, 0 );
		}
		else
		{
			m->cursor = -1;
			refreshCursorLink();
			Menu_AdjustCursor( m, -1 );
		}
		return;
	}

	m->cursor += dir;
	refreshCursorLink();
	Menu_AdjustCursor( m, dir );
}

void vid_MoveMenuSlide (menuframework_s *m, int dir)
{
	if (m->cursor<3)
	{
		m->cursor += dir;

		if (m->cursor<0) { dir = 3; }
		if (m->cursor==3) { m->cursor=0; dir = 0; }

		Menu_AdjustCursor( m, dir );

		refreshCursorLink();
		return;
	}

	Menu_SlideItem(m, dir);
}

const char *VID_MenuKey( int key )
{
	menuframework_s *m;
	static const char *sound1 = "misc/menu1.wav";
	static const char *sound2 = "misc/menu2.wav";
	const char *sound = sound1;
	menucommon_s *item;

	if (video_menu->value == 0)
		m = &s_opengl_system_menu;
	else if (video_menu->value == 1)
		m = &s_opengl_advanced_menu;
	else
		m = &s_opengl_misc_menu;

	if ( m )
		if ( ( item = Menu_ItemAtCursor( m ) ) != 0 )
			if ( item->type == MTYPE_FIELD )
				if ( Field_Key( ( menufield_s * ) item, key ) )
					return NULL;

	switch ( key )
	{
	case K_ESCAPE:
		CancelChanges( 0 );
		return NULL;
	case K_KP_UPARROW:
	case K_UPARROW:
		vid_MoveMenuSelect( m, -1 );
		sound = sound2;
		break;
	case K_KP_DOWNARROW:
	case K_DOWNARROW:
		vid_MoveMenuSelect( m, 1 );
		sound = sound2;
		break;
	case K_KP_LEFTARROW:
	case K_LEFTARROW:
		vid_MoveMenuSlide( m, -1 );
		sound = sound2;
		break;
	case K_KP_RIGHTARROW:
	case K_RIGHTARROW:
		vid_MoveMenuSlide( m, 1 );
		sound = sound2;
		break;
	case K_KP_ENTER:
	case K_ENTER:
		if ( !Menu_SelectItem( m ) )
			ApplyChanges( NULL );
		break;
	}

	return sound;
}