/*
	vid_mgl.c

	Win32 Scitech MGL video driver

	Copyright (C) 1996-1997  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:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

*/
static const char rcsid[] = 
	"$Id$";

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <stdlib.h>

#include "QF/cmd.h"
#include "QF/cdaudio.h"
#include "QF/console.h"
#include "QF/draw.h"
#include "QF/keys.h"
#include "QF/input.h"
#include "QF/qargs.h"
#include "QF/qendian.h"
#include "QF/screen.h"
#include "QF/sound.h"
#include "QF/sys.h"
#include "QF/va.h"
#include "QF/wad.h"

#include "d_local.h"
#include "in_win.h"
#include "resource.h"
#include "winquake.h"

#define	MINIMUM_MEMORY	0x550000

#define MAX_MODE_LIST	30
#define VID_ROW_SIZE	3


/* Unused */
int			VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes,
			VGA_planar;
byte       *VGA_pagebase;

qboolean    dibonly;


HWND        mainwindow;

HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);

int         DIBWidth, DIBHeight;
qboolean    DDActive;
RECT        WindowRect;
DWORD       WindowStyle, ExWindowStyle;

int         window_center_x, window_center_y, window_x, window_y, window_width,
			window_height;
RECT        window_rect;

static DEVMODE	gdevmode;
static qboolean startwindowed = 0, windowed_mode_set = 0;
static int		firstupdate = 1;
static qboolean vid_palettized;
static int		lockcount;
static int		vid_fulldib_on_focus_mode;
static qboolean force_minimized, in_mode_set, is_mode0x13, force_mode_set;
static int		vid_stretched, windowed_mouse;
static qboolean palette_changed, syscolchg, vid_mode_set, hide_window,
				pal_is_nostatic;
static HICON hIcon;


#define MODE_WINDOWED			0
#define MODE_SETTABLE_WINDOW	2
#define NO_MODE					(MODE_WINDOWED - 1)
#define MODE_FULLSCREEN_DEFAULT	(MODE_WINDOWED + 3)

// Note that 0 is MODE_WINDOWED
cvar_t     *vid_mode;

// Note that 0 is MODE_WINDOWED
// Note that 3 is MODE_FULLSCREEN_DEFAULT
cvar_t     *_vid_default_mode_win;
cvar_t     *vid_nopageflip;
cvar_t     *vid_config_x;
cvar_t     *vid_config_y;
cvar_t     *vid_stretch_by_2;
cvar_t     *vid_windowed_mode;
cvar_t     *block_switch;
cvar_t     *vid_window_x;
cvar_t     *vid_window_y;


typedef struct {
	int         width;
	int         height;
} lmode_t;

lmode_t     lowresmodes[] = {
	{320, 200},
	{320, 240},
	{400, 300},
	{512, 384},
};

int         vid_modenum = NO_MODE;
int         vid_testingmode, vid_realmode;
double      vid_testendtime;
int         vid_default = MODE_WINDOWED;
static int  windowed_default;

modestate_t modestate = MS_UNINIT;

static byte *vid_surfcache;
static int  vid_surfcachesize;
static int  VID_highhunkmark;

unsigned char vid_curpal[256 * 3];

int         driver = grDETECT, mode;
qboolean    useWinDirect = true, useDirectDraw = true;
MGLDC      *mgldc = NULL, *memdc = NULL, *dibdc = NULL, *windc = NULL;

typedef struct {
	modestate_t type;
	int         width;
	int         height;
	int         modenum;
	int         mode13;
	int         stretched;
	int         dib;
	int         fullscreen;
	int         bpp;
	int         halfscreen;
	char        modedesc[13];
} vmode_t;

static vmode_t modelist[MAX_MODE_LIST];
static int  nummodes;

int         aPage;						// Current active display page
int         vPage;						// Current visible display page
int         waitVRT = true;				// True to wait for retrace on flip

static vmode_t badmode;

static byte backingbuf[48 * 24];

void        VID_MenuDraw (void);
void        VID_MenuKey (int key);

LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
void        AppActivate (BOOL fActive, BOOL minimize);


void
VID_RememberWindowPos (void)
{
	RECT        rect;

	if (GetWindowRect (mainwindow, &rect)) {
		if ((rect.left < GetSystemMetrics (SM_CXSCREEN)) &&
			(rect.top < GetSystemMetrics (SM_CYSCREEN)) &&
			(rect.right > 0) && (rect.bottom > 0)) {
			Cvar_SetValue (vid_window_x, rect.left);
			Cvar_SetValue (vid_window_y, rect.top);
		}
	}
}

void
VID_CheckWindowXY (void)
{

	if ((vid_window_x->int_val > (GetSystemMetrics (SM_CXSCREEN) - 160)) ||
		(vid_window_y->int_val > (GetSystemMetrics (SM_CYSCREEN) - 120)) ||
		(vid_window_x->int_val < 0) || (vid_window_y->int_val < 0)) {
		Cvar_SetValue (vid_window_x, 0.0);
		Cvar_SetValue (vid_window_y, 0.0);
	}
}

void
VID_UpdateWindowStatus (int w_x, int w_y)
{

	window_rect.left = window_x = w_x;
	window_rect.top = window_y = w_y;
	window_rect.right = window_x + window_width;
	window_rect.bottom = window_y + window_height;
	window_center_x = (window_rect.left + window_rect.right) / 2;
	window_center_y = (window_rect.top + window_rect.bottom) / 2;

	IN_UpdateClipCursor ();
}

qboolean
VID_CheckAdequateMem (int width, int height)
{
	return true;
}

qboolean
VID_AllocBuffers (int width, int height)
{
	int         zbuffersize, cachesize;

	// Calculate the sizes we want first

	zbuffersize = width * height * sizeof (*d_pzbuffer);
	cachesize = D_SurfaceCacheForRes (width, height);

	// Free the old z-buffer
	if (d_pzbuffer) {
		free (d_pzbuffer);
		d_pzbuffer = NULL;
	}
	// Free the old surface cache
	vid_surfcache = D_SurfaceCacheAddress ();

	if (vid_surfcache) {
		D_FlushCaches ();
		free (vid_surfcache);
		vid_surfcache = NULL;
	}
	// Allocate the new z-buffer
	d_pzbuffer = calloc (zbuffersize, 1);
	if (!d_pzbuffer) {
		Sys_Error ("Not enough memory for video mode");
		return false;
	}
	// Allocate the new surface cache; free the z-buffer if we fail
	vid_surfcache = calloc (cachesize, 1);
	if (!vid_surfcache) {
		free (d_pzbuffer);
		d_pzbuffer = NULL;
		Sys_Error ("Not enough memory for video mode");
		return false;
	}
	vid_surfcachesize = cachesize;

	return true;
}

void
initFatalError (void)
{
	MGL_exit ();
	MGL_fatalError (MGL_errorMsg (MGL_result ()));
	exit (EXIT_FAILURE);
}

#if 0									// def NEW_SUSPEND

int
VID_Suspend (MGLDC * dc, int flags)
{
	int         i;

	if (flags & MGL_DEACTIVATE) {
		IN_RestoreOriginalMouseState ();
		CDAudio_Pause ();

		// keep WM_PAINT from trying to redraw
		in_mode_set = true;
		block_drawing = true;
	} else if (flags & MGL_REACTIVATE) {
		IN_SetQuakeMouseState ();
		// fix leftover Alt from any Alt-Tab or the like that switched us away
		IN_ClearStates ();
		CDAudio_Resume ();
		in_mode_set = false;

		block_drawing = false;
//		vid.recalc_refdef = 1;
		force_mode_set = 1;
		i = msg_suppress_1;
		msg_suppress_1 = 1;
		VID_Fullscreen_f ();
		msg_suppress_1 = i;
		force_mode_set = 0;
	}

	return 1;
}

#else

int
VID_Suspend (MGLDC * dc, int flags)
{

	if (flags & MGL_DEACTIVATE) {
		// FIXME: this doesn't currently work on NT
		if (block_switch->int_val && !WinNT) {
			return MGL_NO_DEACTIVATE;
		}

		S_BlockSound ();
		S_ClearBuffer ();

		IN_RestoreOriginalMouseState ();
		CDAudio_Pause ();

		// keep WM_PAINT from trying to redraw
		in_mode_set = true;

		block_drawing = true;			// so we don't try to draw while
										// switched away
	} else if (flags & MGL_REACTIVATE) {
		IN_SetQuakeMouseState ();
		// fix leftover Alt from any Alt-Tab or the like that switched us away
		IN_ClearStates ();
		CDAudio_Resume ();
		S_UnblockSound ();

		in_mode_set = false;

		vid.recalc_refdef = 1;

		block_drawing = false;
	}

	return MGL_NO_SUSPEND_APP;
}

#endif

void
registerAllDispDrivers (void)
{
	/* Event though these driver require WinDirect, we register * them so
	   that they will still be available even if DirectDraw * is present and
	   the user has disable the high performance * WinDirect modes. */
	MGL_registerDriver (MGL_VGA8NAME, VGA8_driver);
//	MGL_registerDriver(MGL_VGAXNAME, VGAX_driver);

	/* Register display drivers */
	if (useWinDirect) {
/* we don't want VESA 1.X drivers
		MGL_registerDriver(MGL_SVGA8NAME, SVGA8_driver);
*/
		MGL_registerDriver (MGL_LINEAR8NAME, LINEAR8_driver);

		if (!COM_CheckParm ("-novbeaf"))
			MGL_registerDriver (MGL_ACCEL8NAME, ACCEL8_driver);
	}

	if (useDirectDraw) {
		MGL_registerDriver (MGL_DDRAW8NAME, DDRAW8_driver);
	}
}

void
registerAllMemDrivers (void)
{
	/* Register memory context drivers */
	MGL_registerDriver (MGL_PACKED8NAME, PACKED8_driver);
}

void
VID_InitMGLFull (HINSTANCE hInstance)
{
	int         i, xRes, yRes, bits, lowres, curmode, temp;
	int         lowstretchedres, stretchedmode = 0, lowstretched;
	uchar      *m;

// FIXME: NT is checked for because MGL currently has a bug that causes it
// to try to use WinDirect modes even on NT
	if (COM_CheckParm ("-nowindirect") ||
		COM_CheckParm ("-nowd") || COM_CheckParm ("-novesa") || WinNT) {
		useWinDirect = false;
	}

	if (COM_CheckParm ("-nodirectdraw") || COM_CheckParm ("-noddraw")
		|| COM_CheckParm ("-nodd"))
		useDirectDraw = false;

	// Initialise the MGL
	MGL_unregisterAllDrivers ();
	registerAllDispDrivers ();
	registerAllMemDrivers ();
	MGL_detectGraph (&driver, &mode);
	m = MGL_availableModes ();

	if (m[0] != 0xFF) {
		lowres = lowstretchedres = 99999;
		lowstretched = 0;
		curmode = 0;

		// find the lowest-res mode, or a mode we can stretch up to and get
		// lowest-res that way
		for (i = 0; m[i] != 0xFF; i++) {
			MGL_modeResolution (m[i], &xRes, &yRes, &bits);

			if ((bits == 8) &&
				(xRes <= MAXWIDTH) &&
				(yRes <= MAXHEIGHT) && (curmode < MAX_MODE_LIST)) {
				if (m[i] == grVGA_320x200x256)
					is_mode0x13 = true;

				if (!COM_CheckParm ("-noforcevga")) {
					if (m[i] == grVGA_320x200x256) {
						mode = i;
						break;
					}
				}

				if (xRes < lowres) {
					lowres = xRes;
					mode = i;
				}

				if ((xRes < lowstretchedres) && ((xRes >> 1) >= 320)) {
					lowstretchedres = xRes >> 1;
					stretchedmode = i;
				}
			}

			curmode++;
		}

		// if there's a mode we can stretch by 2 up to, thereby effectively
		// getting a lower-res mode than the lowest-res real but still at least
		// 320x200, that will be our default mode
		if (lowstretchedres < lowres) {
			mode = stretchedmode;
			lowres = lowstretchedres;
			lowstretched = 1;
		}
		// build the mode list, leaving room for the low-res stretched mode,
		// if any
		nummodes++;						// leave room for default mode

		for (i = 0; m[i] != 0xFF; i++) {
			MGL_modeResolution (m[i], &xRes, &yRes, &bits);

			if ((bits == 8) &&
				(xRes <= MAXWIDTH) &&
				(yRes <= MAXHEIGHT) && (nummodes < MAX_MODE_LIST)) {
				if (i == mode) {
					if (lowstretched) {
						stretchedmode = nummodes;
						curmode = nummodes++;
					} else {
						curmode = MODE_FULLSCREEN_DEFAULT;
					}
				} else {
					curmode = nummodes++;
				}

				modelist[curmode].type = MS_FULLSCREEN;
				modelist[curmode].width = xRes;
				modelist[curmode].height = yRes;
				snprintf (modelist[curmode].modedesc,
						  sizeof (modelist[curmode].modedesc), "%dx%d", xRes,
						  yRes);

				if (m[i] == grVGA_320x200x256)
					modelist[curmode].mode13 = 1;
				else
					modelist[curmode].mode13 = 0;

				modelist[curmode].modenum = m[i];
				modelist[curmode].stretched = 0;
				modelist[curmode].dib = 0;
				modelist[curmode].fullscreen = 1;
				modelist[curmode].halfscreen = 0;
				modelist[curmode].bpp = 8;
			}
		}

		if (lowstretched) {
			modelist[MODE_FULLSCREEN_DEFAULT] = modelist[stretchedmode];
			modelist[MODE_FULLSCREEN_DEFAULT].stretched = 1;
			modelist[MODE_FULLSCREEN_DEFAULT].width >>= 1;
			modelist[MODE_FULLSCREEN_DEFAULT].height >>= 1;
			snprintf (modelist[MODE_FULLSCREEN_DEFAULT].modedesc,
					  sizeof (modelist[MODE_FULLSCREEN_DEFAULT].modedesc),
					  "%dx%d", modelist[MODE_FULLSCREEN_DEFAULT].width,
					  modelist[MODE_FULLSCREEN_DEFAULT].height);
		}

		vid_default = MODE_FULLSCREEN_DEFAULT;

		temp = m[0];

		if (!MGL_init (&driver, &temp, "")) {
			initFatalError ();
		}
	}

	MGL_setSuspendAppCallback (VID_Suspend);
}

/*
  createDisplayDC

  Returns pointer to the MGL device context to use for the application
  Initialises the MGL and creates an appropriate display device context to be
  used by the GUI. This creates and apropriate device context depending on the
  system being compile for, and should be the only place where system specific
  code is required.
*/
MGLDC      *
createDisplayDC (int forcemem)
{
	MGLDC      *dc;
	pixel_format_t pf;
	int         npages;

	// Start the specified video mode
	if (!MGL_changeDisplayMode (mode))
		initFatalError ();

	npages = MGL_availablePages (mode);

	if (npages > 3)
		npages = 3;

	if (!COM_CheckParm ("-notriplebuf")) {
		if (npages > 2) {
			npages = 2;
		}
	}

	if ((dc = MGL_createDisplayDC (npages)) == NULL)
		return NULL;

	if (!forcemem && (MGL_surfaceAccessType (dc)) == MGL_LINEAR_ACCESS
		&& (dc->mi.maxPage > 0)) {
		MGL_makeCurrentDC (dc);
		memdc = NULL;
	} else {
		// Set up for blitting from a memory buffer
		memdc = MGL_createMemoryDC (MGL_sizex (dc) + 1, MGL_sizey (dc) + 1, 8,
									&pf);
		MGL_makeCurrentDC (memdc);
	}

	// Enable page flipping even for even for blitted surfaces
	if (forcemem) {
		vid.numpages = 1;
	} else {
		vid.numpages = dc->mi.maxPage + 1;

		if (vid.numpages > 1) {
			// Set up for page flipping
			MGL_setActivePage (dc, aPage = 1);
			MGL_setVisualPage (dc, vPage = 0, false);
		}

		if (vid.numpages > 3)
			vid.numpages = 3;
	}

	if (vid.numpages == 2)
		waitVRT = true;
	else
		waitVRT = false;

	return dc;
}

void
VID_InitMGLDIB (HINSTANCE hInstance)
{
	WNDCLASS    wc;
	HDC         hdc;

	hIcon = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_ICON1));

	/* Register the frame class */
	wc.style = 0;
	wc.lpfnWndProc = (WNDPROC) MainWndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = 0;
	wc.hCursor = LoadCursor (NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = 0;
	wc.lpszClassName = "WinQuake";

	if (!RegisterClass (&wc))
		Sys_Error ("Couldn't register window class");

	/* Find the size for the DIB window */
	/* Initialise the MGL for windowed operation */
	MGL_setAppInstance (hInstance);
	registerAllMemDrivers ();
	MGL_initWindowed ("");

	modelist[0].type = MS_WINDOWED;
	modelist[0].width = 320;
	modelist[0].height = 240;
	strcpy (modelist[0].modedesc, "320x240");
	modelist[0].mode13 = 0;
	modelist[0].modenum = MODE_WINDOWED;
	modelist[0].stretched = 0;
	modelist[0].dib = 1;
	modelist[0].fullscreen = 0;
	modelist[0].halfscreen = 0;
	modelist[0].bpp = 8;

	modelist[1].type = MS_WINDOWED;
	modelist[1].width = 640;
	modelist[1].height = 480;
	strcpy (modelist[1].modedesc, "640x480");
	modelist[1].mode13 = 0;
	modelist[1].modenum = MODE_WINDOWED + 1;
	modelist[1].stretched = 1;
	modelist[1].dib = 1;
	modelist[1].fullscreen = 0;
	modelist[1].halfscreen = 0;
	modelist[1].bpp = 8;

	modelist[2].type = MS_WINDOWED;
	modelist[2].width = 800;
	modelist[2].height = 600;
	strcpy (modelist[2].modedesc, "800x600");
	modelist[2].mode13 = 0;
	modelist[2].modenum = MODE_WINDOWED + 2;
	modelist[2].stretched = 1;
	modelist[2].dib = 1;
	modelist[2].fullscreen = 0;
	modelist[2].halfscreen = 0;
	modelist[2].bpp = 8;

	// automatically stretch default mode up if > 640x480 desktop resolution
	hdc = GetDC (NULL);

	if ((GetDeviceCaps (hdc, HORZRES) > 640)
		&& !COM_CheckParm ("-noautostretch")) {
		vid_default = MODE_WINDOWED + 1;
	} else {
		vid_default = MODE_WINDOWED;
	}

	windowed_default = vid_default;

	ReleaseDC (NULL, hdc);

	nummodes = 3;						// reserve space for windowed mode

	DDActive = 0;
}

void
VID_InitFullDIB (HINSTANCE hInstance)
{
	DEVMODE     devmode;
	int         i, j, modenum, existingmode, originalnummodes, lowestres;
	int         numlowresmodes, bpp, done;
	int         cstretch, istretch, mstretch = 0;
	BOOL        stat;

	// enumerate 8 bpp modes
	originalnummodes = nummodes;
	modenum = 0;
	lowestres = 99999;

	do {
		stat = EnumDisplaySettings (NULL, modenum, &devmode);

		if ((devmode.dmBitsPerPel == 8) && (devmode.dmPelsWidth <= MAXWIDTH) &&
			(devmode.dmPelsHeight <= MAXHEIGHT) &&
			(nummodes < MAX_MODE_LIST))	{
			devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

			if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
				DISP_CHANGE_SUCCESSFUL) {
				modelist[nummodes].type = MS_FULLDIB;
				modelist[nummodes].width = devmode.dmPelsWidth;
				modelist[nummodes].height = devmode.dmPelsHeight;
				modelist[nummodes].modenum = 0;
				modelist[nummodes].mode13 = 0;
				modelist[nummodes].stretched = 0;
				modelist[nummodes].halfscreen = 0;
				modelist[nummodes].dib = 1;
				modelist[nummodes].fullscreen = 1;
				modelist[nummodes].bpp = devmode.dmBitsPerPel;
				snprintf (modelist[nummodes].modedesc,
						  sizeof (modelist[nummodes].modedesc), "%ldx%ld",
						  devmode.dmPelsWidth, devmode.dmPelsHeight);

				// if the width is more than twice the height, reduce it by
				// half because this
				// is probably a dual-screen monitor
				if (!COM_CheckParm ("-noadjustaspect")) {
					if (modelist[nummodes].width >
						(modelist[nummodes].height << 1)) {
						modelist[nummodes].width >>= 1;
						modelist[nummodes].halfscreen = 1;
						snprintf (modelist[nummodes].modedesc,
								  sizeof (modelist[nummodes].modedesc),
								  "%dx%d", modelist[nummodes].width,
								  modelist[nummodes].height);
					}
				}

				for (i = originalnummodes, existingmode = 0; i < nummodes;
					 i++) {
					if ((modelist[nummodes].width == modelist[i].width) &&
						(modelist[nummodes].height == modelist[i].height)) {
						existingmode = 1;
						break;
					}
				}

				if (!existingmode) {
					if (modelist[nummodes].width < lowestres)
						lowestres = modelist[nummodes].width;

					nummodes++;
				}
			}
		}

		modenum++;
	} while (stat);

// see if any of them were actually settable; if so, this is our mode list,
// else enumerate all modes; our mode list is whichever ones are settable
// with > 8 bpp
	if (nummodes == originalnummodes) {
		modenum = 0;
		lowestres = 99999;

		Con_Printf ("No 8-bpp fullscreen DIB modes found\n");

		do {
			stat = EnumDisplaySettings (NULL, modenum, &devmode);

			if ((((devmode.dmPelsWidth <= MAXWIDTH) &&
				  (devmode.dmPelsHeight <= MAXHEIGHT)) ||
				 (!COM_CheckParm ("-noadjustaspect") &&
				  (devmode.dmPelsWidth <= (MAXWIDTH * 2)) &&
				  (devmode.dmPelsWidth > (devmode.dmPelsHeight * 2)))) &&
				(nummodes < MAX_MODE_LIST) && (devmode.dmBitsPerPel > 8)) {
				devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH |
					DM_PELSHEIGHT;

				if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN)
					== DISP_CHANGE_SUCCESSFUL) {
					modelist[nummodes].type = MS_FULLDIB;
					modelist[nummodes].width = devmode.dmPelsWidth;
					modelist[nummodes].height = devmode.dmPelsHeight;
					modelist[nummodes].modenum = 0;
					modelist[nummodes].mode13 = 0;
					modelist[nummodes].stretched = 0;
					modelist[nummodes].halfscreen = 0;
					modelist[nummodes].dib = 1;
					modelist[nummodes].fullscreen = 1;
					modelist[nummodes].bpp = devmode.dmBitsPerPel;
					snprintf (modelist[nummodes].modedesc,
							  sizeof (modelist[nummodes].modedesc), "%ldx%ld",
							  devmode.dmPelsWidth, devmode.dmPelsHeight);

					// if the width is more than twice the height, reduce it
					// by half because this is probably a dual-screen monitor
					if (!COM_CheckParm ("-noadjustaspect")) {
						if (modelist[nummodes].width >
							(modelist[nummodes].height * 2)) {
							modelist[nummodes].width >>= 1;
							modelist[nummodes].halfscreen = 1;
							snprintf (modelist[nummodes].modedesc,
									  sizeof (modelist[nummodes].modedesc),
									  "%dx%d", modelist[nummodes].width,
									  modelist[nummodes].height);
						}
					}

					for (i = originalnummodes, existingmode = 0; i < nummodes;
						 i++) {
						if ((modelist[nummodes].width == modelist[i].width)
							&& (modelist[nummodes].height ==
								modelist[i].height)) {
							// pick the lowest available bpp
							if (modelist[nummodes].bpp < modelist[i].bpp)
								modelist[i] = modelist[nummodes];

							existingmode = 1;
							break;
						}
					}

					if (!existingmode) {
						if (modelist[nummodes].width < lowestres)
							lowestres = modelist[nummodes].width;

						nummodes++;
					}
				}
			}

			modenum++;
		} while (stat);
	}
	// see if there are any low-res modes that aren't being reported
	numlowresmodes = sizeof (lowresmodes) / sizeof (lowresmodes[0]);
	bpp = 8;
	done = 0;

	// first make sure the driver doesn't just answer yes to all tests
	devmode.dmBitsPerPel = 8;
	devmode.dmPelsWidth = 42;
	devmode.dmPelsHeight = 37;
	devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

	if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
		DISP_CHANGE_SUCCESSFUL) {
		done = 1;
	}

	while (!done) {
		for (j = 0; (j < numlowresmodes) && (nummodes < MAX_MODE_LIST); j++) {
			devmode.dmBitsPerPel = bpp;
			devmode.dmPelsWidth = lowresmodes[j].width;
			devmode.dmPelsHeight = lowresmodes[j].height;
			devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

			if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
				DISP_CHANGE_SUCCESSFUL) {
				modelist[nummodes].type = MS_FULLDIB;
				modelist[nummodes].width = devmode.dmPelsWidth;
				modelist[nummodes].height = devmode.dmPelsHeight;
				modelist[nummodes].modenum = 0;
				modelist[nummodes].mode13 = 0;
				modelist[nummodes].stretched = 0;
				modelist[nummodes].halfscreen = 0;
				modelist[nummodes].dib = 1;
				modelist[nummodes].fullscreen = 1;
				modelist[nummodes].bpp = devmode.dmBitsPerPel;
				snprintf (modelist[nummodes].modedesc,
						  sizeof (modelist[nummodes].modedesc), "%ldx%ld",
						  devmode.dmPelsWidth, devmode.dmPelsHeight);

				// we only want the lowest-bpp version of each mode
				for (i = originalnummodes, existingmode = 0; i < nummodes;
					 i++) {
					if ((modelist[nummodes].width == modelist[i].width) &&
						(modelist[nummodes].height == modelist[i].height) &&
						(modelist[nummodes].bpp >= modelist[i].bpp)) {
						existingmode = 1;
						break;
					}
				}

				if (!existingmode) {
					if (modelist[nummodes].width < lowestres)
						lowestres = modelist[nummodes].width;

					nummodes++;
				}
			}
		}

		switch (bpp) {
			case 8:
				bpp = 16;
				break;

			case 16:
				bpp = 32;
				break;

			case 32:
				done = 1;
				break;
		}
	}

	// now add the lowest stretch-by-2 pseudo-modes between 320-wide
	// (inclusive) and lowest real res (not inclusive) don't bother if we have
	// a real VGA mode 0x13 mode
	if (!is_mode0x13) {
		for (i = originalnummodes, cstretch = 0; i < nummodes; i++) {
			if (((modelist[i].width >> 1) < lowestres) &&
				((modelist[i].width >> 1) >= 320)) {
				lowestres = modelist[i].width >> 1;
				cstretch = 1;
				mstretch = i;
			}
		}

		if ((nummodes + cstretch) > MAX_MODE_LIST)
			cstretch = MAX_MODE_LIST - nummodes;

		if (cstretch > 0) {
			for (i = (nummodes - 1); i >= originalnummodes; i--)
				modelist[i + cstretch] = modelist[i];

			nummodes += cstretch;
			istretch = originalnummodes;

			modelist[istretch] = modelist[mstretch];
			modelist[istretch].width >>= 1;
			modelist[istretch].height >>= 1;
			modelist[istretch].stretched = 1;
			snprintf (modelist[istretch].modedesc,
					  sizeof (modelist[istretch].modedesc), "%dx%d",
					  modelist[istretch].width, modelist[istretch].height);
		}
	}

	if (nummodes != originalnummodes)
		vid_default = MODE_FULLSCREEN_DEFAULT;
	else
		Con_Printf ("No fullscreen DIB modes found\n");
}

int
VID_NumModes (void)
{
	return nummodes;
}

vmode_t    *
VID_GetModePtr (int modenum)
{

	if ((modenum >= 0) && (modenum < nummodes))
		return &modelist[modenum];
	else
		return &badmode;
}

void
VID_CheckModedescFixup (int mode)
{
	int         x, y, stretch;

	if (mode == MODE_SETTABLE_WINDOW) {
		modelist[mode].stretched = vid_stretch_by_2->int_val;
		stretch = modelist[mode].stretched;

		Cvar_SetValue (vid_config_x,
					   max (vid_config_x->int_val, 320 << stretch));
		Cvar_SetValue (vid_config_y,
					   max (vid_config_y->int_val, 200 << stretch));

		x = vid_config_x->int_val;
		y = vid_config_y->int_val;
		snprintf (modelist[mode].modedesc, sizeof (modelist[mode].modedesc),
				  "%dx%d", x, y);
		modelist[mode].width = x;
		modelist[mode].height = y;
	}
}

char       *
VID_GetModeDescriptionMemCheck (int mode)
{
	char       *pinfo;
	vmode_t    *pv;

	if ((mode < 0) || (mode >= nummodes))
		return NULL;

	VID_CheckModedescFixup (mode);

	pv = VID_GetModePtr (mode);
	pinfo = pv->modedesc;

	if (VID_CheckAdequateMem (pv->width, pv->height)) {
		return pinfo;
	} else {
		return NULL;
	}
}

char       *
VID_GetModeDescription (int mode)
{
	char       *pinfo;
	vmode_t    *pv;

	if ((mode < 0) || (mode >= nummodes))
		return NULL;

	VID_CheckModedescFixup (mode);

	pv = VID_GetModePtr (mode);
	pinfo = pv->modedesc;
	return pinfo;
}

/*
	VID_GetModeDescription2

	Tacks on "windowed" or "fullscreen"
*/
char       *
VID_GetModeDescription2 (int mode)
{
	static char pinfo[40];
	vmode_t    *pv;

	if ((mode < 0) || (mode >= nummodes))
		return NULL;

	VID_CheckModedescFixup (mode);

	pv = VID_GetModePtr (mode);

	if (modelist[mode].type == MS_FULLSCREEN) {
		snprintf (pinfo, sizeof (pinfo), "%s fullscreen", pv->modedesc);
	} else if (modelist[mode].type == MS_FULLDIB) {
		snprintf (pinfo, sizeof (pinfo), "%s fullscreen", pv->modedesc);
	} else {
		snprintf (pinfo, sizeof (pinfo), "%s windowed", pv->modedesc);
	}

	return pinfo;
}

// KJB: Added this to return the mode driver name in description for console
char       *
VID_GetExtModeDescription (int mode)
{
	static char pinfo[40];
	vmode_t    *pv;

	if ((mode < 0) || (mode >= nummodes))
		return NULL;

	VID_CheckModedescFixup (mode);

	pv = VID_GetModePtr (mode);
	if (modelist[mode].type == MS_FULLSCREEN) {
		snprintf (pinfo, sizeof (pinfo), "%s fullscreen %s", pv->modedesc,
				  MGL_modeDriverName (pv->modenum));
	} else if (modelist[mode].type == MS_FULLDIB) {
		snprintf (pinfo, sizeof (pinfo), "%s fullscreen DIB", pv->modedesc);
	} else {
		snprintf (pinfo, sizeof (pinfo), "%s windowed", pv->modedesc);
	}

	return pinfo;
}

void
DestroyDIBWindow (void)
{

	if (modestate == MS_WINDOWED) {
		// destroy the associated MGL DC's; the window gets reused
		if (windc)
			MGL_destroyDC (windc);
		if (dibdc)
			MGL_destroyDC (dibdc);
		windc = dibdc = NULL;
	}
}

void
DestroyFullscreenWindow (void)
{
	if (modestate == MS_FULLSCREEN) {
		// destroy the existing fullscreen mode and DC's
		if (mgldc)
			MGL_destroyDC (mgldc);
		if (memdc)
			MGL_destroyDC (memdc);
		mgldc = memdc = NULL;
	}
}

void
DestroyFullDIBWindow (void)
{
	if (modestate == MS_FULLDIB) {
		ChangeDisplaySettings (NULL, CDS_FULLSCREEN);

		// Destroy the fullscreen DIB window and associated MGL DC's
		if (windc)
			MGL_destroyDC (windc);
		if (dibdc)
			MGL_destroyDC (dibdc);
		windc = dibdc = NULL;
	}
}

qboolean
VID_SetWindowedMode (int modenum)
{
	HDC         hdc;
	pixel_format_t pf;
	qboolean    stretched;
	int         lastmodestate;

	if (!windowed_mode_set) {
		if (COM_CheckParm ("-resetwinpos")) {
			Cvar_SetValue (vid_window_x, 0.0);
			Cvar_SetValue (vid_window_y, 0.0);
		}

		windowed_mode_set = 1;
	}

	VID_CheckModedescFixup (modenum);

	DDActive = 0;
	lastmodestate = modestate;

	DestroyFullscreenWindow ();
	DestroyFullDIBWindow ();

	if (windc)
		MGL_destroyDC (windc);
	if (dibdc)
		MGL_destroyDC (dibdc);
	windc = dibdc = NULL;

	// KJB: Signal to the MGL that we are going back to windowed mode
	if (!MGL_changeDisplayMode (grWINDOWED))
		initFatalError ();

	WindowRect.top = WindowRect.left = 0;

	WindowRect.right = modelist[modenum].width;
	WindowRect.bottom = modelist[modenum].height;
	stretched = modelist[modenum].stretched;

	DIBWidth = modelist[modenum].width;
	DIBHeight = modelist[modenum].height;

	if (stretched) {
		DIBWidth >>= 1;
		DIBHeight >>= 1;
	}

	WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU |
		WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
	ExWindowStyle = 0;
	AdjustWindowRectEx (&WindowRect, WindowStyle, FALSE, 0);

	// the first time we're called to set the mode, create the window we'll use
	// for the rest of the session
	if (!vid_mode_set) {
		mainwindow = CreateWindowEx (ExWindowStyle, "WinQuake", PROGRAM,
									 WindowStyle, 0, 0,
									 WindowRect.right - WindowRect.left,
									 WindowRect.bottom - WindowRect.top,
									 NULL, NULL, global_hInstance, NULL);
		if (!mainwindow)
			Sys_Error ("Couldn't create DIB window");

		// tell MGL to use this window for fullscreen modes
		MGL_registerFullScreenWindow (mainwindow);

		vid_mode_set = true;
	} else {
		SetWindowLong (mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
		SetWindowLong (mainwindow, GWL_EXSTYLE, ExWindowStyle);
	}

	if (!SetWindowPos (mainwindow, NULL, 0, 0,
					   WindowRect.right - WindowRect.left,
					   WindowRect.bottom - WindowRect.top,
					   SWP_NOCOPYBITS | SWP_NOZORDER | SWP_HIDEWINDOW)) {
		Sys_Error ("Couldn't resize DIB window");
	}

	if (hide_window)
		return true;

	// position and show the DIB window
	VID_CheckWindowXY ();
	SetWindowPos (mainwindow, NULL, vid_window_x->int_val,
				  vid_window_y->int_val, 0, 0,
				  SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);

	if (force_minimized)
		ShowWindow (mainwindow, SW_MINIMIZE);
	else
		ShowWindow (mainwindow, SW_SHOWDEFAULT);

	UpdateWindow (mainwindow);

	modestate = MS_WINDOWED;
	vid_fulldib_on_focus_mode = 0;

// because we have set the background brush for the window to NULL
// (to avoid flickering when re-sizing the window on the desktop),
// we clear the window to black when created, otherwise it will be
// empty while Quake starts up.
	hdc = GetDC (mainwindow);
	PatBlt (hdc, 0, 0, WindowRect.right, WindowRect.bottom, BLACKNESS);
	ReleaseDC (mainwindow, hdc);

	/* Create the MGL window DC and the MGL memory DC */
	if ((windc = MGL_createWindowedDC (mainwindow)) == NULL)
		MGL_fatalError ("Unable to create Windowed DC!");

	if ((dibdc = MGL_createMemoryDC (DIBWidth, DIBHeight, 8, &pf)) == NULL)
		MGL_fatalError ("Unable to create Memory DC!");

	MGL_makeCurrentDC (dibdc);

	vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
	vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
	vid.numpages = 1;
	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;
	vid.height = vid.conheight = DIBHeight;
	vid.width = vid.conwidth = DIBWidth;
	vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);

	vid_stretched = stretched;

	SendMessage (mainwindow, WM_SETICON, (WPARAM) TRUE, (LPARAM) hIcon);
	SendMessage (mainwindow, WM_SETICON, (WPARAM) FALSE, (LPARAM) hIcon);

	return true;
}

qboolean
VID_SetFullscreenMode (int modenum)
{

	DDActive = 1;

	DestroyDIBWindow ();
	DestroyFullDIBWindow ();

	mode = modelist[modenum].modenum;

	// Destroy old DC's, resetting back to fullscreen mode
	if (mgldc)
		MGL_destroyDC (mgldc);
	if (memdc)
		MGL_destroyDC (memdc);
	mgldc = memdc = NULL;

	if ((mgldc = createDisplayDC (modelist[modenum].stretched ||
								  vid_nopageflip->int_val)) == NULL) {
		return false;
	}

	modestate = MS_FULLSCREEN;
	vid_fulldib_on_focus_mode = 0;

	vid.buffer = vid.conbuffer = vid.direct = NULL;
	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;
	DIBHeight = vid.height = vid.conheight = modelist[modenum].height;
	DIBWidth = vid.width = vid.conwidth = modelist[modenum].width;
	vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);

	vid_stretched = modelist[modenum].stretched;

	// needed because we're not getting WM_MOVE messages fullscreen on NT
	window_x = 0;
	window_y = 0;

	// set the large icon, so the Quake icon will show up in the taskbar
	SendMessage (mainwindow, WM_SETICON, (WPARAM) 1, (LPARAM) hIcon);
	SendMessage (mainwindow, WM_SETICON, (WPARAM) 0, (LPARAM) hIcon);

	// shouldn't be needed, but Kendall needs to let us get the activation
	// message for this not to be needed on NT
	AppActivate (true, false);

	return true;
}

qboolean
VID_SetFullDIBMode (int modenum)
{
	HDC         hdc;
	pixel_format_t pf;
	int         lastmodestate;

	DDActive = 0;

	DestroyFullscreenWindow ();
	DestroyDIBWindow ();

	if (windc)
		MGL_destroyDC (windc);
	if (dibdc)
		MGL_destroyDC (dibdc);
	windc = dibdc = NULL;

	// KJB: Signal to the MGL that we are going back to windowed mode
	if (!MGL_changeDisplayMode (grWINDOWED))
		initFatalError ();

	gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
	gdevmode.dmBitsPerPel = modelist[modenum].bpp;
	gdevmode.dmPelsWidth =
		modelist[modenum].width << modelist[modenum].
		stretched << modelist[modenum].halfscreen;
	gdevmode.dmPelsHeight =
		modelist[modenum].height << modelist[modenum].stretched;
	gdevmode.dmSize = sizeof (gdevmode);

	if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) !=
		DISP_CHANGE_SUCCESSFUL) Sys_Error ("Couldn't set fullscreen DIB mode");

	lastmodestate = modestate;
	modestate = MS_FULLDIB;
	vid_fulldib_on_focus_mode = modenum;

	WindowRect.top = WindowRect.left = 0;

	hdc = GetDC (NULL);

	WindowRect.right = modelist[modenum].width << modelist[modenum].stretched;
	WindowRect.bottom = modelist[modenum].height <<
		modelist[modenum].stretched;

	ReleaseDC (NULL, hdc);

	DIBWidth = modelist[modenum].width;
	DIBHeight = modelist[modenum].height;

	WindowStyle = WS_POPUP | WS_SYSMENU | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
	ExWindowStyle = 0;
	AdjustWindowRectEx (&WindowRect, WindowStyle, FALSE, 0);

	SetWindowLong (mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
	SetWindowLong (mainwindow, GWL_EXSTYLE, ExWindowStyle);

	if (!SetWindowPos (mainwindow, NULL, 0, 0,
					   WindowRect.right - WindowRect.left,
					   WindowRect.bottom - WindowRect.top,
					   SWP_NOCOPYBITS | SWP_NOZORDER)) {
		Sys_Error ("Couldn't resize DIB window");
	}
	// position and show the DIB window
	SetWindowPos (mainwindow, HWND_TOPMOST, 0, 0, 0, 0,
				  SWP_NOSIZE | SWP_SHOWWINDOW | SWP_DRAWFRAME);
	ShowWindow (mainwindow, SW_SHOWDEFAULT);
	UpdateWindow (mainwindow);

	// Because we have set the background brush for the window to NULL
	// (to avoid flickering when re-sizing the window on the desktop), we
	// clear the window to black when created, otherwise it will be
	// empty while Quake starts up.
	hdc = GetDC (mainwindow);
	PatBlt (hdc, 0, 0, WindowRect.right, WindowRect.bottom, BLACKNESS);
	ReleaseDC (mainwindow, hdc);

	/* Create the MGL window DC and the MGL memory DC */
	if ((windc = MGL_createWindowedDC (mainwindow)) == NULL)
		MGL_fatalError ("Unable to create Fullscreen DIB DC!");

	if ((dibdc = MGL_createMemoryDC (DIBWidth, DIBHeight, 8, &pf)) == NULL)
		MGL_fatalError ("Unable to create Memory DC!");

	MGL_makeCurrentDC (dibdc);

	vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
	vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
	vid.numpages = 1;
	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;
	vid.height = vid.conheight = DIBHeight;
	vid.width = vid.conwidth = DIBWidth;
	vid.aspect = ((float) vid.height / (float) vid.width) * (320.0 / 240.0);

	vid_stretched = modelist[modenum].stretched;

	// needed because we're not getting WM_MOVE messages fullscreen on NT
	window_x = 0;
	window_y = 0;

	return true;
}

void
VID_RestoreOldMode (int original_mode)
{
	static qboolean inerror = false;

	if (inerror)
		return;

	in_mode_set = false;
	inerror = true;

	// make sure mode set happens (video mode changes)
	vid_modenum = original_mode - 1;

	if (!VID_SetMode (original_mode, vid_curpal)) {
		vid_modenum = MODE_WINDOWED - 1;

		if (!VID_SetMode (windowed_default, vid_curpal))
			Sys_Error ("Can't set any video mode");
	}

	inerror = false;
}

void
VID_SetDefaultMode (void)
{

	if (vid.initialized)
		VID_SetMode (0, vid_curpal);

	IN_DeactivateMouse ();
}

int
VID_SetMode (int modenum, unsigned char *palette)
{
	int         original_mode, temp;
	qboolean    stat;
	MSG         msg;
	HDC         hdc;

	while ((modenum >= nummodes) || (modenum < 0)) {
		if (vid_modenum == NO_MODE) {
			if (modenum == vid_default) {
				modenum = windowed_default;
			} else {
				modenum = vid_default;
			}

			Cvar_SetValue (vid_mode, modenum);
		} else {
			Cvar_SetValue (vid_mode, vid_modenum);
			return 0;
		}
	}

	if (!force_mode_set && (modenum == vid_modenum))
		return true;

	// so Con_Printfs don't mess us up by forcing vid and snd updates
	temp = scr_disabled_for_loading;
	scr_disabled_for_loading = true;
	in_mode_set = true;

	CDAudio_Pause ();
	S_ClearBuffer ();

	if (vid_modenum == NO_MODE)
		original_mode = windowed_default;
	else
		original_mode = vid_modenum;

	// Set either the fullscreen or windowed mode
	if (modelist[modenum].type == MS_WINDOWED) {
		if (in_grab->int_val && key_dest == key_game) {
			stat = VID_SetWindowedMode (modenum);
			IN_ActivateMouse ();
			IN_HideMouse ();
		} else {
			IN_DeactivateMouse ();
			IN_ShowMouse ();
			stat = VID_SetWindowedMode (modenum);
		}
	} else if (modelist[modenum].type == MS_FULLDIB) {
		stat = VID_SetFullDIBMode (modenum);
		IN_ActivateMouse ();
		IN_HideMouse ();
	} else {
		stat = VID_SetFullscreenMode (modenum);
		IN_ActivateMouse ();
		IN_HideMouse ();
	}

	window_width = vid.width << vid_stretched;
	window_height = vid.height << vid_stretched;
	VID_UpdateWindowStatus (window_x, window_y);

	CDAudio_Resume ();
	scr_disabled_for_loading = temp;

	if (!stat) {
		VID_RestoreOldMode (original_mode);
		return false;
	}

	if (hide_window)
		return true;

// now we try to make sure we get the focus on the mode switch, because
// sometimes in some systems we don't.  We grab the foreground, then
// finish setting up, pump all our messages, and sleep for a little while
// to let messages finish bouncing around the system, then we put
// ourselves at the top of the z order, then grab the foreground again,
// Who knows if it helps, but it probably doesn't hurt
	if (!force_minimized)
		SetForegroundWindow (mainwindow);

	hdc = GetDC (NULL);

	if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE)
		vid_palettized = true;
	else
		vid_palettized = false;

	VID_SetPalette (palette);

	ReleaseDC (NULL, hdc);

	vid_modenum = modenum;
	Cvar_SetValue (vid_mode, vid_modenum);

	if (!VID_AllocBuffers (vid.width, vid.height)) {
		// couldn't get memory for this mode; try to fall back to previous
		// mode
		VID_RestoreOldMode (original_mode);
		return false;
	}

	D_InitCaches (vid_surfcache, vid_surfcachesize);

	while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE)) {
		TranslateMessage (&msg);
		DispatchMessage (&msg);
	}

	Sleep (100);

	if (!force_minimized) {
		SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0, SWP_DRAWFRAME |
					  SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW |
					  SWP_NOCOPYBITS);

		SetForegroundWindow (mainwindow);
	}

	// fix the leftover Alt from any Alt-Tab or the like that switched us away
	IN_ClearStates ();

	Con_Printf ("Video mode %s initialized\n",
				VID_GetModeDescription (vid_modenum));

	VID_SetPalette (palette);

	in_mode_set = false;
	vid.recalc_refdef = 1;

	return true;
}

void
VID_LockBuffer (void)
{
	if (dibdc)
		return;

	lockcount++;

	if (lockcount > 1)
		return;

	MGL_beginDirectAccess ();

	if (memdc) {
		// Update surface pointer for linear access modes
		vid.buffer = vid.conbuffer = vid.direct = memdc->surface;
		vid.rowbytes = vid.conrowbytes = memdc->mi.bytesPerLine;
	} else if (mgldc) {
		// Update surface pointer for linear access modes
		vid.buffer = vid.conbuffer = vid.direct = mgldc->surface;
		vid.rowbytes = vid.conrowbytes = mgldc->mi.bytesPerLine;
	}

	if (r_dowarp)
		d_viewbuffer = r_warpbuffer;
	else
		d_viewbuffer = (void *) (byte *) vid.buffer;

	if (r_dowarp)
		screenwidth = WARP_WIDTH;
	else
		screenwidth = vid.rowbytes;
}

void
VID_UnlockBuffer (void)
{
	if (dibdc)
		return;

	lockcount--;

	if (lockcount > 0)
		return;

	if (lockcount < 0)
		Sys_Error ("Unbalanced unlock");

	MGL_endDirectAccess ();

// to turn up any unlocked accesses
	vid.buffer = vid.conbuffer = vid.direct = d_viewbuffer = NULL;
}

int
VID_ForceUnlockedAndReturnState (void)
{
	int         lk;

	if (!lockcount)
		return 0;

	lk = lockcount;

	if (dibdc) {
		lockcount = 0;
	} else {
		lockcount = 1;
		VID_UnlockBuffer ();
	}

	return lk;
}

void
VID_ForceLockState (int lk)
{
	if (!dibdc && lk) {
		lockcount = 0;
		VID_LockBuffer ();
	}

	lockcount = lk;
}

void
VID_SetPalette (unsigned char *palette)
{
	INT         i;
	palette_t   pal[256];
	HDC         hdc;

	if (!Minimized) {
		palette_changed = true;

		// make sure we have the static colors if we're the active app
		hdc = GetDC (NULL);

		if (vid_palettized && ActiveApp) {
			if (GetSystemPaletteUse (hdc) == SYSPAL_STATIC) {
				// switch to SYSPAL_NOSTATIC and remap the colors
				SetSystemPaletteUse (hdc, SYSPAL_NOSTATIC);
				syscolchg = true;
				pal_is_nostatic = true;
			}
		}

		ReleaseDC (NULL, hdc);

		// Translate the palette values to an MGL palette array and
		// set the values.
		for (i = 0; i < 256; i++) {
			pal[i].red = palette[i * 3];
			pal[i].green = palette[i * 3 + 1];
			pal[i].blue = palette[i * 3 + 2];
		}

		if (DDActive) {
			if (!mgldc)
				return;

			MGL_setPalette (mgldc, pal, 256, 0);
			MGL_realizePalette (mgldc, 256, 0, false);
			if (memdc)
				MGL_setPalette (memdc, pal, 256, 0);
		} else {
			if (!windc)
				return;

			MGL_setPalette (windc, pal, 256, 0);
			MGL_realizePalette (windc, 256, 0, false);
			if (dibdc) {
				MGL_setPalette (dibdc, pal, 256, 0);
				MGL_realizePalette (dibdc, 256, 0, false);
			}
		}
	}

	memcpy (vid_curpal, palette, sizeof (vid_curpal));

	if (syscolchg) {
		PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM) 0,
					 (LPARAM) 0);
		syscolchg = false;
	}
}

void
VID_DescribeCurrentMode_f (void)
{
	Con_Printf ("%s\n", VID_GetExtModeDescription (vid_modenum));
}

void
VID_NumModes_f (void)
{

	if (nummodes == 1)
		Con_Printf ("%d video mode is available\n", nummodes);
	else
		Con_Printf ("%d video modes are available\n", nummodes);
}

void
VID_DescribeMode_f (void)
{
	int         modenum;

	modenum = atoi (Cmd_Argv (1));

	Con_Printf ("%s\n", VID_GetExtModeDescription (modenum));
}

void
VID_DescribeModes_f (void)
{
	int         i, lnummodes;
	char       *pinfo;
	qboolean    na;
	vmode_t    *pv;

	na = false;

	lnummodes = VID_NumModes ();

	for (i = 0; i < lnummodes; i++) {
		pv = VID_GetModePtr (i);
		pinfo = VID_GetExtModeDescription (i);

		if (VID_CheckAdequateMem (pv->width, pv->height)) {
			Con_Printf ("%2d: %s\n", i, pinfo);
		} else {
			Con_Printf ("**: %s\n", pinfo);
			na = true;
		}
	}

	if (na) {
		Con_Printf ("\n[**: not enough system RAM for mode]\n");
	}
}

void
VID_TestMode_f (void)
{
	int         modenum;
	double      testduration;

	if (!vid_testingmode) {
		modenum = atoi (Cmd_Argv (1));

		if (VID_SetMode (modenum, vid_curpal)) {
			vid_testingmode = 1;
			testduration = atof (Cmd_Argv (2));
			if (testduration == 0)
				testduration = 5.0;
			vid_testendtime = realtime + testduration;
		}
	}
}

void
VID_Windowed_f (void)
{

	VID_SetMode (vid_windowed_mode->int_val, vid_curpal);
}

void
VID_Fullscreen_f (void)
{

	VID_SetMode (vid_fullscreen_mode->int_val, vid_curpal);
}

void
VID_Minimize_f (void)
{
	// we only support minimizing windows; if you're fullscreen,
	// switch to windowed first
	if (modestate == MS_WINDOWED)
		ShowWindow (mainwindow, SW_MINIMIZE);
}

void
VID_ForceMode_f (void)
{
	int         modenum;

	if (!vid_testingmode) {
		modenum = atoi (Cmd_Argv (1));

		force_mode_set = 1;
		VID_SetMode (modenum, vid_curpal);
		force_mode_set = 0;
	}
}

void
VID_Init (unsigned char *palette)
{
	int         i, bestmatch = 0, bestmatchmetric, t, dr, dg, db;
	int         basenummodes;
	byte       *ptmp;

	Cmd_AddCommand ("vid_testmode", VID_TestMode_f, "Switch to another video "
					"mode temporarily for 5-seconds to test it.\n"
					"(vid_testmode (mode))");
	Cmd_AddCommand ("vid_nummodes", VID_NumModes_f, "Reports the total number "
					"of video modes available");
	Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f,
					"Report current video mode.");
	Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f, "Report "
					"information on specified video mode, default is "
					"current.\n(vid_describemode (mode))");
	Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f, "Report "
					"information on all video modes.");
	Cmd_AddCommand ("vid_forcemode", VID_ForceMode_f, "Force QuakeWorld to "
					"use a certain video mode. (vid_forcemode (mode))");
	Cmd_AddCommand ("vid_windowed", VID_Windowed_f, "Switch to windowed mode");
	Cmd_AddCommand ("vid_fullscreen", VID_Fullscreen_f, "Switch to full "
					"screen mode");
	Cmd_AddCommand ("vid_minimize", VID_Minimize_f, "Minimize windowed Quake");

	if (COM_CheckParm ("-dibonly"))
		dibonly = true;

	VID_InitMGLDIB (global_hInstance);

	basenummodes = nummodes;

	if (!dibonly)
		VID_InitMGLFull (global_hInstance);

	// if there are no non-windowed modes, or only windowed and mode 0x13,
	// then use fullscreen DIBs as well
	if (((nummodes == basenummodes) || ((nummodes == (basenummodes + 1)) &&
										is_mode0x13)) &&
		!COM_CheckParm ("-nofulldib"))
	{
		VID_InitFullDIB (global_hInstance);
	}

	vid.maxwarpwidth = WARP_WIDTH;
	vid.maxwarpheight = WARP_HEIGHT;
	vid.colormap8 = vid_colormap;
	vid.fullbright = 256 - LittleLong (*((int *) vid.colormap8 + 2048));
	vid_testingmode = 0;

	// GDI doesn't let us remap palette index 0, so we'll remap color
	// mappings from that black to another one
	bestmatchmetric = 256 * 256 * 3;

	for (i = 1; i < 256; i++) {
		dr = palette[0] - palette[i * 3];
		dg = palette[1] - palette[i * 3 + 1];
		db = palette[2] - palette[i * 3 + 2];

		t = (dr * dr) + (dg * dg) + (db * db);

		if (t < bestmatchmetric) {
			bestmatchmetric = t;
			bestmatch = i;

			if (t == 0)
				break;
		}
	}

	for (i = 0, ptmp = vid.colormap8; i < (1 << (VID_CBITS + 8));
		 i++, ptmp++) {
		if (*ptmp == 0)
			*ptmp = bestmatch;
	}

	if (COM_CheckParm ("-startwindowed") || COM_CheckParm ("-window")) {
		startwindowed = 1;
		vid_default = windowed_default;
	}
#ifdef SPLASH_SCREEN
	if (hwnd_dialog)
		DestroyWindow (hwnd_dialog);
#endif

// sound initialization has to go here, preceded by a windowed mode set,
// so there's a window for DirectSound to work with but we're not yet
// fullscreen so the "hardware already in use" dialog is visible if it
// gets displayed

	// keep the window minimized until we're ready for the first real mode set
	hide_window = true;
	VID_SetMode (MODE_WINDOWED, palette);
	hide_window = false;
//	S_Init ();

	vid.initialized = true;

	force_mode_set = true;
	VID_SetMode (vid_default, palette);
	force_mode_set = false;

	vid_realmode = vid_modenum;

	VID_SetPalette (palette);

	vid_menudrawfn = VID_MenuDraw;
	vid_menukeyfn = VID_MenuKey;

	strcpy (badmode.modedesc, "Bad mode");
}

void
VID_Init_Cvars ()
{
	vid_mode = Cvar_Get ("vid_mode", "0", CVAR_NONE, NULL, "Set the video "
						 "mode");
	vid_nopageflip = Cvar_Get ("vid_nopageflip", "0", CVAR_ARCHIVE, NULL,
							   "Toggles the use of page flipping");
	_vid_default_mode_win = Cvar_Get ("_vid_default_mode_win", "3",
									  CVAR_ARCHIVE, NULL, "Default windowed "
									  "video mode");
	vid_config_x = Cvar_Get ("vid_config_x", "800", CVAR_ARCHIVE, NULL,
							 "Maximum x-axis screen size");
	vid_config_y = Cvar_Get ("vid_config_y", "600", CVAR_ARCHIVE, NULL,
							 "Maximum y-axis screen size");
	vid_stretch_by_2 = Cvar_Get ("vid_stretch_by_2", "1", CVAR_ARCHIVE, NULL,
								 "Stretch the pixles by a two fold to acheive "
								 "proper view");
	in_grab = Cvar_Get ("in_grab", "0", CVAR_ARCHIVE, NULL,
								"Have quake grab the mouse from X when you "
								"play");
	vid_fullscreen_mode = Cvar_Get ("vid_fullscreen_mode", "3", CVAR_ARCHIVE,
									NULL, "Set the full screen video mode.");
	vid_windowed_mode =	Cvar_Get ("vid_windowed_mode", "0", CVAR_ARCHIVE, NULL,
								  "Set the windowed video mode");
	block_switch = Cvar_Get ("block_switch", "0", CVAR_ARCHIVE, NULL, "If "
							 "set, won't allow you to task switch while "
							 "playing");
	vid_window_x = Cvar_Get ("vid_window_x", "0", CVAR_ARCHIVE, NULL, "The "
							 "x-axis location of the window, if windowed");
	vid_window_y = Cvar_Get ("vid_window_y", "0", CVAR_ARCHIVE, NULL, "The "
							 "y-axis location of the window, if windowed");
}

void
VID_Shutdown (void)
{
#ifdef SPLASH_SCREEN
                if (hwnd_dialog)
                        DestroyWindow (hwnd_dialog);
#endif

	if (vid.initialized) {
		if (modestate == MS_FULLDIB)
			ChangeDisplaySettings (NULL, CDS_FULLSCREEN);

		PostMessage (HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM) mainwindow,
					 (LPARAM) 0);
		PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM) 0,
					 (LPARAM) 0);

		AppActivate (false, false);
		DestroyDIBWindow ();
		DestroyFullscreenWindow ();
		DestroyFullDIBWindow ();

		if (mainwindow)
			DestroyWindow (mainwindow);

		MGL_exit ();

		vid_testingmode = 0;
		vid.initialized = 0;
	}
}

void
FlipScreen (vrect_t *rects)
{
	/* Flip the surfaces */
	if (DDActive) {
		if (mgldc) {
			if (memdc) {
				while (rects) {
					if (vid_stretched) {
						MGL_stretchBltCoord (mgldc, memdc, rects->x,
											 rects->y, rects->x + rects->width,
											 rects->y + rects->height,
											 rects->x << 1, rects->y << 1,
											 (rects->x + rects->width) << 1,
											 (rects->y + rects->height) << 1);
					} else {
						MGL_bitBltCoord (mgldc, memdc, rects->x, rects->y,
										 (rects->x + rects->width),
										 (rects->y + rects->height),
										 rects->x, rects->y, MGL_REPLACE_MODE);
					}

					rects = rects->pnext;
				}
			}

			if (vid.numpages > 1) {
				// We have a flipping surface, so do a hard page flip
				aPage = (aPage + 1) % vid.numpages;
				vPage = (vPage + 1) % vid.numpages;
				MGL_setActivePage (mgldc, aPage);
				MGL_setVisualPage (mgldc, vPage, waitVRT);
			}
		}
	} else {
		HDC         hdcScreen;

		hdcScreen = GetDC (mainwindow);

		if (windc && dibdc) {
			MGL_setWinDC (windc, hdcScreen);

			while (rects) {
				if (vid_stretched) {
					MGL_stretchBltCoord (windc, dibdc, rects->x, rects->y,
										 rects->x + rects->width,
										 rects->y + rects->height,
										 rects->x << 1, rects->y << 1,
										 (rects->x + rects->width) << 1,
										 (rects->y + rects->height) << 1);
				} else {
					MGL_bitBltCoord (windc, dibdc, rects->x, rects->y,
									 rects->x + rects->width,
									 rects->y + rects->height, rects->x,
									 rects->y, MGL_REPLACE_MODE);
				}

				rects = rects->pnext;
			}
		}

		ReleaseDC (mainwindow, hdcScreen);
	}
}

void
VID_Update (vrect_t *rects)
{
	vrect_t     rect;
	RECT        trect;

	if (!vid_palettized && palette_changed) {
		palette_changed = false;
		rect.x = 0;
		rect.y = 0;
		rect.width = vid.width;
		rect.height = vid.height;
		rect.pnext = NULL;
		rects = &rect;
	}

	if (firstupdate) {
		if (modestate == MS_WINDOWED) {
			GetWindowRect (mainwindow, &trect);

			if ((trect.left != vid_window_x->int_val) ||
				(trect.top != vid_window_y->int_val)) {
				if (COM_CheckParm ("-resetwinpos")) {
					Cvar_SetValue (vid_window_x, 0.0);
					Cvar_SetValue (vid_window_y, 0.0);
				}

				VID_CheckWindowXY ();
				SetWindowPos (mainwindow, NULL, vid_window_x->int_val,
							  vid_window_y->int_val, 0, 0, SWP_NOSIZE |
							  SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
			}
		}

		if ((_vid_default_mode_win->int_val != vid_default) &&
			(!startwindowed || (_vid_default_mode_win->int_val <
								MODE_FULLSCREEN_DEFAULT))) {
			firstupdate = 0;

			if (COM_CheckParm ("-resetwinpos")) {
				Cvar_SetValue (vid_window_x, 0.0);
				Cvar_SetValue (vid_window_y, 0.0);
			}

			if ((_vid_default_mode_win->int_val < 0) ||
				(_vid_default_mode_win->int_val >= nummodes)) {
				Cvar_SetValue (_vid_default_mode_win, windowed_default);
			}

			Cvar_SetValue (vid_mode, _vid_default_mode_win->int_val);
		}
	}
	// We've drawn the frame; copy it to the screen
	FlipScreen (rects);

	if (vid_testingmode) {
		if (realtime >= vid_testendtime) {
			VID_SetMode (vid_realmode, vid_curpal);
			vid_testingmode = 0;
		}
	} else {
		if (vid_mode->int_val != vid_realmode) {
			VID_SetMode (vid_mode->int_val, vid_curpal);
			Cvar_SetValue (vid_mode, vid_modenum);
			// so if mode set fails, we don't keep on
			// trying to set that mode
			vid_realmode = vid_modenum;
		}
	}

	// handle the mouse state when windowed if that's changed
	if (modestate == MS_WINDOWED) {
		if (!in_grab->int_val) {
			if (windowed_mouse) {
				IN_DeactivateMouse ();
				IN_ShowMouse ();
			}
			windowed_mouse = false;
		} else {
			windowed_mouse = true;
			if (key_dest == key_game && !mouseactive && ActiveApp) {
				IN_ActivateMouse ();
				IN_HideMouse ();
			} else if (mouseactive && key_dest != key_game) {
				IN_DeactivateMouse ();
				IN_ShowMouse ();
			}
		}
	}
}

void
D_BeginDirectRect (int x, int y, byte * pbitmap, int width, int height)
{
	int         i, j, reps, repshift;
	vrect_t     rect;

	if (!vid.initialized)
		return;

	if (vid.aspect > 1.5) {
		reps = 2;
		repshift = 1;
	} else {
		reps = 1;
		repshift = 0;
	}

	if (vid.numpages == 1) {
		VID_LockBuffer ();

		if (!vid.direct)
			Sys_Error ("NULL vid.direct pointer");

		for (i = 0; i < (height << repshift); i += reps) {
			for (j = 0; j < reps; j++) {
				memcpy (&backingbuf[(i + j) * 24],
						vid.direct + x + ((y << repshift) + i +
										  j) * vid.rowbytes, width);
				memcpy (vid.direct + x +
						((y << repshift) + i + j) * vid.rowbytes,
						&pbitmap[(i >> repshift) * width], width);
			}
		}

		VID_UnlockBuffer ();

		rect.x = x;
		rect.y = y;
		rect.width = width;
		rect.height = height << repshift;
		rect.pnext = NULL;

		FlipScreen (&rect);
	} else {
		// unlock if locked
		if (lockcount > 0)
			MGL_endDirectAccess ();

		// set the active page to the displayed page
		MGL_setActivePage (mgldc, vPage);

		// lock the screen
		MGL_beginDirectAccess ();

		// save from and draw to screen
		for (i = 0; i < (height << repshift); i += reps) {
			for (j = 0; j < reps; j++) {
				memcpy (&backingbuf[(i + j) * 24],
						(byte *) mgldc->surface + x +
						((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
						width);
				memcpy ((byte *) mgldc->surface + x +
						((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
						&pbitmap[(i >> repshift) * width], width);
			}
		}

		// unlock the screen
		MGL_endDirectAccess ();

		// restore the original active page
		MGL_setActivePage (mgldc, aPage);

		// relock the screen if it was locked
		if (lockcount > 0)
			MGL_beginDirectAccess ();
	}
}

void
D_EndDirectRect (int x, int y, int width, int height)
{
	int         i, j, reps, repshift;
	vrect_t     rect;

	if (!vid.initialized)
		return;

	if (vid.aspect > 1.5) {
		reps = 2;
		repshift = 1;
	} else {
		reps = 1;
		repshift = 0;
	}

	if (vid.numpages == 1) {
		VID_LockBuffer ();

		if (!vid.direct)
			Sys_Error ("NULL vid.direct pointer");

		for (i = 0; i < (height << repshift); i += reps) {
			for (j = 0; j < reps; j++) {
				memcpy (vid.direct + x +
						((y << repshift) + i + j) * vid.rowbytes,
						&backingbuf[(i + j) * 24], width);
			}
		}

		VID_UnlockBuffer ();

		rect.x = x;
		rect.y = y;
		rect.width = width;
		rect.height = height << repshift;
		rect.pnext = NULL;

		FlipScreen (&rect);
	} else {
		// unlock if locked
		if (lockcount > 0)
			MGL_endDirectAccess ();

		// set the active page to the displayed page
		MGL_setActivePage (mgldc, vPage);

		// lock the screen
		MGL_beginDirectAccess ();

		// restore to the screen
		for (i = 0; i < (height << repshift); i += reps) {
			for (j = 0; j < reps; j++) {
				memcpy ((byte *) mgldc->surface + x +
						((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
						&backingbuf[(i + j) * 24], width);
			}
		}

		// unlock the screen
		MGL_endDirectAccess ();

		// restore the original active page
		MGL_setActivePage (mgldc, aPage);

		// relock the screen if it was locked
		if (lockcount > 0)
			MGL_beginDirectAccess ();
	}
}

//==========================================================================

/*
  AppActivate
  
  fActive - True if app is activating
  If the application is activating, then swap the system into SYSPAL_NOSTATIC
  mode so that our palettes will display correctly.
*/
void
AppActivate (BOOL fActive, BOOL minimize)
{
	HDC         hdc;
	int         i, t;
	static BOOL sound_active;

	ActiveApp = fActive;

	// messy, but it seems to work
	if (vid_fulldib_on_focus_mode) {
		Minimized = minimize;

		if (Minimized)
			ActiveApp = false;
	}

	MGL_appActivate (windc, ActiveApp);

	if (vid.initialized) {
		// yield the palette if we're losing the focus
		hdc = GetDC (NULL);

		if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
			if (ActiveApp) {
				if ((modestate == MS_WINDOWED) || (modestate == MS_FULLDIB)) {
					if (GetSystemPaletteUse (hdc) == SYSPAL_STATIC) {
						// switch to SYSPAL_NOSTATIC and remap the colors
						SetSystemPaletteUse (hdc, SYSPAL_NOSTATIC);
						syscolchg = true;
						pal_is_nostatic = true;
					}
				}
			} else if (pal_is_nostatic) {
				if (GetSystemPaletteUse (hdc) == SYSPAL_NOSTATIC) {
					// switch back to SYSPAL_STATIC and the old mapping
					SetSystemPaletteUse (hdc, SYSPAL_STATIC);
					syscolchg = true;
				}

				pal_is_nostatic = false;
			}
		}

		if (!Minimized)
			VID_SetPalette (vid_curpal);

		scr_fullupdate = 0;

		ReleaseDC (NULL, hdc);
	}
	// enable/disable sound on focus gain/loss
	if (!ActiveApp && sound_active) {
		S_BlockSound ();
		S_ClearBuffer ();
		sound_active = false;
	} else if (ActiveApp && !sound_active) {
		S_UnblockSound ();
		S_ClearBuffer ();
		sound_active = true;
	}
	// minimize/restore fulldib windows/mouse-capture normal windows on demand
	if (!in_mode_set) {
		if (ActiveApp) {
			if (vid_fulldib_on_focus_mode) {
				if (vid.initialized) {
					msg_suppress_1 = true;	// don't want to see normal mode
											// set message
					VID_SetMode (vid_fulldib_on_focus_mode, vid_curpal);
					msg_suppress_1 = false;

					t = in_mode_set;
					in_mode_set = true;
					AppActivate (true, false);
					in_mode_set = t;
				}

				IN_ActivateMouse ();
				IN_HideMouse ();
			}
				else if ((modestate == MS_WINDOWED) && in_grab->int_val
						 && key_dest == key_game) {
				IN_ActivateMouse ();
				IN_HideMouse ();
			}
		}

		if (!ActiveApp) {
			if (modestate == MS_FULLDIB) {
				if (vid.initialized) {
					force_minimized = true;
					i = vid_fulldib_on_focus_mode;
					msg_suppress_1 = true;	// don't want to see normal mode
											// set message
					VID_SetMode (windowed_default, vid_curpal);
					msg_suppress_1 = false;
					vid_fulldib_on_focus_mode = i;
					force_minimized = false;

					// we never seem to get WM_ACTIVATE inactive from this
					// mode set, so we'll do it manually
					t = in_mode_set;
					in_mode_set = true;
					AppActivate (false, true);
					in_mode_set = t;
				}

				IN_DeactivateMouse ();
				IN_ShowMouse ();
			} else if ((modestate == MS_WINDOWED) && in_grab->int_val
					   /* &&  mouseactive */ ) {
				IN_DeactivateMouse ();
				IN_ShowMouse ();
			}
		}
	}
}

void
VID_HandlePause (qboolean pause)
{
#if 0
	if ((modestate == MS_WINDOWED) && in_grab->int_val) {
		if (pause) {
			IN_DeactivateMouse ();
			IN_ShowMouse ();
		} else {
			IN_ActivateMouse ();
			IN_HideMouse ();
		}
	}
#endif
}

/*
  MAIN WINDOW
*/

LONG        CDAudio_MessageHandler (HWND hWnd, UINT uMsg, WPARAM wParam,
									LPARAM lParam);

/* main window procedure */
LONG WINAPI
MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LONG        lRet = 0;
	int         fActive, fMinimized, temp;
	int         key, unicode;
	HDC         hdc;
	PAINTSTRUCT ps;
	extern unsigned int uiWheelMessage;

	if (uMsg == uiWheelMessage) {
		uMsg = WM_MOUSEWHEEL;
		wParam <<= 16;
	}

	switch (uMsg) {
		case WM_CREATE:
			break;

		case WM_MOVE:
			VID_UpdateWindowStatus ((int) LOWORD (lParam),
									(int) HIWORD (lParam));

			if ((modestate == MS_WINDOWED) && !in_mode_set && !Minimized)
				VID_RememberWindowPos ();

			break;

		case WM_KEYDOWN:
		case WM_SYSKEYDOWN:
			if (!in_mode_set) {
				MapKey (lParam, 1, &key, &unicode);
				Key_Event (key, unicode, true);
			}
			break;

		case WM_KEYUP:
		case WM_SYSKEYUP:
			if (!in_mode_set) {
				MapKey (lParam, 0, &key, &unicode);
				Key_Event (key, unicode, false);
			}
			break;

		case WM_SYSCHAR:
			// keep Alt-Space from happening
			break;

		// this is complicated because Win32 seems to pack multiple mouse
		// events into one update sometimes, so always check all states and
		// look for events
		case WM_LBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_RBUTTONDOWN:
		case WM_RBUTTONUP:
		case WM_MBUTTONDOWN:
		case WM_MBUTTONUP:
		case WM_MOUSEMOVE:
			if (!in_mode_set) {
				temp = 0;

				if (wParam & MK_LBUTTON)
					temp |= 1;
				if (wParam & MK_RBUTTON)
					temp |= 2;
				if (wParam & MK_MBUTTON)
					temp |= 4;
				IN_MouseEvent (temp);
			}
			break;

		// JACK: This is the mouse wheel with the Intellimouse
		// Its delta is either positive or neg, and we generate the proper
		// Event.
		case WM_MOUSEWHEEL:
			if ((short) HIWORD (wParam) > 0) {
				Key_Event (QFK_MWHEELUP, -1, true);
				Key_Event (QFK_MWHEELUP, -1, false);
			} else {
					Key_Event (QFK_MWHEELDOWN, -1, true);
					Key_Event (QFK_MWHEELDOWN, -1, false);
			}
			break;

		case WM_SIZE:
			Minimized = false;

			if (!(wParam & SIZE_RESTORED)) {
				if (wParam & SIZE_MINIMIZED)
					Minimized = true;
			}
			break;

		case WM_CLOSE:
			// this causes Close in the right-click task bar menu not to work,
			// but right now bad things happen if Close is handled in that case
			// (garbage and a crash on Win95)
			if (!in_mode_set) {
				if (MessageBox
					(mainwindow, "Are you sure you want to quit?",
					 "Confirm Exit",
					 MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES) {
					Sys_Quit ();
				}
			}
			break;

		case WM_ACTIVATE:
			fActive = LOWORD (wParam);
			fMinimized = (BOOL) HIWORD (wParam);
			AppActivate (!(fActive == WA_INACTIVE), fMinimized);
			// fix leftover Alt from any Alt-Tab or the like that switched us
			// away
			IN_ClearStates ();

			if (!in_mode_set) {
				if (windc)
					MGL_activatePalette (windc, true);

				VID_SetPalette (vid_curpal);
			}
			break;

		case MM_MCINOTIFY:
			//FIXME lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
			break;

		default:
			/* pass all unhandled messages to DefWindowProc */
			lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
			break;

		case WM_SYSCOMMAND:
			// Check for maximize being hit
			switch (wParam & ~0x0F) {
				case SC_MAXIMIZE:
					// if minimized, bring up as a window before going
					// fullscreen, so MGL will have the right state to restore
					if (Minimized) {
						force_mode_set = true;
						VID_SetMode (vid_modenum, vid_curpal);
						force_mode_set = false;
					}

					VID_SetMode (vid_fullscreen_mode->int_val, vid_curpal);
					break;

				case SC_SCREENSAVE:
				case SC_MONITORPOWER:
					if (modestate != MS_WINDOWED) {
						// don't call DefWindowProc() because we don't want
						// to start the screen saver fullscreen
						break;
					}

				// fall through windowed and allow the screen saver to start
				default:
					if (!in_mode_set) {
						S_BlockSound ();
						S_ClearBuffer ();
					}

					lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);

					if (!in_mode_set) {
						S_UnblockSound ();
					}
			}
			break;

		case WM_PAINT:
			hdc = BeginPaint (hWnd, &ps);

			if (!in_mode_set && host_initialized)
				SCR_UpdateWholeScreen ();

			EndPaint (hWnd, &ps);
			break;
		// KJB: Added these new palette functions
		case WM_PALETTECHANGED:
			if ((HWND) wParam == hWnd)
				break;
		/* Fall through to WM_QUERYNEWPALETTE */
		case WM_QUERYNEWPALETTE:
			hdc = GetDC (NULL);

			if (GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE)
				vid_palettized = true;
			else
				vid_palettized = false;

			ReleaseDC (NULL, hdc);

			scr_fullupdate = 0;

			if (vid.initialized && !in_mode_set && windc
				&& MGL_activatePalette (windc, false) && !Minimized) {
				VID_SetPalette (vid_curpal);
				InvalidateRect (mainwindow, NULL, false);

				// specifically required if WM_QUERYNEWPALETTE realizes a new 
				// palette
				lRet = TRUE;
			}
			break;

		case WM_DISPLAYCHANGE:
			if (!in_mode_set && (modestate == MS_WINDOWED)
				&& !vid_fulldib_on_focus_mode) {
				force_mode_set = true;
				VID_SetMode (vid_modenum, vid_curpal);
				force_mode_set = false;
			}
			break;
	}

	/* return 0 if handled message, 1 if not */
	return lRet;
}


static int  vid_line, vid_wmodes;

typedef struct {
	int         modenum;
	char       *desc;
	int         iscur;
	int         ismode13;
	int         width;
} modedesc_t;

#define MAX_COLUMN_SIZE		5
#define MODE_AREA_HEIGHT	(MAX_COLUMN_SIZE + 6)
#define MAX_MODEDESCS		(MAX_COLUMN_SIZE*3)

static modedesc_t modedescs[MAX_MODEDESCS];

void
VID_MenuDraw (void)
{
	qpic_t     *p;
	char       *ptr;
	int         lnummodes, i, j, k, column, row, dup, dupmode = 0;
	char        temp[100];
	vmode_t    *pv;
	modedesc_t  tmodedesc;

	p = Draw_CachePic ("gfx/vidmodes.lmp", true);
	M_DrawPic ((320 - p->width) / 2, 4, p);

	for (i = 0; i < 3; i++) {
		ptr = VID_GetModeDescriptionMemCheck (i);
		modedescs[i].modenum = modelist[i].modenum;
		modedescs[i].desc = ptr;
		modedescs[i].ismode13 = 0;
		modedescs[i].iscur = 0;

		if (vid_modenum == i)
			modedescs[i].iscur = 1;
	}

	vid_wmodes = 3;
	lnummodes = VID_NumModes ();

	for (i = 3; i < lnummodes; i++) {
		ptr = VID_GetModeDescriptionMemCheck (i);
		pv = VID_GetModePtr (i);

		// we only have room for 15 fullscreen modes, so don't allow
		// 360-wide modes, because if there are 5 320-wide modes and
		// 5 360-wide modes, we'll run out of space
		if (ptr && ((pv->width != 360) || COM_CheckParm ("-allow360"))) {
			dup = 0;

			for (j = 3; j < vid_wmodes; j++) {
				if (!strcmp (modedescs[j].desc, ptr)) {
					dup = 1;
					dupmode = j;
					break;
				}
			}

			if (dup || (vid_wmodes < MAX_MODEDESCS)) {
				if (!dup || !modedescs[dupmode].ismode13
					|| COM_CheckParm ("-noforcevga")) {
					if (dup) {
						k = dupmode;
					} else {
						k = vid_wmodes;
					}

					modedescs[k].modenum = i;
					modedescs[k].desc = ptr;
					modedescs[k].ismode13 = pv->mode13;
					modedescs[k].iscur = 0;
					modedescs[k].width = pv->width;

					if (i == vid_modenum)
						modedescs[k].iscur = 1;

					if (!dup)
						vid_wmodes++;
				}
			}
		}
	}

	// sort the modes on width (to handle picking up oddball dibonly modes
	// after all the others)
	for (i = 3; i < (vid_wmodes - 1); i++) {
		for (j = (i + 1); j < vid_wmodes; j++) {
			if (modedescs[i].width > modedescs[j].width) {
				tmodedesc = modedescs[i];
				modedescs[i] = modedescs[j];
				modedescs[j] = tmodedesc;
			}
		}
	}

	M_Print (13 * 8, 36, "Windowed Modes");

	column = 16;
	row = 36 + 2 * 8;

	for (i = 0; i < 3; i++) {
		if (modedescs[i].iscur)
			M_PrintWhite (column, row, modedescs[i].desc);
		else
			M_Print (column, row, modedescs[i].desc);

		column += 13 * 8;
	}

	if (vid_wmodes > 3) {
		M_Print (12 * 8, 36 + 4 * 8, "Fullscreen Modes");

		column = 16;
		row = 36 + 6 * 8;

		for (i = 3; i < vid_wmodes; i++) {
			if (modedescs[i].iscur)
				M_PrintWhite (column, row, modedescs[i].desc);
			else
				M_Print (column, row, modedescs[i].desc);

			column += 13 * 8;

			if (((i - 3) % VID_ROW_SIZE) == (VID_ROW_SIZE - 1)) {
				column = 16;
				row += 8;
			}
		}
	}
	// line cursor
	if (vid_testingmode) {
		snprintf (temp, sizeof (temp), "TESTING %s", modedescs[vid_line].desc);
		M_Print (13 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 4, temp);
		M_Print (9 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 6,
				 "Please wait 5 seconds...");
	} else {
		M_Print (9 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8,
				 "Press Enter to set mode");
		M_Print (6 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 3,
				 "T to test mode for 5 seconds");
		ptr = VID_GetModeDescription2 (vid_modenum);

		if (ptr) {
			snprintf (temp, sizeof (temp), "D to set default: %s", ptr);
			M_Print (2 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 5, temp);
		}

		ptr = VID_GetModeDescription2 (_vid_default_mode_win->int_val);

		if (ptr) {
			snprintf (temp, sizeof (temp), "Current default: %s", ptr);
			M_Print (3 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 6, temp);
		}

		M_Print (15 * 8, 36 + MODE_AREA_HEIGHT * 8 + 8 * 8, "Esc to exit");

		row = 36 + 2 * 8 + (vid_line / VID_ROW_SIZE) * 8;
		column = 8 + (vid_line % VID_ROW_SIZE) * 13 * 8;

		if (vid_line >= 3)
			row += 3 * 8;

		M_DrawCharacter (column, row, 12 + ((int) (realtime * 4) & 1));
	}
}

void
VID_MenuKey (int key)
{
	if (vid_testingmode)
		return;

	switch (key) {
		case K_ESCAPE:
			S_LocalSound ("misc/menu1.wav");
			M_Menu_Options_f ();
			break;

		case K_LEFTARROW:

			S_LocalSound ("misc/menu1.wav");
			vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
				((vid_line + 2) % VID_ROW_SIZE);

			if (vid_line >= vid_wmodes)
				vid_line = vid_wmodes - 1;
			break;

		case K_RIGHTARROW:
			S_LocalSound ("misc/menu1.wav");
			vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
				((vid_line + 4) % VID_ROW_SIZE);

			if (vid_line >= vid_wmodes)
				vid_line = (vid_line / VID_ROW_SIZE) * VID_ROW_SIZE;
			break;

		case K_UPARROW:
			S_LocalSound ("misc/menu1.wav");
			vid_line -= VID_ROW_SIZE;

			if (vid_line < 0) {
				vid_line += ((vid_wmodes + (VID_ROW_SIZE - 1)) /
							 VID_ROW_SIZE) * VID_ROW_SIZE;

				while (vid_line >= vid_wmodes)
					vid_line -= VID_ROW_SIZE;
			}
			break;

		case K_DOWNARROW:
			S_LocalSound ("misc/menu1.wav");
			vid_line += VID_ROW_SIZE;

			if (vid_line >= vid_wmodes) {
				vid_line -= ((vid_wmodes + (VID_ROW_SIZE - 1)) /
							 VID_ROW_SIZE) * VID_ROW_SIZE;

				while (vid_line < 0)
					vid_line += VID_ROW_SIZE;
			}
			break;

		case K_ENTER:
			S_LocalSound ("misc/menu1.wav");
			VID_SetMode (modedescs[vid_line].modenum, vid_curpal);
			break;

		case 'T':
		case 't':
			S_LocalSound ("misc/menu1.wav");
			// have to set this before setting the mode because WM_PAINT
			// happens during the mode set and does a VID_Update, which
			// checks vid_testingmode
			vid_testingmode = 1;
			vid_testendtime = realtime + 5.0;

			if (!VID_SetMode (modedescs[vid_line].modenum, vid_curpal)) {
				vid_testingmode = 0;
			}
			break;

		case 'D':
		case 'd':
			S_LocalSound ("misc/menu1.wav");
			firstupdate = 0;
			Cvar_SetValue (_vid_default_mode_win, vid_modenum);
			break;

		default:
			break;
	}
}

void
VID_SetCaption (const char *text)
{
	if (text && *text) {
		char       *temp = strdup (text);

		SetWindowText (mainwindow, (LPSTR) va ("%s %s: %s", PROGRAM, VERSION,
											   text));
		free (temp);
	} else {
		SetWindowText (mainwindow, (LPSTR) va ("%s %s", PROGRAM, VERSION));
	}
}