home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / client / vid_win.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-21  |  74.9 KB  |  3,392 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20. // vid_win.c -- Win32 video driver
  21.  
  22. #include "quakedef.h"
  23. #include "winquake.h"
  24. #include "d_local.h"
  25. #include "resource.h"
  26.  
  27. #define    MINIMUM_MEMORY    0x550000
  28.  
  29. #define MAX_MODE_LIST    30
  30. #define VID_ROW_SIZE    3
  31.  
  32. qboolean    dibonly;
  33.  
  34. extern int        Minimized;
  35.  
  36. HWND        mainwindow;
  37.  
  38. HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);
  39.  
  40. int            DIBWidth, DIBHeight;
  41. qboolean    DDActive;
  42. RECT        WindowRect;
  43. DWORD        WindowStyle, ExWindowStyle;
  44.  
  45. int            window_center_x, window_center_y, window_x, window_y, window_width, window_height;
  46. RECT        window_rect;
  47.  
  48. static DEVMODE    gdevmode;
  49. static qboolean    startwindowed = 0, windowed_mode_set;
  50. static int        firstupdate = 1;
  51. static qboolean    vid_initialized = false, vid_palettized;
  52. static int        lockcount;
  53. static int        vid_fulldib_on_focus_mode;
  54. static qboolean    force_minimized, in_mode_set, is_mode0x13, force_mode_set;
  55. static int        vid_stretched, windowed_mouse;
  56. static qboolean    palette_changed, syscolchg, vid_mode_set, hide_window, pal_is_nostatic;
  57. static HICON    hIcon;
  58.  
  59. qboolean mouseactive; // from in_win.c
  60.  
  61. viddef_t    vid;                // global video state
  62.  
  63. #define MODE_WINDOWED            0
  64. #define MODE_SETTABLE_WINDOW    2
  65. #define NO_MODE                    (MODE_WINDOWED - 1)
  66. #define MODE_FULLSCREEN_DEFAULT    (MODE_WINDOWED + 3)
  67.  
  68. // Note that 0 is MODE_WINDOWED
  69. cvar_t        vid_mode = {"vid_mode","0", false};
  70. // Note that 0 is MODE_WINDOWED
  71. cvar_t        _vid_default_mode = {"_vid_default_mode","0", true};
  72. // Note that 3 is MODE_FULLSCREEN_DEFAULT
  73. cvar_t        _vid_default_mode_win = {"_vid_default_mode_win","3", true};
  74. cvar_t        vid_wait = {"vid_wait","0"};
  75. cvar_t        vid_nopageflip = {"vid_nopageflip","0", true};
  76. cvar_t        _vid_wait_override = {"_vid_wait_override", "0", true};
  77. cvar_t        vid_config_x = {"vid_config_x","800", true};
  78. cvar_t        vid_config_y = {"vid_config_y","600", true};
  79. cvar_t        vid_stretch_by_2 = {"vid_stretch_by_2","1", true};
  80. cvar_t        _windowed_mouse = {"_windowed_mouse","0", true};
  81. cvar_t        vid_fullscreen_mode = {"vid_fullscreen_mode","3", true};
  82. cvar_t        vid_windowed_mode = {"vid_windowed_mode","0", true};
  83. cvar_t        block_switch = {"block_switch","0", true};
  84. cvar_t        vid_window_x = {"vid_window_x", "0", true};
  85. cvar_t        vid_window_y = {"vid_window_y", "0", true};
  86.  
  87. typedef struct {
  88.     int        width;
  89.     int        height;
  90. } lmode_t;
  91.  
  92. lmode_t    lowresmodes[] = {
  93.     {320, 200},
  94.     {320, 240},
  95.     {400, 300},
  96.     {512, 384},
  97. };
  98.  
  99. int            vid_modenum = NO_MODE;
  100. int            vid_testingmode, vid_realmode;
  101. double        vid_testendtime;
  102. int            vid_default = MODE_WINDOWED;
  103. static int    windowed_default;
  104.  
  105. modestate_t    modestate = MS_UNINIT;
  106.  
  107. static byte        *vid_surfcache;
  108. static int        vid_surfcachesize;
  109. static int        VID_highhunkmark;
  110.  
  111. unsigned char    vid_curpal[256*3];
  112.  
  113. unsigned short    d_8to16table[256];
  114. unsigned    d_8to24table[256];
  115.  
  116. int     driver = grDETECT,mode;
  117. bool    useWinDirect = true, useDirectDraw = true;
  118. MGLDC    *mgldc = NULL,*memdc = NULL,*dibdc = NULL,*windc = NULL;
  119.  
  120. typedef struct {
  121.     modestate_t    type;
  122.     int            width;
  123.     int            height;
  124.     int            modenum;
  125.     int            mode13;
  126.     int            stretched;
  127.     int            dib;
  128.     int            fullscreen;
  129.     int            bpp;
  130.     int            halfscreen;
  131.     char        modedesc[13];
  132. } vmode_t;
  133.  
  134. static vmode_t    modelist[MAX_MODE_LIST];
  135. static int        nummodes;
  136. static vmode_t    *pcurrentmode;
  137.  
  138. int        aPage;                    // Current active display page
  139. int        vPage;                    // Current visible display page
  140. int        waitVRT = true;            // True to wait for retrace on flip
  141.  
  142. static vmode_t    badmode;
  143.  
  144. static byte    backingbuf[48*24];
  145.  
  146. void VID_MenuDraw (void);
  147. void VID_MenuKey (int key);
  148.  
  149. LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  150. void AppActivate(BOOL fActive, BOOL minimize);
  151.  
  152.  
  153. /*
  154. ================
  155. VID_RememberWindowPos
  156. ================
  157. */
  158. void VID_RememberWindowPos (void)
  159. {
  160.     RECT    rect;
  161.  
  162.     if (GetWindowRect (mainwindow, &rect))
  163.     {
  164.         if ((rect.left < GetSystemMetrics (SM_CXSCREEN)) &&
  165.             (rect.top < GetSystemMetrics (SM_CYSCREEN))  &&
  166.             (rect.right > 0)                             &&
  167.             (rect.bottom > 0))
  168.         {
  169.             Cvar_SetValue ("vid_window_x", (float)rect.left);
  170.             Cvar_SetValue ("vid_window_y", (float)rect.top);
  171.         }
  172.     }
  173. }
  174.  
  175.  
  176. /*
  177. ================
  178. VID_CheckWindowXY
  179. ================
  180. */
  181. void VID_CheckWindowXY (void)
  182. {
  183.  
  184.     if (((int)vid_window_x.value > (GetSystemMetrics (SM_CXSCREEN) - 160)) ||
  185.         ((int)vid_window_y.value > (GetSystemMetrics (SM_CYSCREEN) - 120)) ||
  186.         ((int)vid_window_x.value < 0)                                       ||
  187.         ((int)vid_window_y.value < 0))
  188.     {
  189.         Cvar_SetValue ("vid_window_x", 0.0);
  190.         Cvar_SetValue ("vid_window_y", 0.0 );
  191.     }
  192. }
  193.  
  194.  
  195. /*
  196. ================
  197. VID_UpdateWindowStatus
  198. ================
  199. */
  200. void VID_UpdateWindowStatus (void)
  201. {
  202.  
  203.     window_rect.left = window_x;
  204.     window_rect.top = window_y;
  205.     window_rect.right = window_x + window_width;
  206.     window_rect.bottom = window_y + window_height;
  207.     window_center_x = (window_rect.left + window_rect.right) / 2;
  208.     window_center_y = (window_rect.top + window_rect.bottom) / 2;
  209.  
  210.     IN_UpdateClipCursor ();
  211. }
  212.  
  213.  
  214. /*
  215. ================
  216. ClearAllStates
  217. ================
  218. */
  219. void ClearAllStates (void)
  220. {
  221.     int        i;
  222.     
  223. // send an up event for each key, to make sure the server clears them all
  224.     for (i=0 ; i<256 ; i++)
  225.     {
  226.         Key_Event (i, false);
  227.     }
  228.  
  229.     Key_ClearStates ();
  230.     IN_ClearStates ();
  231. }
  232.  
  233.  
  234. /*
  235. ================
  236. VID_CheckAdequateMem
  237. ================
  238. */
  239. qboolean VID_CheckAdequateMem (int width, int height)
  240. {
  241.     int        tbuffersize;
  242.  
  243.     tbuffersize = width * height * sizeof (*d_pzbuffer);
  244.  
  245.     tbuffersize += D_SurfaceCacheForRes (width, height);
  246.  
  247. // see if there's enough memory, allowing for the normal mode 0x13 pixel,
  248. // z, and surface buffers
  249.     if ((host_parms.memsize - tbuffersize + SURFCACHE_SIZE_AT_320X200 +
  250.          0x10000 * 3) < MINIMUM_MEMORY)
  251.     {
  252.         return false;        // not enough memory for mode
  253.     }
  254.  
  255.     return true;
  256. }
  257.  
  258.  
  259. /*
  260. ================
  261. VID_AllocBuffers
  262. ================
  263. */
  264. qboolean VID_AllocBuffers (int width, int height)
  265. {
  266.     int        tsize, tbuffersize;
  267.  
  268.     tbuffersize = width * height * sizeof (*d_pzbuffer);
  269.  
  270.     tsize = D_SurfaceCacheForRes (width, height);
  271.  
  272.     tbuffersize += tsize;
  273.  
  274. // see if there's enough memory, allowing for the normal mode 0x13 pixel,
  275. // z, and surface buffers
  276.     if ((host_parms.memsize - tbuffersize + SURFCACHE_SIZE_AT_320X200 +
  277.          0x10000 * 3) < MINIMUM_MEMORY)
  278.     {
  279.         Con_SafePrintf ("Not enough memory for video mode\n");
  280.         return false;        // not enough memory for mode
  281.     }
  282.  
  283.     vid_surfcachesize = tsize;
  284.  
  285.     if (d_pzbuffer)
  286.     {
  287.         D_FlushCaches ();
  288.         Hunk_FreeToHighMark (VID_highhunkmark);
  289.         d_pzbuffer = NULL;
  290.     }
  291.  
  292.     VID_highhunkmark = Hunk_HighMark ();
  293.  
  294.     d_pzbuffer = Hunk_HighAllocName (tbuffersize, "video");
  295.  
  296.     vid_surfcache = (byte *)d_pzbuffer +
  297.             width * height * sizeof (*d_pzbuffer);
  298.     
  299.     return true;
  300. }
  301.  
  302.  
  303. void initFatalError(void)
  304. {
  305.     MGL_exit();
  306.     MGL_fatalError(MGL_errorMsg(MGL_result()));
  307.     exit(EXIT_FAILURE);
  308. }
  309.  
  310. #if 0 //def NEW_SUSPEND
  311.  
  312. int VID_Suspend (MGLDC *dc, int flags)
  313. {
  314.     int i;
  315.     if (flags & MGL_DEACTIVATE)
  316.     {
  317.         IN_RestoreOriginalMouseState ();
  318.         CDAudio_Pause ();
  319.  
  320.         // keep WM_PAINT from trying to redraw
  321.         in_mode_set = true;
  322.         block_drawing = true;
  323.     }
  324.     else if (flags & MGL_REACTIVATE)
  325.     {
  326.         IN_SetQuakeMouseState ();
  327.         // fix the leftover Alt from any Alt-Tab or the like that switched us away
  328.         ClearAllStates ();
  329.         CDAudio_Resume ();
  330.         in_mode_set = false;
  331.  
  332.         block_drawing = false;
  333. //        vid.recalc_refdef = 1;
  334.         force_mode_set = 1;
  335.         i = msg_suppress_1;
  336.         msg_suppress_1 = 1;
  337.         VID_Fullscreen_f();
  338.         msg_suppress_1 = i;
  339.         force_mode_set = 0;
  340.     }
  341.  
  342.     return 1;
  343. }
  344.  
  345. #else
  346.  
  347. int VID_Suspend (MGLDC *dc, int flags)
  348. {
  349.  
  350.     if (flags & MGL_DEACTIVATE)
  351.     {
  352.     // FIXME: this doesn't currently work on NT
  353.         if (block_switch.value && !WinNT)
  354.         {
  355.             return MGL_NO_DEACTIVATE;
  356.         }
  357.  
  358.         S_BlockSound ();
  359.         S_ClearBuffer ();
  360.  
  361.         IN_RestoreOriginalMouseState ();
  362.         CDAudio_Pause ();
  363.  
  364.     // keep WM_PAINT from trying to redraw
  365.         in_mode_set = true;
  366.  
  367.         block_drawing = true;    // so we don't try to draw while switched away
  368.  
  369.         return MGL_NO_SUSPEND_APP;
  370.     }
  371.     else if (flags & MGL_REACTIVATE)
  372.     {
  373.         IN_SetQuakeMouseState ();
  374.     // fix the leftover Alt from any Alt-Tab or the like that switched us away
  375.         ClearAllStates ();
  376.         CDAudio_Resume ();
  377.         S_UnblockSound ();
  378.  
  379.         in_mode_set = false;
  380.  
  381.         vid.recalc_refdef = 1;
  382.  
  383.         block_drawing = false;
  384.  
  385.         return MGL_NO_SUSPEND_APP;
  386.     }
  387.  
  388. }
  389. #endif
  390.  
  391.  
  392. void registerAllDispDrivers(void)
  393. {
  394.     /* Event though these driver require WinDirect, we register
  395.      * them so that they will still be available even if DirectDraw
  396.      * is present and the user has disable the high performance
  397.      * WinDirect modes.
  398.      */
  399.     MGL_registerDriver(MGL_VGA8NAME,VGA8_driver);
  400. //    MGL_registerDriver(MGL_VGAXNAME,VGAX_driver);
  401.  
  402.     /* Register display drivers */
  403.     if (useWinDirect)
  404.     {
  405. //we don't want VESA 1.X drivers        MGL_registerDriver(MGL_SVGA8NAME,SVGA8_driver);
  406.         MGL_registerDriver(MGL_LINEAR8NAME,LINEAR8_driver);
  407.  
  408.         if (!COM_CheckParm ("-novbeaf"))
  409.             MGL_registerDriver(MGL_ACCEL8NAME,ACCEL8_driver);
  410.     }
  411.  
  412.     if (useDirectDraw)
  413.     {
  414.         MGL_registerDriver(MGL_DDRAW8NAME,DDRAW8_driver);
  415.     }
  416. }
  417.  
  418.  
  419. void registerAllMemDrivers(void)
  420. {
  421.     /* Register memory context drivers */
  422.     MGL_registerDriver(MGL_PACKED8NAME,PACKED8_driver);
  423. }
  424.  
  425.  
  426. void VID_InitMGLFull (HINSTANCE hInstance)
  427. {
  428.     int            i, xRes, yRes, bits, vMode, lowres, curmode, temp;
  429.     int            lowstretchedres, stretchedmode, lowstretched;
  430.     uchar        *m;
  431.  
  432. // FIXME: NT is checked for because MGL currently has a bug that causes it
  433. // to try to use WinDirect modes even on NT
  434.     if (COM_CheckParm("-nowindirect") ||
  435.         COM_CheckParm("-nowd") ||
  436.         COM_CheckParm("-novesa") ||
  437.         WinNT)
  438.     {
  439.         useWinDirect = false;
  440.     }
  441.  
  442.     if (COM_CheckParm("-nodirectdraw") || COM_CheckParm("-noddraw") || COM_CheckParm("-nodd"))
  443.         useDirectDraw = false;
  444.  
  445.     // Initialise the MGL
  446.     MGL_unregisterAllDrivers();
  447.     registerAllDispDrivers();
  448.     registerAllMemDrivers();
  449.     MGL_detectGraph(&driver,&mode);
  450.     m = MGL_availableModes();
  451.  
  452.     if (m[0] != 0xFF)
  453.     {
  454.         lowres = lowstretchedres = 99999;
  455.         lowstretched = 0;
  456.         curmode = 0;
  457.  
  458.     // find the lowest-res mode, or a mode we can stretch up to and get
  459.     // lowest-res that way
  460.         for (i = 0; m[i] != 0xFF; i++)
  461.         {
  462.             MGL_modeResolution(m[i], &xRes, &yRes,&bits);
  463.  
  464.             if ((bits == 8) &&
  465.                 (xRes <= MAXWIDTH) &&
  466.                 (yRes <= MAXHEIGHT) &&
  467.                 (curmode < MAX_MODE_LIST))
  468.             {
  469.                 if (m[i] == grVGA_320x200x256)
  470.                     is_mode0x13 = true;
  471.  
  472.                 if (!COM_CheckParm("-noforcevga"))
  473.                 {
  474.                     if (m[i] == grVGA_320x200x256)
  475.                     {
  476.                         mode = i;
  477.                         break;
  478.                     }
  479.                 }
  480.  
  481.                 if (xRes < lowres)
  482.                 {
  483.                     lowres = xRes;
  484.                     mode = i;
  485.                 }
  486.  
  487.                 if ((xRes < lowstretchedres) && ((xRes >> 1) >= 320))
  488.                 {
  489.                     lowstretchedres = xRes >> 1;
  490.                     stretchedmode = i;
  491.                 }
  492.             }
  493.  
  494.             curmode++;
  495.         }
  496.  
  497.     // if there's a mode we can stretch by 2 up to, thereby effectively getting
  498.     // a lower-res mode than the lowest-res real but still at least 320x200, that
  499.     // will be our default mode
  500.         if (lowstretchedres < lowres)
  501.         {
  502.             mode = stretchedmode;
  503.             lowres = lowstretchedres;
  504.             lowstretched = 1;
  505.         }
  506.  
  507.     // build the mode list, leaving room for the low-res stretched mode, if any
  508.         nummodes++;        // leave room for default mode
  509.  
  510.         for (i = 0; m[i] != 0xFF; i++)
  511.         {
  512.             MGL_modeResolution(m[i], &xRes, &yRes,&bits);
  513.  
  514.             if ((bits == 8) &&
  515.                 (xRes <= MAXWIDTH) &&
  516.                 (yRes <= MAXHEIGHT) &&
  517.                 (nummodes < MAX_MODE_LIST))
  518.             {
  519.                 if (i == mode)
  520.                 {
  521.                     if (lowstretched)
  522.                     {
  523.                         stretchedmode = nummodes;
  524.                         curmode = nummodes++;
  525.                     }
  526.                     else
  527.                     {
  528.                         curmode = MODE_FULLSCREEN_DEFAULT;
  529.                     }
  530.                 }
  531.                 else
  532.                 {
  533.                     curmode = nummodes++;
  534.                 }
  535.  
  536.                 modelist[curmode].type = MS_FULLSCREEN;
  537.                 modelist[curmode].width = xRes;
  538.                 modelist[curmode].height = yRes;
  539.                 sprintf (modelist[curmode].modedesc, "%dx%d", xRes, yRes);
  540.  
  541.                 if (m[i] == grVGA_320x200x256)
  542.                     modelist[curmode].mode13 = 1;
  543.                 else
  544.                     modelist[curmode].mode13 = 0;
  545.  
  546.                 modelist[curmode].modenum = m[i];
  547.                 modelist[curmode].stretched = 0;
  548.                 modelist[curmode].dib = 0;
  549.                 modelist[curmode].fullscreen = 1;
  550.                 modelist[curmode].halfscreen = 0;
  551.                 modelist[curmode].bpp = 8;
  552.             }
  553.         }
  554.  
  555.         if (lowstretched)
  556.         {
  557.             modelist[MODE_FULLSCREEN_DEFAULT] = modelist[stretchedmode];
  558.             modelist[MODE_FULLSCREEN_DEFAULT].stretched = 1;
  559.             modelist[MODE_FULLSCREEN_DEFAULT].width >>= 1;
  560.             modelist[MODE_FULLSCREEN_DEFAULT].height >>= 1;
  561.             sprintf (modelist[MODE_FULLSCREEN_DEFAULT].modedesc, "%dx%d",
  562.                      modelist[MODE_FULLSCREEN_DEFAULT].width,
  563.                      modelist[MODE_FULLSCREEN_DEFAULT].height);
  564.         }
  565.  
  566.         vid_default = MODE_FULLSCREEN_DEFAULT;
  567.  
  568.         temp = m[0];
  569.  
  570.         if (!MGL_init(&driver, &temp, ""))
  571.         {
  572.             initFatalError();
  573.         }
  574.     }
  575.  
  576.     MGL_setSuspendAppCallback(VID_Suspend);
  577. }
  578.  
  579.  
  580. MGLDC *createDisplayDC(int forcemem)
  581. /****************************************************************************
  582. *
  583. * Function:     createDisplayDC
  584. * Returns:      Pointer to the MGL device context to use for the application
  585. *
  586. * Description:  Initialises the MGL and creates an appropriate display
  587. *               device context to be used by the GUI. This creates and
  588. *               apropriate device context depending on the system being
  589. *               compile for, and should be the only place where system
  590. *               specific code is required.
  591. *
  592. ****************************************************************************/
  593. {
  594.     MGLDC            *dc;
  595.     pixel_format_t    pf;
  596.     int                npages;
  597.  
  598.     // Start the specified video mode
  599.     if (!MGL_changeDisplayMode(mode))
  600.         initFatalError();
  601.  
  602.     npages = MGL_availablePages(mode);
  603.  
  604.     if (npages > 3)
  605.         npages = 3;
  606.  
  607.     if (!COM_CheckParm ("-notriplebuf"))
  608.     {
  609.         if (npages > 2)
  610.         {
  611.             npages = 2;
  612.         }
  613.     }
  614.  
  615.     if ((dc = MGL_createDisplayDC(npages)) == NULL)
  616.         return NULL;
  617.  
  618.     if (!forcemem && (MGL_surfaceAccessType(dc)) == MGL_LINEAR_ACCESS && (dc->mi.maxPage > 0))
  619.     {
  620.         MGL_makeCurrentDC(dc);
  621.         memdc = NULL;
  622.     }
  623.     else
  624.     {
  625.         // Set up for blitting from a memory buffer
  626.         memdc = MGL_createMemoryDC(MGL_sizex(dc)+1,MGL_sizey(dc)+1,8,&pf);
  627.         MGL_makeCurrentDC(memdc);
  628.     }
  629.  
  630.     // Enable page flipping even for even for blitted surfaces
  631.     if (forcemem)
  632.     {
  633.         vid.numpages = 1;
  634.     }
  635.     else
  636.     {
  637.         vid.numpages = dc->mi.maxPage + 1;
  638.  
  639.         if (vid.numpages > 1)
  640.         {
  641.             // Set up for page flipping
  642.             MGL_setActivePage(dc, aPage = 1);
  643.             MGL_setVisualPage(dc, vPage = 0, false);
  644.         }
  645.  
  646.         if (vid.numpages > 3)
  647.             vid.numpages = 3;
  648.     }
  649.  
  650.     if (vid.numpages == 2)
  651.         waitVRT = true;
  652.     else
  653.         waitVRT = false;
  654.  
  655.     return dc;
  656. }
  657.  
  658.  
  659. void VID_InitMGLDIB (HINSTANCE hInstance)
  660. {
  661.     WNDCLASS        wc;
  662.     HDC                hdc;
  663.     int                i;
  664.  
  665.     hIcon = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_ICON2));
  666.  
  667.     /* Register the frame class */
  668.     wc.style         = 0;
  669.     wc.lpfnWndProc   = (WNDPROC)MainWndProc;
  670.     wc.cbClsExtra    = 0;
  671.     wc.cbWndExtra    = 0;
  672.     wc.hInstance     = hInstance;
  673.     wc.hIcon         = 0;
  674.     wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
  675.     wc.hbrBackground = NULL;
  676.     wc.lpszMenuName  = 0;
  677.     wc.lpszClassName = "WinQuake";
  678.  
  679.     if (!RegisterClass (&wc) )
  680.         Sys_Error ("Couldn't register window class");
  681.  
  682.     /* Find the size for the DIB window */
  683.     /* Initialise the MGL for windowed operation */
  684.     MGL_setAppInstance(hInstance);
  685.     registerAllMemDrivers();
  686.     MGL_initWindowed("");
  687.  
  688.     modelist[0].type = MS_WINDOWED;
  689.     modelist[0].width = 320;
  690.     modelist[0].height = 240;
  691.     strcpy (modelist[0].modedesc, "320x240");
  692.     modelist[0].mode13 = 0;
  693.     modelist[0].modenum = MODE_WINDOWED;
  694.     modelist[0].stretched = 0;
  695.     modelist[0].dib = 1;
  696.     modelist[0].fullscreen = 0;
  697.     modelist[0].halfscreen = 0;
  698.     modelist[0].bpp = 8;
  699.  
  700.     modelist[1].type = MS_WINDOWED;
  701.     modelist[1].width = 640;
  702.     modelist[1].height = 480;
  703.     strcpy (modelist[1].modedesc, "640x480");
  704.     modelist[1].mode13 = 0;
  705.     modelist[1].modenum = MODE_WINDOWED + 1;
  706.     modelist[1].stretched = 1;
  707.     modelist[1].dib = 1;
  708.     modelist[1].fullscreen = 0;
  709.     modelist[1].halfscreen = 0;
  710.     modelist[1].bpp = 8;
  711.  
  712.     modelist[2].type = MS_WINDOWED;
  713.     modelist[2].width = 800;
  714.     modelist[2].height = 600;
  715.     strcpy (modelist[2].modedesc, "800x600");
  716.     modelist[2].mode13 = 0;
  717.     modelist[2].modenum = MODE_WINDOWED + 2;
  718.     modelist[2].stretched = 1;
  719.     modelist[2].dib = 1;
  720.     modelist[2].fullscreen = 0;
  721.     modelist[2].halfscreen = 0;
  722.     modelist[2].bpp = 8;
  723.  
  724. // automatically stretch the default mode up if > 640x480 desktop resolution
  725.     hdc = GetDC(NULL);
  726.  
  727.     if ((GetDeviceCaps(hdc, HORZRES) > 640) && !COM_CheckParm("-noautostretch"))
  728.     {
  729.         vid_default = MODE_WINDOWED + 1;
  730.     }
  731.     else
  732.     {
  733.         vid_default = MODE_WINDOWED;
  734.     }
  735.  
  736.     windowed_default = vid_default;
  737.  
  738.     ReleaseDC(NULL,hdc);
  739.  
  740.     nummodes = 3;    // reserve space for windowed mode
  741.  
  742.     DDActive = 0;
  743. }
  744.  
  745.  
  746. /*
  747. =================
  748. VID_InitFullDIB
  749. =================
  750. */
  751. void VID_InitFullDIB (HINSTANCE hInstance)
  752. {
  753.     DEVMODE    devmode;
  754.     int        i, j, modenum, cmodes, existingmode, originalnummodes, lowestres;
  755.     int        numlowresmodes, bpp, done;
  756.     int        cstretch, istretch, mstretch;
  757.     BOOL    stat;
  758.  
  759. // enumerate 8 bpp modes
  760.     originalnummodes = nummodes;
  761.     modenum = 0;
  762.     lowestres = 99999;
  763.  
  764.     do
  765.     {
  766.         stat = EnumDisplaySettings (NULL, modenum, &devmode);
  767.  
  768.         if ((devmode.dmBitsPerPel == 8) &&
  769.             (devmode.dmPelsWidth <= MAXWIDTH) &&
  770.             (devmode.dmPelsHeight <= MAXHEIGHT) &&
  771.             (nummodes < MAX_MODE_LIST))
  772.         {
  773.             devmode.dmFields = DM_BITSPERPEL |
  774.                                DM_PELSWIDTH |
  775.                                DM_PELSHEIGHT;
  776.  
  777.             if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
  778.                     DISP_CHANGE_SUCCESSFUL)
  779.             {
  780.                 modelist[nummodes].type = MS_FULLDIB;
  781.                 modelist[nummodes].width = devmode.dmPelsWidth;
  782.                 modelist[nummodes].height = devmode.dmPelsHeight;
  783.                 modelist[nummodes].modenum = 0;
  784.                 modelist[nummodes].mode13 = 0;
  785.                 modelist[nummodes].stretched = 0;
  786.                 modelist[nummodes].halfscreen = 0;
  787.                 modelist[nummodes].dib = 1;
  788.                 modelist[nummodes].fullscreen = 1;
  789.                 modelist[nummodes].bpp = devmode.dmBitsPerPel;
  790.                 sprintf (modelist[nummodes].modedesc, "%dx%d",
  791.                          devmode.dmPelsWidth, devmode.dmPelsHeight);
  792.  
  793.             // if the width is more than twice the height, reduce it by half because this
  794.             // is probably a dual-screen monitor
  795.                 if (!COM_CheckParm("-noadjustaspect"))
  796.                 {
  797.                     if (modelist[nummodes].width > (modelist[nummodes].height << 1))
  798.                     {
  799.                         modelist[nummodes].width >>= 1;
  800.                         modelist[nummodes].halfscreen = 1;
  801.                         sprintf (modelist[nummodes].modedesc, "%dx%d",
  802.                                  modelist[nummodes].width,
  803.                                  modelist[nummodes].height);
  804.                     }
  805.                 }
  806.  
  807.                 for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
  808.                 {
  809.                     if ((modelist[nummodes].width == modelist[i].width) &&
  810.                         (modelist[nummodes].height == modelist[i].height))
  811.                     {
  812.                         existingmode = 1;
  813.                         break;
  814.                     }
  815.                 }
  816.  
  817.                 if (!existingmode)
  818.                 {
  819.                     if (modelist[nummodes].width < lowestres)
  820.                         lowestres = modelist[nummodes].width;
  821.  
  822.                     nummodes++;
  823.                 }
  824.             }
  825.         }
  826.  
  827.         modenum++;
  828.     } while (stat);
  829.  
  830. // see if any of them were actually settable; if so, this is our mode list,
  831. // else enumerate all modes; our mode list is whichever ones are settable
  832. // with > 8 bpp
  833.     if (nummodes == originalnummodes)
  834.     {
  835.         modenum = 0;
  836.         lowestres = 99999;
  837.  
  838.         Con_SafePrintf ("No 8-bpp fullscreen DIB modes found\n");
  839.  
  840.         do
  841.         {
  842.             stat = EnumDisplaySettings (NULL, modenum, &devmode);
  843.  
  844.             if ((((devmode.dmPelsWidth <= MAXWIDTH) &&
  845.                   (devmode.dmPelsHeight <= MAXHEIGHT)) ||
  846.                  (!COM_CheckParm("-noadjustaspect") &&
  847.                   (devmode.dmPelsWidth <= (MAXWIDTH*2)) &&
  848.                   (devmode.dmPelsWidth > (devmode.dmPelsHeight*2)))) &&
  849.                 (nummodes < MAX_MODE_LIST) &&
  850.                 (devmode.dmBitsPerPel > 8))
  851.             {
  852.                 devmode.dmFields = DM_BITSPERPEL |
  853.                                    DM_PELSWIDTH |
  854.                                    DM_PELSHEIGHT;
  855.  
  856.                 if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
  857.                         DISP_CHANGE_SUCCESSFUL)
  858.                 {
  859.                     modelist[nummodes].type = MS_FULLDIB;
  860.                     modelist[nummodes].width = devmode.dmPelsWidth;
  861.                     modelist[nummodes].height = devmode.dmPelsHeight;
  862.                     modelist[nummodes].modenum = 0;
  863.                     modelist[nummodes].mode13 = 0;
  864.                     modelist[nummodes].stretched = 0;
  865.                     modelist[nummodes].halfscreen = 0;
  866.                     modelist[nummodes].dib = 1;
  867.                     modelist[nummodes].fullscreen = 1;
  868.                     modelist[nummodes].bpp = devmode.dmBitsPerPel;
  869.                     sprintf (modelist[nummodes].modedesc, "%dx%d",
  870.                              devmode.dmPelsWidth, devmode.dmPelsHeight);
  871.  
  872.                 // if the width is more than twice the height, reduce it by half because this
  873.                 // is probably a dual-screen monitor
  874.                     if (!COM_CheckParm("-noadjustaspect"))
  875.                     {
  876.                         if (modelist[nummodes].width > (modelist[nummodes].height*2))
  877.                         {
  878.                             modelist[nummodes].width >>= 1;
  879.                             modelist[nummodes].halfscreen = 1;
  880.                             sprintf (modelist[nummodes].modedesc, "%dx%d",
  881.                                      modelist[nummodes].width,
  882.                                      modelist[nummodes].height);
  883.                         }
  884.                     }
  885.  
  886.                     for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
  887.                     {
  888.                         if ((modelist[nummodes].width == modelist[i].width) &&
  889.                             (modelist[nummodes].height == modelist[i].height))
  890.                         {
  891.                         // pick the lowest available bpp
  892.                             if (modelist[nummodes].bpp < modelist[i].bpp)
  893.                                 modelist[i] = modelist[nummodes];
  894.  
  895.                             existingmode = 1;
  896.                             break;
  897.                         }
  898.                     }
  899.  
  900.                     if (!existingmode)
  901.                     {
  902.                         if (modelist[nummodes].width < lowestres)
  903.                             lowestres = modelist[nummodes].width;
  904.  
  905.                         nummodes++;
  906.                     }
  907.                 }
  908.             }
  909.  
  910.             modenum++;
  911.         } while (stat);
  912.     }
  913.  
  914. // see if there are any low-res modes that aren't being reported
  915.     numlowresmodes = sizeof(lowresmodes) / sizeof(lowresmodes[0]);
  916.     bpp = 8;
  917.     done = 0;
  918.  
  919. // first make sure the driver doesn't just answer yes to all tests
  920.     devmode.dmBitsPerPel = 8;
  921.     devmode.dmPelsWidth = 42;
  922.     devmode.dmPelsHeight = 37;
  923.     devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  924.  
  925.     if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
  926.             DISP_CHANGE_SUCCESSFUL)
  927.     {
  928.         done = 1;
  929.     }
  930.  
  931.     while (!done)
  932.     {
  933.         for (j=0 ; (j<numlowresmodes) && (nummodes < MAX_MODE_LIST) ; j++)
  934.         {
  935.             devmode.dmBitsPerPel = bpp;
  936.             devmode.dmPelsWidth = lowresmodes[j].width;
  937.             devmode.dmPelsHeight = lowresmodes[j].height;
  938.             devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  939.  
  940.             if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
  941.                     DISP_CHANGE_SUCCESSFUL)
  942.             {
  943.                     modelist[nummodes].type = MS_FULLDIB;
  944.                     modelist[nummodes].width = devmode.dmPelsWidth;
  945.                     modelist[nummodes].height = devmode.dmPelsHeight;
  946.                     modelist[nummodes].modenum = 0;
  947.                     modelist[nummodes].mode13 = 0;
  948.                     modelist[nummodes].stretched = 0;
  949.                     modelist[nummodes].halfscreen = 0;
  950.                     modelist[nummodes].dib = 1;
  951.                     modelist[nummodes].fullscreen = 1;
  952.                     modelist[nummodes].bpp = devmode.dmBitsPerPel;
  953.                     sprintf (modelist[nummodes].modedesc, "%dx%d",
  954.                              devmode.dmPelsWidth, devmode.dmPelsHeight);
  955.  
  956.             // we only want the lowest-bpp version of each mode
  957.                 for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
  958.                 {
  959.                     if ((modelist[nummodes].width == modelist[i].width)   &&
  960.                         (modelist[nummodes].height == modelist[i].height) &&
  961.                         (modelist[nummodes].bpp >= modelist[i].bpp))
  962.                     {
  963.                         existingmode = 1;
  964.                         break;
  965.                     }
  966.                 }
  967.  
  968.                 if (!existingmode)
  969.                 {
  970.                     if (modelist[nummodes].width < lowestres)
  971.                         lowestres = modelist[nummodes].width;
  972.  
  973.                     nummodes++;
  974.                 }
  975.             }
  976.         }
  977.  
  978.         switch (bpp)
  979.         {
  980.             case 8:
  981.                 bpp = 16;
  982.                 break;
  983.  
  984.             case 16:
  985.                 bpp = 32;
  986.                 break;
  987.  
  988.             case 32:
  989.                 done = 1;
  990.                 break;
  991.         }
  992.     }
  993.  
  994. // now add the lowest stretch-by-2 pseudo-modes between 320-wide
  995. // (inclusive) and lowest real res (not inclusive)
  996. // don't bother if we have a real VGA mode 0x13 mode
  997.     if (!is_mode0x13)
  998.     {
  999.         for (i=originalnummodes, cstretch=0 ; i<nummodes ; i++)
  1000.         {
  1001.             if (((modelist[i].width >> 1) < lowestres) &&
  1002.                 ((modelist[i].width >> 1) >= 320))
  1003.             {
  1004.                 lowestres = modelist[i].width >> 1;
  1005.                 cstretch = 1;
  1006.                 mstretch = i;
  1007.             }
  1008.         }
  1009.  
  1010.         if ((nummodes + cstretch) > MAX_MODE_LIST)
  1011.             cstretch = MAX_MODE_LIST - nummodes;
  1012.  
  1013.         if (cstretch > 0)
  1014.         {
  1015.             for (i=(nummodes-1) ; i>=originalnummodes ; i--)
  1016.                 modelist[i+cstretch] = modelist[i];
  1017.  
  1018.             nummodes += cstretch;
  1019.             istretch = originalnummodes;
  1020.  
  1021.             modelist[istretch] = modelist[mstretch];
  1022.             modelist[istretch].width >>= 1;
  1023.             modelist[istretch].height >>= 1;
  1024.             modelist[istretch].stretched = 1;
  1025.             sprintf (modelist[istretch].modedesc, "%dx%d",
  1026.                      modelist[istretch].width, modelist[istretch].height);
  1027.         }
  1028.     }
  1029.  
  1030.     if (nummodes != originalnummodes)
  1031.         vid_default = MODE_FULLSCREEN_DEFAULT;
  1032.     else
  1033.         Con_SafePrintf ("No fullscreen DIB modes found\n");
  1034. }
  1035.  
  1036.  
  1037. /*
  1038. =================
  1039. VID_NumModes
  1040. =================
  1041. */
  1042. int VID_NumModes (void)
  1043. {
  1044.     return nummodes;
  1045. }
  1046.  
  1047.     
  1048. /*
  1049. =================
  1050. VID_GetModePtr
  1051. =================
  1052. */
  1053. vmode_t *VID_GetModePtr (int modenum)
  1054. {
  1055.  
  1056.     if ((modenum >= 0) && (modenum < nummodes))
  1057.         return &modelist[modenum];
  1058.     else
  1059.         return &badmode;
  1060. }
  1061.  
  1062.  
  1063. /*
  1064. =================
  1065. VID_CheckModedescFixup
  1066. =================
  1067. */
  1068. void VID_CheckModedescFixup (int mode)
  1069. {
  1070.     int        x, y, stretch;
  1071.  
  1072.     if (mode == MODE_SETTABLE_WINDOW)
  1073.     {
  1074.         modelist[mode].stretched = (int)vid_stretch_by_2.value;
  1075.         stretch = modelist[mode].stretched;
  1076.  
  1077.         if (vid_config_x.value < (320 << stretch))
  1078.             vid_config_x.value = 320 << stretch;
  1079.  
  1080.         if (vid_config_y.value < (200 << stretch))
  1081.             vid_config_y.value = 200 << stretch;
  1082.  
  1083.         x = (int)vid_config_x.value;
  1084.         y = (int)vid_config_y.value;
  1085.         sprintf (modelist[mode].modedesc, "%dx%d", x, y);
  1086.         modelist[mode].width = x;
  1087.         modelist[mode].height = y;
  1088.     }
  1089. }
  1090.  
  1091.  
  1092. /*
  1093. =================
  1094. VID_GetModeDescriptionMemCheck
  1095. =================
  1096. */
  1097. char *VID_GetModeDescriptionMemCheck (int mode)
  1098. {
  1099.     char        *pinfo;
  1100.     vmode_t        *pv;
  1101.  
  1102.     if ((mode < 0) || (mode >= nummodes))
  1103.         return NULL;
  1104.  
  1105.     VID_CheckModedescFixup (mode);
  1106.  
  1107.     pv = VID_GetModePtr (mode);
  1108.     pinfo = pv->modedesc;
  1109.  
  1110.     if (VID_CheckAdequateMem (pv->width, pv->height))
  1111.     {
  1112.         return pinfo;
  1113.     }
  1114.     else
  1115.     {
  1116.         return NULL;
  1117.     }
  1118. }
  1119.  
  1120.  
  1121. /*
  1122. =================
  1123. VID_GetModeDescription
  1124. =================
  1125. */
  1126. char *VID_GetModeDescription (int mode)
  1127. {
  1128.     char        *pinfo;
  1129.     vmode_t        *pv;
  1130.  
  1131.     if ((mode < 0) || (mode >= nummodes))
  1132.         return NULL;
  1133.  
  1134.     VID_CheckModedescFixup (mode);
  1135.  
  1136.     pv = VID_GetModePtr (mode);
  1137.     pinfo = pv->modedesc;
  1138.     return pinfo;
  1139. }
  1140.  
  1141.  
  1142. /*
  1143. =================
  1144. VID_GetModeDescription2
  1145.  
  1146. Tacks on "windowed" or "fullscreen"
  1147. =================
  1148. */
  1149. char *VID_GetModeDescription2 (int mode)
  1150. {
  1151.     static char    pinfo[40];
  1152.     vmode_t        *pv;
  1153.  
  1154.     if ((mode < 0) || (mode >= nummodes))
  1155.         return NULL;
  1156.  
  1157.     VID_CheckModedescFixup (mode);
  1158.  
  1159.     pv = VID_GetModePtr (mode);
  1160.  
  1161.     if (modelist[mode].type == MS_FULLSCREEN)
  1162.     {
  1163.         sprintf(pinfo,"%s fullscreen", pv->modedesc);
  1164.     }
  1165.     else if (modelist[mode].type == MS_FULLDIB)
  1166.     {
  1167.         sprintf(pinfo,"%s fullscreen", pv->modedesc);
  1168.     }
  1169.     else
  1170.     {
  1171.         sprintf(pinfo, "%s windowed", pv->modedesc);
  1172.     }
  1173.  
  1174.     return pinfo;
  1175. }
  1176.  
  1177.  
  1178. // KJB: Added this to return the mode driver name in description for console
  1179.  
  1180. char *VID_GetExtModeDescription (int mode)
  1181. {
  1182.     static char    pinfo[40];
  1183.     vmode_t        *pv;
  1184.  
  1185.     if ((mode < 0) || (mode >= nummodes))
  1186.         return NULL;
  1187.  
  1188.     VID_CheckModedescFixup (mode);
  1189.  
  1190.     pv = VID_GetModePtr (mode);
  1191.     if (modelist[mode].type == MS_FULLSCREEN)
  1192.     {
  1193.         sprintf(pinfo,"%s fullscreen %s",pv->modedesc,
  1194.                 MGL_modeDriverName(pv->modenum));
  1195.     }
  1196.     else if (modelist[mode].type == MS_FULLDIB)
  1197.     {
  1198.         sprintf(pinfo,"%s fullscreen DIB", pv->modedesc);
  1199.     }
  1200.     else
  1201.     {
  1202.         sprintf(pinfo, "%s windowed", pv->modedesc);
  1203.     }
  1204.  
  1205.     return pinfo;
  1206. }
  1207.  
  1208.  
  1209. void DestroyDIBWindow (void)
  1210. {
  1211.  
  1212.     if (modestate == MS_WINDOWED)
  1213.     {
  1214.     // destroy the associated MGL DC's; the window gets reused
  1215.         if (windc)
  1216.             MGL_destroyDC(windc);
  1217.         if (dibdc)
  1218.             MGL_destroyDC(dibdc);
  1219.         windc = dibdc = NULL;
  1220.     }
  1221. }
  1222.  
  1223.  
  1224. void DestroyFullscreenWindow (void)
  1225. {
  1226.  
  1227.     if (modestate == MS_FULLSCREEN)
  1228.     {
  1229.     // destroy the existing fullscreen mode and DC's
  1230.         if (mgldc)
  1231.             MGL_destroyDC (mgldc);
  1232.         if (memdc)
  1233.             MGL_destroyDC (memdc);
  1234.         mgldc = memdc = NULL;
  1235.     }
  1236. }
  1237.  
  1238.  
  1239.  
  1240. void DestroyFullDIBWindow (void)
  1241. {
  1242.     if (modestate == MS_FULLDIB)
  1243.     {
  1244.         ChangeDisplaySettings (NULL, CDS_FULLSCREEN);
  1245.  
  1246.     // Destroy the fullscreen DIB window and associated MGL DC's
  1247.         if (windc)
  1248.             MGL_destroyDC(windc);
  1249.         if (dibdc)
  1250.             MGL_destroyDC(dibdc);
  1251.         windc = dibdc = NULL;
  1252.     }
  1253. }
  1254.  
  1255.  
  1256. qboolean VID_SetWindowedMode (int modenum)
  1257. {
  1258.     HDC                hdc;
  1259.     pixel_format_t    pf;
  1260.     qboolean        stretched;
  1261.     int                lastmodestate;
  1262.     LONG            wlong;
  1263.  
  1264.     if (!windowed_mode_set)
  1265.     {
  1266.         if (COM_CheckParm ("-resetwinpos"))
  1267.         {
  1268.             Cvar_SetValue ("vid_window_x", 0.0);
  1269.             Cvar_SetValue ("vid_window_y", 0.0);
  1270.         }
  1271.  
  1272.         windowed_mode_set;
  1273.     }
  1274.  
  1275.     VID_CheckModedescFixup (modenum);
  1276.  
  1277.     DDActive = 0;
  1278.     lastmodestate = modestate;
  1279.  
  1280.     DestroyFullscreenWindow ();
  1281.     DestroyFullDIBWindow ();
  1282.  
  1283.     if (windc)
  1284.         MGL_destroyDC(windc);
  1285.     if (dibdc)
  1286.         MGL_destroyDC(dibdc);
  1287.     windc = dibdc = NULL;
  1288.  
  1289. // KJB: Signal to the MGL that we are going back to windowed mode
  1290.     if (!MGL_changeDisplayMode(grWINDOWED))
  1291.         initFatalError();
  1292.  
  1293.     WindowRect.top = WindowRect.left = 0;
  1294.  
  1295.     WindowRect.right = modelist[modenum].width;
  1296.     WindowRect.bottom = modelist[modenum].height;
  1297.     stretched = modelist[modenum].stretched;
  1298.  
  1299.     DIBWidth = modelist[modenum].width;
  1300.     DIBHeight = modelist[modenum].height;
  1301.  
  1302.     if (stretched)
  1303.     {
  1304.         DIBWidth >>= 1;
  1305.         DIBHeight >>= 1;
  1306.     }
  1307.  
  1308.     WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU |
  1309.                   WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPSIBLINGS |
  1310.                   WS_CLIPCHILDREN;
  1311.     ExWindowStyle = 0;
  1312.     AdjustWindowRectEx(&WindowRect, WindowStyle, FALSE, 0);
  1313.  
  1314. // the first time we're called to set the mode, create the window we'll use
  1315. // for the rest of the session
  1316.     if (!vid_mode_set)
  1317.     {
  1318.         mainwindow = CreateWindowEx (
  1319.              ExWindowStyle,
  1320.              "WinQuake",
  1321.              "WinQuake",
  1322.              WindowStyle,
  1323.              0, 0,
  1324.              WindowRect.right - WindowRect.left,
  1325.              WindowRect.bottom - WindowRect.top,
  1326.              NULL,
  1327.              NULL,
  1328.              global_hInstance,
  1329.              NULL);
  1330.  
  1331.         if (!mainwindow)
  1332.             Sys_Error ("Couldn't create DIB window");
  1333.  
  1334.     // tell MGL to use this window for fullscreen modes
  1335.         MGL_registerFullScreenWindow (mainwindow);
  1336.  
  1337.         vid_mode_set = true;
  1338.     }
  1339.     else
  1340.     {
  1341.         SetWindowLong(mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
  1342.         SetWindowLong(mainwindow, GWL_EXSTYLE, ExWindowStyle);
  1343.     }
  1344.  
  1345.     if (!SetWindowPos (mainwindow,
  1346.                            NULL,
  1347.                            0, 0,
  1348.                            WindowRect.right - WindowRect.left,
  1349.                            WindowRect.bottom - WindowRect.top,
  1350.                            SWP_NOCOPYBITS | SWP_NOZORDER |
  1351.                             SWP_HIDEWINDOW))
  1352.         {
  1353.             Sys_Error ("Couldn't resize DIB window");
  1354.         }
  1355.  
  1356.     if (hide_window)
  1357.         return true;
  1358.  
  1359. // position and show the DIB window
  1360.     VID_CheckWindowXY ();
  1361.     SetWindowPos (mainwindow, NULL, (int)vid_window_x.value,
  1362.                   (int)vid_window_y.value, 0, 0,
  1363.                   SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
  1364.  
  1365.     if (force_minimized)
  1366.         ShowWindow (mainwindow, SW_MINIMIZE);
  1367.     else
  1368.         ShowWindow (mainwindow, SW_SHOWDEFAULT);
  1369.  
  1370.     UpdateWindow (mainwindow);
  1371.  
  1372.     modestate = MS_WINDOWED;
  1373.     vid_fulldib_on_focus_mode = 0;
  1374.  
  1375. // because we have set the background brush for the window to NULL
  1376. // (to avoid flickering when re-sizing the window on the desktop),
  1377. // we clear the window to black when created, otherwise it will be
  1378. // empty while Quake starts up.
  1379.     hdc = GetDC(mainwindow);
  1380.     PatBlt(hdc,0,0,WindowRect.right,WindowRect.bottom,BLACKNESS);
  1381.     ReleaseDC(mainwindow, hdc);
  1382.  
  1383.     /* Create the MGL window DC and the MGL memory DC */
  1384.     if ((windc = MGL_createWindowedDC(mainwindow)) == NULL)
  1385.         MGL_fatalError("Unable to create Windowed DC!");
  1386.  
  1387.     if ((dibdc = MGL_createMemoryDC(DIBWidth,DIBHeight,8,&pf)) == NULL)
  1388.         MGL_fatalError("Unable to create Memory DC!");
  1389.  
  1390.     MGL_makeCurrentDC(dibdc);
  1391.  
  1392.     vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
  1393.     vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
  1394.     vid.numpages = 1;
  1395.     vid.maxwarpwidth = WARP_WIDTH;
  1396.     vid.maxwarpheight = WARP_HEIGHT;
  1397.     vid.height = vid.conheight = DIBHeight;
  1398.     vid.width = vid.conwidth = DIBWidth;
  1399.     vid.aspect = ((float)vid.height / (float)vid.width) *
  1400.                 (320.0 / 240.0);
  1401.  
  1402.     vid_stretched = stretched;
  1403.  
  1404.     SendMessage (mainwindow, WM_SETICON, (WPARAM)TRUE, (LPARAM)hIcon);
  1405.     SendMessage (mainwindow, WM_SETICON, (WPARAM)FALSE, (LPARAM)hIcon);
  1406.  
  1407.     return true;
  1408. }
  1409.  
  1410.  
  1411. qboolean VID_SetFullscreenMode (int modenum)
  1412. {
  1413.  
  1414.     DDActive = 1;
  1415.  
  1416.     DestroyDIBWindow ();
  1417.     DestroyFullDIBWindow ();
  1418.  
  1419.     mode = modelist[modenum].modenum;
  1420.  
  1421.     // Destroy old DC's, resetting back to fullscreen mode
  1422.     if (mgldc)
  1423.         MGL_destroyDC (mgldc);
  1424.     if (memdc)
  1425.         MGL_destroyDC (memdc);
  1426.     mgldc = memdc = NULL;
  1427.  
  1428.     if ((mgldc = createDisplayDC (modelist[modenum].stretched ||
  1429.          (int)vid_nopageflip.value)) == NULL)
  1430.     {
  1431.         return false;
  1432.     }
  1433.  
  1434.     modestate = MS_FULLSCREEN;
  1435.     vid_fulldib_on_focus_mode = 0;
  1436.  
  1437.     vid.buffer = vid.conbuffer = vid.direct = NULL;
  1438.     vid.maxwarpwidth = WARP_WIDTH;
  1439.     vid.maxwarpheight = WARP_HEIGHT;
  1440.     DIBHeight = vid.height = vid.conheight = modelist[modenum].height;
  1441.     DIBWidth = vid.width = vid.conwidth = modelist[modenum].width;
  1442.     vid.aspect = ((float)vid.height / (float)vid.width) *
  1443.                 (320.0 / 240.0);
  1444.  
  1445.     vid_stretched = modelist[modenum].stretched;
  1446.  
  1447. // needed because we're not getting WM_MOVE messages fullscreen on NT
  1448.     window_x = 0;
  1449.     window_y = 0;
  1450.  
  1451. // set the large icon, so the Quake icon will show up in the taskbar
  1452.     SendMessage (mainwindow, WM_SETICON, (WPARAM)1, (LPARAM)hIcon);
  1453.     SendMessage (mainwindow, WM_SETICON, (WPARAM)0, (LPARAM)hIcon);
  1454.  
  1455. // shouldn't be needed, but Kendall needs to let us get the activation
  1456. // message for this not to be needed on NT
  1457.     AppActivate (true, false);
  1458.  
  1459.     return true;
  1460. }
  1461.  
  1462.  
  1463. qboolean VID_SetFullDIBMode (int modenum)
  1464. {
  1465.     HDC                hdc;
  1466.     pixel_format_t    pf;
  1467.     int                lastmodestate;
  1468.  
  1469.     DDActive = 0;
  1470.  
  1471.     DestroyFullscreenWindow ();
  1472.     DestroyDIBWindow ();
  1473.  
  1474.     if (windc)
  1475.         MGL_destroyDC(windc);
  1476.     if (dibdc)
  1477.         MGL_destroyDC(dibdc);
  1478.     windc = dibdc = NULL;
  1479.  
  1480.     // KJB: Signal to the MGL that we are going back to windowed mode
  1481.     if (!MGL_changeDisplayMode(grWINDOWED))
  1482.         initFatalError();
  1483.  
  1484.     gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  1485.     gdevmode.dmBitsPerPel = modelist[modenum].bpp;
  1486.     gdevmode.dmPelsWidth = modelist[modenum].width << modelist[modenum].stretched <<
  1487.                            modelist[modenum].halfscreen;
  1488.     gdevmode.dmPelsHeight = modelist[modenum].height << modelist[modenum].stretched;
  1489.     gdevmode.dmSize = sizeof (gdevmode);
  1490.  
  1491.     if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
  1492.         Sys_Error ("Couldn't set fullscreen DIB mode");
  1493.  
  1494.     lastmodestate = modestate;
  1495.     modestate = MS_FULLDIB;
  1496.     vid_fulldib_on_focus_mode = modenum;
  1497.  
  1498.     WindowRect.top = WindowRect.left = 0;
  1499.  
  1500.     hdc = GetDC(NULL);
  1501.  
  1502.     WindowRect.right = modelist[modenum].width << modelist[modenum].stretched;
  1503.     WindowRect.bottom = modelist[modenum].height << modelist[modenum].stretched;
  1504.  
  1505.     ReleaseDC(NULL,hdc);
  1506.  
  1507.     DIBWidth = modelist[modenum].width;
  1508.     DIBHeight = modelist[modenum].height;
  1509.  
  1510.     WindowStyle = WS_POPUP | WS_SYSMENU | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
  1511.     ExWindowStyle = 0;
  1512.     AdjustWindowRectEx(&WindowRect, WindowStyle, FALSE, 0);
  1513.  
  1514.     SetWindowLong(mainwindow, GWL_STYLE, WindowStyle | WS_VISIBLE);
  1515.     SetWindowLong(mainwindow, GWL_EXSTYLE, ExWindowStyle);
  1516.  
  1517.     if (!SetWindowPos (mainwindow,
  1518.                            NULL,
  1519.                            0, 0,
  1520.                            WindowRect.right - WindowRect.left,
  1521.                            WindowRect.bottom - WindowRect.top,
  1522.                            SWP_NOCOPYBITS | SWP_NOZORDER))
  1523.         {
  1524.             Sys_Error ("Couldn't resize DIB window");
  1525.         }
  1526.  
  1527. // position and show the DIB window
  1528.     SetWindowPos (mainwindow, HWND_TOPMOST, 0, 0, 0, 0,
  1529.                   SWP_NOSIZE | SWP_SHOWWINDOW | SWP_DRAWFRAME);
  1530.     ShowWindow (mainwindow, SW_SHOWDEFAULT);
  1531.     UpdateWindow (mainwindow);
  1532.  
  1533.     // Because we have set the background brush for the window to NULL
  1534.     // (to avoid flickering when re-sizing the window on the desktop), we
  1535.     // clear the window to black when created, otherwise it will be
  1536.     // empty while Quake starts up.
  1537.     hdc = GetDC(mainwindow);
  1538.     PatBlt(hdc,0,0,WindowRect.right,WindowRect.bottom,BLACKNESS);
  1539.     ReleaseDC(mainwindow, hdc);
  1540.  
  1541.     /* Create the MGL window DC and the MGL memory DC */
  1542.     if ((windc = MGL_createWindowedDC(mainwindow)) == NULL)
  1543.         MGL_fatalError("Unable to create Fullscreen DIB DC!");
  1544.  
  1545.     if ((dibdc = MGL_createMemoryDC(DIBWidth,DIBHeight,8,&pf)) == NULL)
  1546.         MGL_fatalError("Unable to create Memory DC!");
  1547.  
  1548.     MGL_makeCurrentDC(dibdc);
  1549.  
  1550.     vid.buffer = vid.conbuffer = vid.direct = dibdc->surface;
  1551.     vid.rowbytes = vid.conrowbytes = dibdc->mi.bytesPerLine;
  1552.     vid.numpages = 1;
  1553.     vid.maxwarpwidth = WARP_WIDTH;
  1554.     vid.maxwarpheight = WARP_HEIGHT;
  1555.     vid.height = vid.conheight = DIBHeight;
  1556.     vid.width = vid.conwidth = DIBWidth;
  1557.     vid.aspect = ((float)vid.height / (float)vid.width) *
  1558.                 (320.0 / 240.0);
  1559.  
  1560.     vid_stretched = modelist[modenum].stretched;
  1561.  
  1562. // needed because we're not getting WM_MOVE messages fullscreen on NT
  1563.     window_x = 0;
  1564.     window_y = 0;
  1565.  
  1566.     return true;
  1567. }
  1568.  
  1569.  
  1570. void VID_RestoreOldMode (int original_mode)
  1571. {
  1572.     static qboolean    inerror = false;
  1573.  
  1574.     if (inerror)
  1575.         return;
  1576.  
  1577.     in_mode_set = false;
  1578.     inerror = true;
  1579.  
  1580. // make sure mode set happens (video mode changes)
  1581.     vid_modenum = original_mode - 1;
  1582.  
  1583.     if (!VID_SetMode (original_mode, vid_curpal))
  1584.     {
  1585.         vid_modenum = MODE_WINDOWED - 1;
  1586.  
  1587.         if (!VID_SetMode (windowed_default, vid_curpal))
  1588.             Sys_Error ("Can't set any video mode");
  1589.     }
  1590.  
  1591.     inerror = false;
  1592. }
  1593.  
  1594.  
  1595. void VID_SetDefaultMode (void)
  1596. {
  1597.  
  1598.     if (vid_initialized)
  1599.         VID_SetMode (0, vid_curpal);
  1600.  
  1601.     IN_DeactivateMouse ();
  1602. }
  1603.  
  1604.  
  1605. int VID_SetMode (int modenum, unsigned char *palette)
  1606. {
  1607.     int                original_mode, temp, dummy;
  1608.     qboolean        stat;
  1609.     MSG                msg;
  1610.     HDC                hdc;
  1611.  
  1612.     while ((modenum >= nummodes) || (modenum < 0))
  1613.     {
  1614.         if (vid_modenum == NO_MODE)
  1615.         {
  1616.             if (modenum == vid_default)
  1617.             {
  1618.                 modenum = windowed_default;
  1619.             }
  1620.             else
  1621.             {
  1622.                 modenum = vid_default;
  1623.             }
  1624.  
  1625.             Cvar_SetValue ("vid_mode", (float)modenum);
  1626.         }
  1627.         else
  1628.         {
  1629.             Cvar_SetValue ("vid_mode", (float)vid_modenum);
  1630.             return 0;
  1631.         }
  1632.     }
  1633.  
  1634.     if (!force_mode_set && (modenum == vid_modenum))
  1635.         return true;
  1636.  
  1637. // so Con_Printfs don't mess us up by forcing vid and snd updates
  1638.     temp = scr_disabled_for_loading;
  1639.     scr_disabled_for_loading = true;
  1640.     in_mode_set = true;
  1641.  
  1642.     CDAudio_Pause ();
  1643.     S_ClearBuffer ();
  1644.  
  1645.     if (vid_modenum == NO_MODE)
  1646.         original_mode = windowed_default;
  1647.     else
  1648.         original_mode = vid_modenum;
  1649.  
  1650.     // Set either the fullscreen or windowed mode
  1651.     if (modelist[modenum].type == MS_WINDOWED)
  1652.     {
  1653.         if (_windowed_mouse.value && key_dest == key_game)
  1654.         {
  1655.             stat = VID_SetWindowedMode(modenum);
  1656.             IN_ActivateMouse ();
  1657.             IN_HideMouse ();
  1658.         }
  1659.         else
  1660.         {
  1661.             IN_DeactivateMouse ();
  1662.             IN_ShowMouse ();
  1663.             stat = VID_SetWindowedMode(modenum);
  1664.         }
  1665.     }
  1666.     else if (modelist[modenum].type == MS_FULLDIB)
  1667.     {
  1668.         stat = VID_SetFullDIBMode(modenum);
  1669.         IN_ActivateMouse ();
  1670.         IN_HideMouse ();
  1671.     }
  1672.     else
  1673.     {
  1674.         stat = VID_SetFullscreenMode(modenum);
  1675.         IN_ActivateMouse ();
  1676.         IN_HideMouse ();
  1677.     }
  1678.  
  1679.     window_width = vid.width << vid_stretched;
  1680.     window_height = vid.height << vid_stretched;
  1681.     VID_UpdateWindowStatus ();
  1682.  
  1683.     CDAudio_Resume ();
  1684.     scr_disabled_for_loading = temp;
  1685.  
  1686.     if (!stat)
  1687.     {
  1688.         VID_RestoreOldMode (original_mode);
  1689.         return false;
  1690.     }
  1691.  
  1692.     if (hide_window)
  1693.         return true;
  1694.  
  1695. // now we try to make sure we get the focus on the mode switch, because
  1696. // sometimes in some systems we don't.  We grab the foreground, then
  1697. // finish setting up, pump all our messages, and sleep for a little while
  1698. // to let messages finish bouncing around the system, then we put
  1699. // ourselves at the top of the z order, then grab the foreground again,
  1700. // Who knows if it helps, but it probably doesn't hurt
  1701.     if (!force_minimized)
  1702.         SetForegroundWindow (mainwindow);
  1703.  
  1704.     hdc = GetDC(NULL);
  1705.  
  1706.     if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
  1707.         vid_palettized = true;
  1708.     else
  1709.         vid_palettized = false;
  1710.  
  1711.     VID_SetPalette (palette);
  1712.  
  1713.     ReleaseDC(NULL,hdc);
  1714.  
  1715.     vid_modenum = modenum;
  1716.     Cvar_SetValue ("vid_mode", (float)vid_modenum);
  1717.  
  1718.     if (!VID_AllocBuffers (vid.width, vid.height))
  1719.     {
  1720.     // couldn't get memory for this mode; try to fall back to previous mode
  1721.         VID_RestoreOldMode (original_mode);
  1722.         return false;
  1723.     }
  1724.  
  1725.     D_InitCaches (vid_surfcache, vid_surfcachesize);
  1726.  
  1727.     while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
  1728.     {
  1729.           TranslateMessage (&msg);
  1730.           DispatchMessage (&msg);
  1731.     }
  1732.  
  1733.     Sleep (100);
  1734.  
  1735.     if (!force_minimized)
  1736.     {
  1737.         SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0,
  1738.                   SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW |
  1739.                   SWP_NOCOPYBITS);
  1740.  
  1741.         SetForegroundWindow (mainwindow);
  1742.     }
  1743.  
  1744. // fix the leftover Alt from any Alt-Tab or the like that switched us away
  1745.     ClearAllStates ();
  1746.  
  1747.     if (!msg_suppress_1)
  1748.         Con_SafePrintf ("Video mode %s initialized\n", VID_GetModeDescription (vid_modenum));
  1749.  
  1750.     VID_SetPalette (palette);
  1751.  
  1752.     in_mode_set = false;
  1753.     vid.recalc_refdef = 1;
  1754.  
  1755.     return true;
  1756. }
  1757.  
  1758. void VID_LockBuffer (void)
  1759. {
  1760.  
  1761.     if (dibdc)
  1762.         return;
  1763.  
  1764.     lockcount++;
  1765.  
  1766.     if (lockcount > 1)
  1767.         return;
  1768.  
  1769.     MGL_beginDirectAccess();
  1770.  
  1771.     if (memdc)
  1772.     {
  1773.         // Update surface pointer for linear access modes
  1774.         vid.buffer = vid.conbuffer = vid.direct = memdc->surface;
  1775.         vid.rowbytes = vid.conrowbytes = memdc->mi.bytesPerLine;
  1776.     }
  1777.     else if (mgldc)
  1778.     {
  1779.         // Update surface pointer for linear access modes
  1780.         vid.buffer = vid.conbuffer = vid.direct = mgldc->surface;
  1781.         vid.rowbytes = vid.conrowbytes = mgldc->mi.bytesPerLine;
  1782.     }
  1783.  
  1784.     if (r_dowarp)
  1785.         d_viewbuffer = r_warpbuffer;
  1786.     else
  1787.         d_viewbuffer = (void *)(byte *)vid.buffer;
  1788.  
  1789.     if (r_dowarp)
  1790.         screenwidth = WARP_WIDTH;
  1791.     else
  1792.         screenwidth = vid.rowbytes;
  1793.  
  1794.     if (lcd_x.value)
  1795.         screenwidth <<= 1;
  1796. }
  1797.         
  1798.         
  1799. void VID_UnlockBuffer (void)
  1800. {
  1801.     if (dibdc)
  1802.         return;
  1803.  
  1804.     lockcount--;
  1805.  
  1806.     if (lockcount > 0)
  1807.         return;
  1808.  
  1809.     if (lockcount < 0)
  1810.         Sys_Error ("Unbalanced unlock");
  1811.  
  1812.     MGL_endDirectAccess();
  1813.  
  1814. // to turn up any unlocked accesses
  1815.     vid.buffer = vid.conbuffer = vid.direct = d_viewbuffer = NULL;
  1816.  
  1817. }
  1818.  
  1819.  
  1820. int VID_ForceUnlockedAndReturnState (void)
  1821. {
  1822.     int    lk;
  1823.  
  1824.     if (!lockcount)
  1825.         return 0;
  1826.  
  1827.     lk = lockcount;
  1828.  
  1829.     if (dibdc)
  1830.     {
  1831.         lockcount = 0;
  1832.     }
  1833.     else
  1834.     {
  1835.         lockcount = 1;
  1836.         VID_UnlockBuffer ();
  1837.     }
  1838.  
  1839.     return lk;
  1840. }
  1841.  
  1842.  
  1843. void VID_ForceLockState (int lk)
  1844. {
  1845.  
  1846.     if (!dibdc && lk)
  1847.     {
  1848.         lockcount = 0;
  1849.         VID_LockBuffer ();
  1850.     }
  1851.  
  1852.     lockcount = lk;
  1853. }
  1854.  
  1855.  
  1856. void    VID_SetPalette (unsigned char *palette)
  1857. {
  1858.     INT            i;
  1859.     palette_t    pal[256];
  1860.     HDC            hdc;
  1861.  
  1862.     if (!Minimized)
  1863.     {
  1864.         palette_changed = true;
  1865.  
  1866.     // make sure we have the static colors if we're the active app
  1867.         hdc = GetDC(NULL);
  1868.  
  1869.         if (vid_palettized && ActiveApp)
  1870.         {
  1871.             if (GetSystemPaletteUse(hdc) == SYSPAL_STATIC)
  1872.             {
  1873.             // switch to SYSPAL_NOSTATIC and remap the colors
  1874.                 SetSystemPaletteUse(hdc, SYSPAL_NOSTATIC);
  1875.                 syscolchg = true;
  1876.                 pal_is_nostatic = true;
  1877.             }
  1878.         }
  1879.  
  1880.         ReleaseDC(NULL,hdc);
  1881.  
  1882.         // Translate the palette values to an MGL palette array and
  1883.         // set the values.
  1884.         for (i = 0; i < 256; i++)
  1885.         {
  1886.             pal[i].red = palette[i*3];
  1887.             pal[i].green = palette[i*3+1];
  1888.             pal[i].blue = palette[i*3+2];
  1889.         }
  1890.  
  1891.         if (DDActive)
  1892.         {
  1893.             if (!mgldc)
  1894.                 return;
  1895.  
  1896.             MGL_setPalette(mgldc,pal,256,0);
  1897.             MGL_realizePalette(mgldc,256,0,false);
  1898.             if (memdc)
  1899.                 MGL_setPalette(memdc,pal,256,0);
  1900.         }
  1901.         else
  1902.         {
  1903.             if (!windc)
  1904.                 return;
  1905.  
  1906.             MGL_setPalette(windc,pal,256,0);
  1907.             MGL_realizePalette(windc,256,0,false);
  1908.             if (dibdc)
  1909.             {
  1910.                 MGL_setPalette(dibdc,pal,256,0);
  1911.                 MGL_realizePalette(dibdc,256,0,false);
  1912.             }
  1913.         }
  1914.     }
  1915.  
  1916.     memcpy (vid_curpal, palette, sizeof(vid_curpal));
  1917.  
  1918.     if (syscolchg)
  1919.     {
  1920.         PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM)0, (LPARAM)0);
  1921.         syscolchg = false;
  1922.     }
  1923. }
  1924.  
  1925.  
  1926. void    VID_ShiftPalette (unsigned char *palette)
  1927. {
  1928.     VID_SetPalette (palette);
  1929. }
  1930.  
  1931.  
  1932. /*
  1933. =================
  1934. VID_DescribeCurrentMode_f
  1935. =================
  1936. */
  1937. void VID_DescribeCurrentMode_f (void)
  1938. {
  1939.     Con_Printf ("%s\n", VID_GetExtModeDescription (vid_modenum));
  1940. }
  1941.  
  1942.  
  1943. /*
  1944. =================
  1945. VID_NumModes_f
  1946. =================
  1947. */
  1948. void VID_NumModes_f (void)
  1949. {
  1950.  
  1951.     if (nummodes == 1)
  1952.         Con_Printf ("%d video mode is available\n", nummodes);
  1953.     else
  1954.         Con_Printf ("%d video modes are available\n", nummodes);
  1955. }
  1956.  
  1957.  
  1958. /*
  1959. =================
  1960. VID_DescribeMode_f
  1961. =================
  1962. */
  1963. void VID_DescribeMode_f (void)
  1964. {
  1965.     int        modenum;
  1966.     
  1967.     modenum = Q_atoi (Cmd_Argv(1));
  1968.  
  1969.     Con_Printf ("%s\n", VID_GetExtModeDescription (modenum));
  1970. }
  1971.  
  1972.  
  1973. /*
  1974. =================
  1975. VID_DescribeModes_f
  1976. =================
  1977. */
  1978. void VID_DescribeModes_f (void)
  1979. {
  1980.     int            i, lnummodes;
  1981.     char        *pinfo;
  1982.     qboolean    na;
  1983.     vmode_t        *pv;
  1984.  
  1985.     na = false;
  1986.  
  1987.     lnummodes = VID_NumModes ();
  1988.  
  1989.     for (i=0 ; i<lnummodes ; i++)
  1990.     {
  1991.         pv = VID_GetModePtr (i);
  1992.         pinfo = VID_GetExtModeDescription (i);
  1993.  
  1994.         if (VID_CheckAdequateMem (pv->width, pv->height))
  1995.         {
  1996.             Con_Printf ("%2d: %s\n", i, pinfo);
  1997.         }
  1998.         else
  1999.         {
  2000.             Con_Printf ("**: %s\n", pinfo);
  2001.             na = true;
  2002.         }
  2003.     }
  2004.  
  2005.     if (na)
  2006.     {
  2007.         Con_Printf ("\n[**: not enough system RAM for mode]\n");
  2008.     }
  2009. }
  2010.  
  2011.  
  2012. /*
  2013. =================
  2014. VID_TestMode_f
  2015. =================
  2016. */
  2017. void VID_TestMode_f (void)
  2018. {
  2019.     int        modenum;
  2020.     double    testduration;
  2021.  
  2022.     if (!vid_testingmode)
  2023.     {
  2024.         modenum = Q_atoi (Cmd_Argv(1));
  2025.  
  2026.         if (VID_SetMode (modenum, vid_curpal))
  2027.         {
  2028.             vid_testingmode = 1;
  2029.             testduration = Q_atof (Cmd_Argv(2));
  2030.             if (testduration == 0)
  2031.                 testduration = 5.0;
  2032.             vid_testendtime = realtime + testduration;
  2033.         }
  2034.     }
  2035. }
  2036.  
  2037. /*
  2038. =================
  2039. VID_Windowed_f
  2040. =================
  2041. */
  2042. void VID_Windowed_f (void)
  2043. {
  2044.  
  2045.     VID_SetMode ((int)vid_windowed_mode.value, vid_curpal);
  2046. }
  2047.  
  2048.  
  2049. /*
  2050. =================
  2051. VID_Fullscreen_f
  2052. =================
  2053. */
  2054. void VID_Fullscreen_f (void)
  2055. {
  2056.  
  2057.     VID_SetMode ((int)vid_fullscreen_mode.value, vid_curpal);
  2058. }
  2059.  
  2060. /*
  2061. =================
  2062. VID_Minimize_f
  2063. =================
  2064. */
  2065. void VID_Minimize_f (void)
  2066. {
  2067.  
  2068. // we only support minimizing windows; if you're fullscreen,
  2069. // switch to windowed first
  2070.     if (modestate == MS_WINDOWED)
  2071.         ShowWindow (mainwindow, SW_MINIMIZE);
  2072. }
  2073.  
  2074.  
  2075.  
  2076. /*
  2077. =================
  2078. VID_ForceMode_f
  2079. =================
  2080. */
  2081. void VID_ForceMode_f (void)
  2082. {
  2083.     int        modenum;
  2084.     double    testduration;
  2085.  
  2086.     if (!vid_testingmode)
  2087.     {
  2088.         modenum = Q_atoi (Cmd_Argv(1));
  2089.  
  2090.         force_mode_set = 1;
  2091.         VID_SetMode (modenum, vid_curpal);
  2092.         force_mode_set = 0;
  2093.     }
  2094. }
  2095.  
  2096.  
  2097. void    VID_Init (unsigned char *palette)
  2098. {
  2099.     int        i, bestmatch, bestmatchmetric, t, dr, dg, db;
  2100.     int        basenummodes;
  2101.     byte    *ptmp;
  2102.  
  2103.     Cvar_RegisterVariable (&vid_mode);
  2104.     Cvar_RegisterVariable (&vid_wait);
  2105.     Cvar_RegisterVariable (&vid_nopageflip);
  2106.     Cvar_RegisterVariable (&_vid_wait_override);
  2107.     Cvar_RegisterVariable (&_vid_default_mode);
  2108.     Cvar_RegisterVariable (&_vid_default_mode_win);
  2109.     Cvar_RegisterVariable (&vid_config_x);
  2110.     Cvar_RegisterVariable (&vid_config_y);
  2111.     Cvar_RegisterVariable (&vid_stretch_by_2);
  2112.     Cvar_RegisterVariable (&_windowed_mouse);
  2113.     Cvar_RegisterVariable (&vid_fullscreen_mode);
  2114.     Cvar_RegisterVariable (&vid_windowed_mode);
  2115.     Cvar_RegisterVariable (&block_switch);
  2116.     Cvar_RegisterVariable (&vid_window_x);
  2117.     Cvar_RegisterVariable (&vid_window_y);
  2118.  
  2119.     Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
  2120.     Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
  2121.     Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
  2122.     Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
  2123.     Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
  2124.     Cmd_AddCommand ("vid_forcemode", VID_ForceMode_f);
  2125.     Cmd_AddCommand ("vid_windowed", VID_Windowed_f);
  2126.     Cmd_AddCommand ("vid_fullscreen", VID_Fullscreen_f);
  2127.     Cmd_AddCommand ("vid_minimize", VID_Minimize_f);
  2128.  
  2129.     if (COM_CheckParm ("-dibonly"))
  2130.         dibonly = true;
  2131.  
  2132.     VID_InitMGLDIB (global_hInstance);
  2133.  
  2134.     basenummodes = nummodes;
  2135.  
  2136.     if (!dibonly)
  2137.         VID_InitMGLFull (global_hInstance);
  2138.  
  2139. // if there are no non-windowed modes, or only windowed and mode 0x13, then use
  2140. // fullscreen DIBs as well
  2141.     if (((nummodes == basenummodes) ||
  2142.          ((nummodes == (basenummodes + 1)) && is_mode0x13)) &&
  2143.         !COM_CheckParm ("-nofulldib"))
  2144.  
  2145.     {
  2146.         VID_InitFullDIB (global_hInstance);
  2147.     }
  2148.  
  2149.     vid.maxwarpwidth = WARP_WIDTH;
  2150.     vid.maxwarpheight = WARP_HEIGHT;
  2151.     vid.colormap = host_colormap;
  2152.     vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
  2153.     vid_testingmode = 0;
  2154.  
  2155. // GDI doesn't let us remap palette index 0, so we'll remap color
  2156. // mappings from that black to another one
  2157.     bestmatchmetric = 256*256*3;
  2158.  
  2159.     for (i=1 ; i<256 ; i++)
  2160.     {
  2161.         dr = palette[0] - palette[i*3];
  2162.         dg = palette[1] - palette[i*3+1];
  2163.         db = palette[2] - palette[i*3+2];
  2164.  
  2165.         t = (dr * dr) + (dg * dg) + (db * db);
  2166.  
  2167.         if (t < bestmatchmetric)
  2168.         {
  2169.             bestmatchmetric = t;
  2170.             bestmatch = i;
  2171.  
  2172.             if (t == 0)
  2173.                 break;
  2174.         }
  2175.     }
  2176.  
  2177.     for (i=0, ptmp = vid.colormap ; i<(1<<(VID_CBITS+8)) ; i++, ptmp++)
  2178.     {
  2179.         if (*ptmp == 0)
  2180.             *ptmp = bestmatch;
  2181.     }
  2182.  
  2183.     if (COM_CheckParm("-startwindowed"))
  2184.     {
  2185.         startwindowed = 1;
  2186.         vid_default = windowed_default;
  2187.     }
  2188.  
  2189.     if (hwnd_dialog)
  2190.         DestroyWindow (hwnd_dialog);
  2191.  
  2192. // sound initialization has to go here, preceded by a windowed mode set,
  2193. // so there's a window for DirectSound to work with but we're not yet
  2194. // fullscreen so the "hardware already in use" dialog is visible if it
  2195. // gets displayed
  2196.  
  2197. // keep the window minimized until we're ready for the first real mode set
  2198.     hide_window = true;
  2199.     VID_SetMode (MODE_WINDOWED, palette);
  2200.     hide_window = false;
  2201.     S_Init ();
  2202.  
  2203.     vid_initialized = true;
  2204.  
  2205.     force_mode_set = true;
  2206.     VID_SetMode (vid_default, palette);
  2207.     force_mode_set = false;
  2208.  
  2209.     vid_realmode = vid_modenum;
  2210.  
  2211.     VID_SetPalette (palette);
  2212.  
  2213.     vid_menudrawfn = VID_MenuDraw;
  2214.     vid_menukeyfn = VID_MenuKey;
  2215.  
  2216.     strcpy (badmode.modedesc, "Bad mode");
  2217. }
  2218.  
  2219.  
  2220. void    VID_Shutdown (void)
  2221. {
  2222.     HDC                hdc;
  2223.     int                dummy;
  2224.  
  2225.     if (vid_initialized)
  2226.     {
  2227.         if (modestate == MS_FULLDIB)
  2228.             ChangeDisplaySettings (NULL, CDS_FULLSCREEN);
  2229.  
  2230.         PostMessage (HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM)mainwindow, (LPARAM)0);
  2231.         PostMessage (HWND_BROADCAST, WM_SYSCOLORCHANGE, (WPARAM)0, (LPARAM)0);
  2232.  
  2233.         AppActivate(false, false);
  2234.         DestroyDIBWindow ();
  2235.         DestroyFullscreenWindow ();
  2236.         DestroyFullDIBWindow ();
  2237.  
  2238.         if (hwnd_dialog)
  2239.             DestroyWindow (hwnd_dialog);
  2240.  
  2241.         if (mainwindow)
  2242.             DestroyWindow(mainwindow);
  2243.  
  2244.         MGL_exit();
  2245.  
  2246.         vid_testingmode = 0;
  2247.         vid_initialized = 0;
  2248.     }
  2249. }
  2250.  
  2251.  
  2252. /*
  2253. ================
  2254. FlipScreen
  2255. ================
  2256. */
  2257. void FlipScreen(vrect_t *rects)
  2258. {
  2259.     HRESULT        ddrval;
  2260.  
  2261.     // Flip the surfaces
  2262.  
  2263.     if (DDActive)
  2264.     {
  2265.         if (mgldc)
  2266.         {
  2267.             if (memdc)
  2268.             {
  2269.                 while (rects)
  2270.                 {
  2271.                     if (vid_stretched)
  2272.                     {
  2273.                         MGL_stretchBltCoord(mgldc, memdc,
  2274.                                     rects->x,
  2275.                                     rects->y,
  2276.                                     rects->x + rects->width,
  2277.                                     rects->y + rects->height,
  2278.                                     rects->x << 1,
  2279.                                     rects->y << 1,
  2280.                                     (rects->x + rects->width) << 1,
  2281.                                     (rects->y + rects->height) << 1);
  2282.                     }
  2283.                     else
  2284.                     {
  2285.                         MGL_bitBltCoord(mgldc, memdc,
  2286.                                     rects->x, rects->y,
  2287.                                     (rects->x + rects->width),
  2288.                                     (rects->y + rects->height),
  2289.                                     rects->x, rects->y, MGL_REPLACE_MODE);
  2290.                     }
  2291.  
  2292.                     rects = rects->pnext;
  2293.                 }
  2294.             }
  2295.  
  2296.             if (vid.numpages > 1)
  2297.             {
  2298.                 // We have a flipping surface, so do a hard page flip
  2299.                 aPage = (aPage+1) % vid.numpages;
  2300.                 vPage = (vPage+1) % vid.numpages;
  2301.                 MGL_setActivePage(mgldc,aPage);
  2302.                 MGL_setVisualPage(mgldc,vPage,waitVRT);
  2303.             }
  2304.         }
  2305.     }
  2306.     else
  2307.     {
  2308.         HDC hdcScreen;
  2309.  
  2310.         hdcScreen = GetDC(mainwindow);
  2311.  
  2312.         if (windc && dibdc)
  2313.         {
  2314.             MGL_setWinDC(windc,hdcScreen);
  2315.  
  2316.             while (rects)
  2317.             {
  2318.                 if (vid_stretched)
  2319.                 {
  2320.                     MGL_stretchBltCoord(windc,dibdc,
  2321.                         rects->x, rects->y,
  2322.                         rects->x + rects->width, rects->y + rects->height,
  2323.                         rects->x << 1, rects->y << 1,
  2324.                         (rects->x + rects->width) << 1,
  2325.                         (rects->y + rects->height) << 1);
  2326.                 }
  2327.                 else
  2328.                 {
  2329.                     MGL_bitBltCoord(windc,dibdc,
  2330.                         rects->x, rects->y,
  2331.                         rects->x + rects->width, rects->y + rects->height,
  2332.                         rects->x, rects->y, MGL_REPLACE_MODE);
  2333.                 }
  2334.  
  2335.                 rects = rects->pnext;
  2336.             }
  2337.         }
  2338.  
  2339.         ReleaseDC(mainwindow, hdcScreen);
  2340.     }
  2341. }
  2342.  
  2343.  
  2344. void    VID_Update (vrect_t *rects)
  2345. {
  2346.     vrect_t    rect;
  2347.     RECT    trect;
  2348.  
  2349.     if (!vid_palettized && palette_changed)
  2350.     {
  2351.         palette_changed = false;
  2352.         rect.x = 0;
  2353.         rect.y = 0;
  2354.         rect.width = vid.width;
  2355.         rect.height = vid.height;
  2356.         rect.pnext = NULL;
  2357.         rects = ▭
  2358.     }
  2359.  
  2360.     if (firstupdate)
  2361.     {
  2362.         if (modestate == MS_WINDOWED)
  2363.         {
  2364.             GetWindowRect (mainwindow, &trect);
  2365.  
  2366.             if ((trect.left != (int)vid_window_x.value) ||
  2367.                 (trect.top  != (int)vid_window_y.value))
  2368.             {
  2369.                 if (COM_CheckParm ("-resetwinpos"))
  2370.                 {
  2371.                     Cvar_SetValue ("vid_window_x", 0.0);
  2372.                     Cvar_SetValue ("vid_window_y", 0.0);
  2373.                 }
  2374.  
  2375.                 VID_CheckWindowXY ();
  2376.                 SetWindowPos (mainwindow, NULL, (int)vid_window_x.value,
  2377.                   (int)vid_window_y.value, 0, 0,
  2378.                   SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
  2379.             }
  2380.         }
  2381.  
  2382.         if ((_vid_default_mode_win.value != vid_default) &&
  2383.             (!startwindowed || (_vid_default_mode_win.value < MODE_FULLSCREEN_DEFAULT)))
  2384.         {
  2385.             firstupdate = 0;
  2386.  
  2387.             if (COM_CheckParm ("-resetwinpos"))
  2388.             {
  2389.                 Cvar_SetValue ("vid_window_x", 0.0);
  2390.                 Cvar_SetValue ("vid_window_y", 0.0);
  2391.             }
  2392.  
  2393.             if ((_vid_default_mode_win.value < 0) ||
  2394.                 (_vid_default_mode_win.value >= nummodes))
  2395.             {
  2396.                 Cvar_SetValue ("_vid_default_mode_win", windowed_default);
  2397.             }
  2398.  
  2399.             Cvar_SetValue ("vid_mode", _vid_default_mode_win.value);
  2400.         }
  2401.     }
  2402.  
  2403.     // We've drawn the frame; copy it to the screen
  2404.     FlipScreen (rects);
  2405.  
  2406.     if (vid_testingmode)
  2407.     {
  2408.         if (realtime >= vid_testendtime)
  2409.         {
  2410.             VID_SetMode (vid_realmode, vid_curpal);
  2411.             vid_testingmode = 0;
  2412.         }
  2413.     }
  2414.     else
  2415.     {
  2416.         if ((int)vid_mode.value != vid_realmode)
  2417.         {
  2418.             VID_SetMode ((int)vid_mode.value, vid_curpal);
  2419.             Cvar_SetValue ("vid_mode", (float)vid_modenum);
  2420.                                 // so if mode set fails, we don't keep on
  2421.                                 //  trying to set that mode
  2422.             vid_realmode = vid_modenum;
  2423.         }
  2424.     }
  2425.  
  2426. // handle the mouse state when windowed if that's changed
  2427.     if (modestate == MS_WINDOWED)
  2428.     {
  2429.         if (!_windowed_mouse.value) {
  2430.             if (windowed_mouse)    {
  2431.                 IN_DeactivateMouse ();
  2432.                 IN_ShowMouse ();
  2433.             }
  2434.             windowed_mouse = false;
  2435.         } else {
  2436.             windowed_mouse = true;
  2437.             if (key_dest == key_game && !mouseactive && ActiveApp) {
  2438.                 IN_ActivateMouse ();
  2439.                 IN_HideMouse ();
  2440.             } else if (mouseactive && key_dest != key_game) {
  2441.                 IN_DeactivateMouse ();
  2442.                 IN_ShowMouse ();
  2443.             }
  2444.         }
  2445.     }
  2446. }
  2447.  
  2448.  
  2449. /*
  2450. ================
  2451. D_BeginDirectRect
  2452. ================
  2453. */
  2454. void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
  2455. {
  2456.     int        i, j, reps, repshift;
  2457.     vrect_t    rect;
  2458.  
  2459.     if (!vid_initialized)
  2460.         return;
  2461.  
  2462.     if (vid.aspect > 1.5)
  2463.     {
  2464.         reps = 2;
  2465.         repshift = 1;
  2466.     }
  2467.     else
  2468.     {
  2469.         reps = 1;
  2470.         repshift = 0;
  2471.     }
  2472.  
  2473.     if (vid.numpages == 1)
  2474.     {
  2475.         VID_LockBuffer ();
  2476.  
  2477.         if (!vid.direct)
  2478.             Sys_Error ("NULL vid.direct pointer");
  2479.  
  2480.         for (i=0 ; i<(height << repshift) ; i += reps)
  2481.         {
  2482.             for (j=0 ; j<reps ; j++)
  2483.             {
  2484.                 memcpy (&backingbuf[(i + j) * 24],
  2485.                         vid.direct + x + ((y << repshift) + i + j) * vid.rowbytes,
  2486.                         width);
  2487.                 memcpy (vid.direct + x + ((y << repshift) + i + j) * vid.rowbytes,
  2488.                         &pbitmap[(i >> repshift) * width],
  2489.                         width);
  2490.             }
  2491.         }
  2492.  
  2493.         VID_UnlockBuffer ();
  2494.  
  2495.         rect.x = x;
  2496.         rect.y = y;
  2497.         rect.width = width;
  2498.         rect.height = height << repshift;
  2499.         rect.pnext = NULL;
  2500.  
  2501.         FlipScreen (&rect);
  2502.     }
  2503.     else
  2504.     {
  2505.     // unlock if locked
  2506.         if (lockcount > 0)
  2507.             MGL_endDirectAccess();
  2508.  
  2509.     // set the active page to the displayed page
  2510.         MGL_setActivePage (mgldc, vPage);
  2511.  
  2512.     // lock the screen
  2513.         MGL_beginDirectAccess ();
  2514.  
  2515.     // save from and draw to screen
  2516.         for (i=0 ; i<(height << repshift) ; i += reps)
  2517.         {
  2518.             for (j=0 ; j<reps ; j++)
  2519.             {
  2520.                 memcpy (&backingbuf[(i + j) * 24],
  2521.                         (byte *)mgldc->surface + x +
  2522.                          ((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
  2523.                         width);
  2524.                 memcpy ((byte *)mgldc->surface + x +
  2525.                          ((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
  2526.                         &pbitmap[(i >> repshift) * width],
  2527.                         width);
  2528.             }
  2529.         }
  2530.  
  2531.     // unlock the screen
  2532.         MGL_endDirectAccess ();
  2533.  
  2534.     // restore the original active page
  2535.         MGL_setActivePage (mgldc, aPage);
  2536.  
  2537.     // relock the screen if it was locked
  2538.         if (lockcount > 0)
  2539.             MGL_beginDirectAccess();
  2540.     }
  2541. }
  2542.  
  2543.  
  2544. /*
  2545. ================
  2546. D_EndDirectRect
  2547. ================
  2548. */
  2549. void D_EndDirectRect (int x, int y, int width, int height)
  2550. {
  2551.     int        i, j, reps, repshift;
  2552.     vrect_t    rect;
  2553.  
  2554.     if (!vid_initialized)
  2555.         return;
  2556.  
  2557.     if (vid.aspect > 1.5)
  2558.     {
  2559.         reps = 2;
  2560.         repshift = 1;
  2561.     }
  2562.     else
  2563.     {
  2564.         reps = 1;
  2565.         repshift = 0;
  2566.     }
  2567.  
  2568.     if (vid.numpages == 1)
  2569.     {
  2570.         VID_LockBuffer ();
  2571.  
  2572.         if (!vid.direct)
  2573.             Sys_Error ("NULL vid.direct pointer");
  2574.  
  2575.         for (i=0 ; i<(height << repshift) ; i += reps)
  2576.         {
  2577.             for (j=0 ; j<reps ; j++)
  2578.             {
  2579.                 memcpy (vid.direct + x + ((y << repshift) + i + j) * vid.rowbytes,
  2580.                         &backingbuf[(i + j) * 24],
  2581.                         width);
  2582.             }
  2583.         }
  2584.  
  2585.         VID_UnlockBuffer ();
  2586.  
  2587.         rect.x = x;
  2588.         rect.y = y;
  2589.         rect.width = width;
  2590.         rect.height = height << repshift;
  2591.         rect.pnext = NULL;
  2592.  
  2593.         FlipScreen (&rect);
  2594.     }
  2595.     else
  2596.     {
  2597.     // unlock if locked
  2598.         if (lockcount > 0)
  2599.             MGL_endDirectAccess();
  2600.  
  2601.     // set the active page to the displayed page
  2602.         MGL_setActivePage (mgldc, vPage);
  2603.  
  2604.     // lock the screen
  2605.         MGL_beginDirectAccess ();
  2606.  
  2607.     // restore to the screen
  2608.         for (i=0 ; i<(height << repshift) ; i += reps)
  2609.         {
  2610.             for (j=0 ; j<reps ; j++)
  2611.             {
  2612.                 memcpy ((byte *)mgldc->surface + x +
  2613.                          ((y << repshift) + i + j) * mgldc->mi.bytesPerLine,
  2614.                         &backingbuf[(i + j) * 24],
  2615.                         width);
  2616.             }
  2617.         }
  2618.  
  2619.     // unlock the screen
  2620.         MGL_endDirectAccess ();
  2621.  
  2622.     // restore the original active page
  2623.         MGL_setActivePage (mgldc, aPage);
  2624.  
  2625.     // relock the screen if it was locked
  2626.         if (lockcount > 0)
  2627.             MGL_beginDirectAccess();
  2628.     }
  2629. }
  2630.  
  2631.  
  2632. //==========================================================================
  2633.  
  2634. byte        scantokey[128] = 
  2635.                     { 
  2636. //  0           1       2       3       4       5       6       7 
  2637. //  8           9       A       B       C       D       E       F 
  2638.     0  ,    27,     '1',    '2',    '3',    '4',    '5',    '6', 
  2639.     '7',    '8',    '9',    '0',    '-',    '=',    K_BACKSPACE, 9, // 0 
  2640.     'q',    'w',    'e',    'r',    't',    'y',    'u',    'i', 
  2641.     'o',    'p',    '[',    ']',    13 ,    K_CTRL,'a',  's',      // 1 
  2642.     'd',    'f',    'g',    'h',    'j',    'k',    'l',    ';', 
  2643.     '\'' ,    '`',    K_SHIFT,'\\',  'z',    'x',    'c',    'v',      // 2 
  2644.     'b',    'n',    'm',    ',',    '.',    '/',    K_SHIFT,'*', 
  2645.     K_ALT,' ',   0  ,    K_F1, K_F2, K_F3, K_F4, K_F5,   // 3 
  2646.     K_F6, K_F7, K_F8, K_F9, K_F10,  K_PAUSE,    0  , K_HOME, 
  2647.     K_UPARROW,K_PGUP,'-',K_LEFTARROW,'5',K_RIGHTARROW,'+',K_END, //4 
  2648.     K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0,             0,              K_F11, 
  2649.     K_F12,0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 5
  2650.     0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0, 
  2651.     0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 6 
  2652.     0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0, 
  2653.     0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0         // 7 
  2654. }; 
  2655.  
  2656. /*
  2657. =======
  2658. MapKey
  2659.  
  2660. Map from windows to quake keynums
  2661. =======
  2662. */
  2663. int MapKey (int key)
  2664. {
  2665.     key = (key>>16)&255;
  2666.     if (key > 127)
  2667.         return 0;
  2668.  
  2669.     return scantokey[key];
  2670. }
  2671.  
  2672. void AppActivate(BOOL fActive, BOOL minimize)
  2673. /****************************************************************************
  2674. *
  2675. * Function:     AppActivate
  2676. * Parameters:   fActive - True if app is activating
  2677. *
  2678. * Description:  If the application is activating, then swap the system
  2679. *               into SYSPAL_NOSTATIC mode so that our palettes will display
  2680. *               correctly.
  2681. *
  2682. ****************************************************************************/
  2683. {
  2684.     HDC            hdc;
  2685.     int            i, t;
  2686.     static BOOL    sound_active;
  2687.  
  2688.     ActiveApp = fActive;
  2689.  
  2690. // messy, but it seems to work
  2691.     if (vid_fulldib_on_focus_mode)
  2692.     {
  2693.     Minimized = minimize;
  2694.  
  2695.     if (Minimized)
  2696.             ActiveApp = false;
  2697.     }
  2698.  
  2699.     MGL_appActivate(windc, ActiveApp);
  2700.  
  2701.     if (vid_initialized)
  2702.     {
  2703.     // yield the palette if we're losing the focus
  2704.         hdc = GetDC(NULL);
  2705.  
  2706.         if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
  2707.         {
  2708.             if (ActiveApp)
  2709.             {
  2710.                 if ((modestate == MS_WINDOWED) || (modestate == MS_FULLDIB))
  2711.                 {
  2712.                 if (GetSystemPaletteUse(hdc) == SYSPAL_STATIC)
  2713.                 {
  2714.                 // switch to SYSPAL_NOSTATIC and remap the colors
  2715.                     SetSystemPaletteUse(hdc, SYSPAL_NOSTATIC);
  2716.                     syscolchg = true;
  2717.                         pal_is_nostatic = true;
  2718.                 }
  2719.             }
  2720.             }
  2721.             else if (pal_is_nostatic)
  2722.             {
  2723.                 if (GetSystemPaletteUse(hdc) == SYSPAL_NOSTATIC)
  2724.                 {
  2725.                 // switch back to SYSPAL_STATIC and the old mapping
  2726.                     SetSystemPaletteUse(hdc, SYSPAL_STATIC);
  2727.                     syscolchg = true;
  2728.                 }
  2729.  
  2730.                 pal_is_nostatic = false;
  2731.             }
  2732.         }
  2733.  
  2734.         if (!Minimized)
  2735.             VID_SetPalette (vid_curpal);
  2736.  
  2737.         scr_fullupdate = 0;
  2738.  
  2739.         ReleaseDC(NULL,hdc);
  2740.     }
  2741.  
  2742. // enable/disable sound on focus gain/loss
  2743.     if (!ActiveApp && sound_active)
  2744.     {
  2745.         S_BlockSound ();
  2746.         S_ClearBuffer ();
  2747.         sound_active = false;
  2748.     }
  2749.     else if (ActiveApp && !sound_active)
  2750.     {
  2751.         S_UnblockSound ();
  2752.         S_ClearBuffer ();
  2753.         sound_active = true;
  2754.     }
  2755.  
  2756. // minimize/restore fulldib windows/mouse-capture normal windows on demand
  2757.     if (!in_mode_set)
  2758.     {
  2759.         if (ActiveApp)
  2760.         {
  2761.             if (vid_fulldib_on_focus_mode)
  2762.             {
  2763.                 if (vid_initialized)
  2764.                 {
  2765.                     msg_suppress_1 = true;    // don't want to see normal mode set message
  2766.                     VID_SetMode (vid_fulldib_on_focus_mode, vid_curpal);
  2767.                     msg_suppress_1 = false;
  2768.  
  2769.                     t = in_mode_set;
  2770.                     in_mode_set = true;
  2771.                     AppActivate (true, false);
  2772.                     in_mode_set = t;
  2773.                 }
  2774.  
  2775.                 IN_ActivateMouse ();
  2776.                 IN_HideMouse ();
  2777.             }
  2778.             else if ((modestate == MS_WINDOWED) && _windowed_mouse.value && key_dest == key_game)
  2779.             {
  2780.                 IN_ActivateMouse ();
  2781.                 IN_HideMouse ();
  2782.             }
  2783.         }
  2784.  
  2785.         if (!ActiveApp)
  2786.         {
  2787.             if (modestate == MS_FULLDIB)
  2788.             {
  2789.                 if (vid_initialized)
  2790.                 {
  2791.                     force_minimized = true;
  2792.                     i = vid_fulldib_on_focus_mode;
  2793.                     msg_suppress_1 = true;    // don't want to see normal mode set message
  2794.                     VID_SetMode (windowed_default, vid_curpal);
  2795.                     msg_suppress_1 = false;
  2796.                     vid_fulldib_on_focus_mode = i;
  2797.                     force_minimized = false;
  2798.  
  2799.                 // we never seem to get WM_ACTIVATE inactive from this mode set, so we'll
  2800.                 // do it manually
  2801.                     t = in_mode_set;
  2802.                     in_mode_set = true;
  2803.                     AppActivate (false, true);
  2804.                     in_mode_set = t;
  2805.                 }
  2806.  
  2807.                 IN_DeactivateMouse ();
  2808.                 IN_ShowMouse ();
  2809.             }
  2810.             else if ((modestate == MS_WINDOWED) && _windowed_mouse.value /* && mouseactive */)
  2811.             {
  2812.                 IN_DeactivateMouse ();
  2813.                 IN_ShowMouse ();
  2814.             }
  2815.         }
  2816.     }
  2817. }
  2818.  
  2819.  
  2820. /*
  2821. ================
  2822. VID_HandlePause
  2823. ================
  2824. */
  2825. void VID_HandlePause (qboolean pause)
  2826. {
  2827. #if 0
  2828.     if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
  2829.     {
  2830.         if (pause)
  2831.         {
  2832.             IN_DeactivateMouse ();
  2833.             IN_ShowMouse ();
  2834.         }
  2835.         else
  2836.         {
  2837.             IN_ActivateMouse ();
  2838.             IN_HideMouse ();
  2839.         }
  2840.     }
  2841. #endif
  2842. }
  2843.  
  2844.             
  2845. /*
  2846. ===================================================================
  2847.  
  2848. MAIN WINDOW
  2849.  
  2850. ===================================================================
  2851. */
  2852.  
  2853. LONG CDAudio_MessageHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  2854.  
  2855. /* main window procedure */
  2856. LONG WINAPI MainWndProc (
  2857.     HWND    hWnd,
  2858.     UINT    uMsg,
  2859.     WPARAM  wParam,
  2860.     LPARAM  lParam)
  2861. {
  2862.     LONG            lRet = 0;
  2863.     int                fwKeys, xPos, yPos, fActive, fMinimized, temp;
  2864.     HDC                hdc;
  2865.     PAINTSTRUCT        ps;
  2866.     extern unsigned int uiWheelMessage;
  2867.     static int        recursiveflag;
  2868.  
  2869.     if ( uMsg == uiWheelMessage ) {
  2870.         uMsg = WM_MOUSEWHEEL;
  2871.         wParam <<= 16;
  2872.     }
  2873.  
  2874.  
  2875.     switch (uMsg)
  2876.     {
  2877.         case WM_CREATE:
  2878.             break;
  2879.  
  2880.         case WM_SYSCOMMAND:
  2881.  
  2882.         // Check for maximize being hit
  2883.             switch (wParam & ~0x0F)
  2884.             {
  2885.                 case SC_MAXIMIZE:
  2886.                 // if minimized, bring up as a window before going fullscreen,
  2887.                 // so MGL will have the right state to restore
  2888.                     if (Minimized)
  2889.                     {
  2890.                         force_mode_set = true;
  2891.                         VID_SetMode (vid_modenum, vid_curpal);
  2892.                         force_mode_set = false;
  2893.                     }
  2894.  
  2895.                     VID_SetMode ((int)vid_fullscreen_mode.value, vid_curpal);
  2896.                     break;
  2897.  
  2898.                 case SC_SCREENSAVE:
  2899.                 case SC_MONITORPOWER:
  2900.                     if (modestate != MS_WINDOWED)
  2901.                     {
  2902.                     // don't call DefWindowProc() because we don't want to start
  2903.                     // the screen saver fullscreen
  2904.                         break;
  2905.                     }
  2906.  
  2907.                 // fall through windowed and allow the screen saver to start
  2908.  
  2909.                 default:
  2910.                 if (!in_mode_set)
  2911.                 {
  2912.                     S_BlockSound ();
  2913.                     S_ClearBuffer ();
  2914.                 }
  2915.  
  2916.                 lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
  2917.  
  2918.                 if (!in_mode_set)
  2919.                 {
  2920.                     S_UnblockSound ();
  2921.                 }
  2922.             }
  2923.             break;
  2924.  
  2925.         case WM_MOVE:
  2926.             window_x = (int) LOWORD(lParam);
  2927.             window_y = (int) HIWORD(lParam);
  2928.             VID_UpdateWindowStatus ();
  2929.  
  2930.             if ((modestate == MS_WINDOWED) && !in_mode_set && !Minimized)
  2931.                 VID_RememberWindowPos ();
  2932.  
  2933.             break;
  2934.  
  2935.         case WM_SIZE:
  2936.             Minimized = false;
  2937.             
  2938.             if (!(wParam & SIZE_RESTORED))
  2939.             {
  2940.                 if (wParam & SIZE_MINIMIZED)
  2941.                     Minimized = true;
  2942.             }
  2943.             break;
  2944.  
  2945.         case WM_SYSCHAR:
  2946.         // keep Alt-Space from happening
  2947.             break;
  2948.  
  2949.         case WM_ACTIVATE:
  2950.             fActive = LOWORD(wParam);
  2951.             fMinimized = (BOOL) HIWORD(wParam);
  2952.             AppActivate(!(fActive == WA_INACTIVE), fMinimized);
  2953.  
  2954.         // fix the leftover Alt from any Alt-Tab or the like that switched us away
  2955.             ClearAllStates ();
  2956.  
  2957.             if (!in_mode_set)
  2958.             {
  2959.                 if (windc)
  2960.                     MGL_activatePalette(windc,true);
  2961.  
  2962.                 VID_SetPalette(vid_curpal);
  2963.             }
  2964.  
  2965.             break;
  2966.  
  2967.         case WM_PAINT:
  2968.             hdc = BeginPaint(hWnd, &ps);
  2969.  
  2970.             if (!in_mode_set && host_initialized)
  2971.                 SCR_UpdateWholeScreen ();
  2972.  
  2973.             EndPaint(hWnd, &ps);
  2974.             break;
  2975.  
  2976.         case WM_KEYDOWN:
  2977.         case WM_SYSKEYDOWN:
  2978.             if (!in_mode_set)
  2979.                 Key_Event (MapKey(lParam), true);
  2980.             break;
  2981.  
  2982.         case WM_KEYUP:
  2983.         case WM_SYSKEYUP:
  2984.             if (!in_mode_set)
  2985.                 Key_Event (MapKey(lParam), false);
  2986.             break;
  2987.  
  2988.     // this is complicated because Win32 seems to pack multiple mouse events into
  2989.     // one update sometimes, so we always check all states and look for events
  2990.         case WM_LBUTTONDOWN:
  2991.         case WM_LBUTTONUP:
  2992.         case WM_RBUTTONDOWN:
  2993.         case WM_RBUTTONUP:
  2994.         case WM_MBUTTONDOWN:
  2995.         case WM_MBUTTONUP:
  2996.         case WM_MOUSEMOVE:
  2997.             if (!in_mode_set)
  2998.             {
  2999.                 temp = 0;
  3000.  
  3001.                 if (wParam & MK_LBUTTON)
  3002.                     temp |= 1;
  3003.  
  3004.                 if (wParam & MK_RBUTTON)
  3005.                     temp |= 2;
  3006.  
  3007.                 if (wParam & MK_MBUTTON)
  3008.                     temp |= 4;
  3009.  
  3010.                 IN_MouseEvent (temp);
  3011.             }
  3012.             break;
  3013.         // JACK: This is the mouse wheel with the Intellimouse
  3014.         // Its delta is either positive or neg, and we generate the proper
  3015.         // Event.
  3016.         case WM_MOUSEWHEEL: 
  3017.             if ((short) HIWORD(wParam) > 0) {
  3018.                 Key_Event(K_MWHEELUP, true);
  3019.                 Key_Event(K_MWHEELUP, false);
  3020.             } else {
  3021.                 Key_Event(K_MWHEELDOWN, true);
  3022.                 Key_Event(K_MWHEELDOWN, false);
  3023.             }
  3024.             break;
  3025.         // KJB: Added these new palette functions
  3026.         case WM_PALETTECHANGED:
  3027.             if ((HWND)wParam == hWnd)
  3028.                 break;
  3029.             /* Fall through to WM_QUERYNEWPALETTE */
  3030.         case WM_QUERYNEWPALETTE:
  3031.             hdc = GetDC(NULL);
  3032.  
  3033.             if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
  3034.                 vid_palettized = true;
  3035.             else
  3036.                 vid_palettized = false;
  3037.  
  3038.             ReleaseDC(NULL,hdc);
  3039.  
  3040.             scr_fullupdate = 0;
  3041.  
  3042.             if (vid_initialized && !in_mode_set && windc && MGL_activatePalette(windc,false) && !Minimized)
  3043.             {
  3044.                 VID_SetPalette (vid_curpal);
  3045.                 InvalidateRect (mainwindow, NULL, false);
  3046.  
  3047.             // specifically required if WM_QUERYNEWPALETTE realizes a new palette
  3048.                 lRet = TRUE;
  3049.             }
  3050.             break;
  3051.  
  3052.         case WM_DISPLAYCHANGE:
  3053.             if (!in_mode_set && (modestate == MS_WINDOWED) && !vid_fulldib_on_focus_mode)
  3054.             {
  3055.                 force_mode_set = true;
  3056.                 VID_SetMode (vid_modenum, vid_curpal);
  3057.                 force_mode_set = false;
  3058.             }
  3059.             break;
  3060.  
  3061.            case WM_CLOSE:
  3062.         // this causes Close in the right-click task bar menu not to work, but right
  3063.         // now bad things happen if Close is handled in that case (garbage and a
  3064.         // crash on Win95)
  3065.             if (!in_mode_set)
  3066.             {
  3067.                 if (MessageBox (mainwindow, "Are you sure you want to quit?", "Confirm Exit",
  3068.                             MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES)
  3069.                 {
  3070.                     Sys_Quit ();
  3071.                 }
  3072.             }
  3073.             break;
  3074.  
  3075.         case MM_MCINOTIFY:
  3076.             lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
  3077.             break;
  3078.  
  3079.         default:
  3080.             /* pass all unhandled messages to DefWindowProc */
  3081.             lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
  3082.             break;
  3083.     }
  3084.  
  3085.     /* return 0 if handled message, 1 if not */
  3086.     return lRet;
  3087. }
  3088.  
  3089.  
  3090. extern void M_Menu_Options_f (void);
  3091. extern void M_Print (int cx, int cy, char *str);
  3092. extern void M_PrintWhite (int cx, int cy, char *str);
  3093. extern void M_DrawCharacter (int cx, int line, int num);
  3094. extern void M_DrawTransPic (int x, int y, qpic_t *pic);
  3095. extern void M_DrawPic (int x, int y, qpic_t *pic);
  3096.  
  3097. static int    vid_line, vid_wmodes;
  3098.  
  3099. typedef struct
  3100. {
  3101.     int        modenum;
  3102.     char    *desc;
  3103.     int        iscur;
  3104.     int        ismode13;
  3105.     int        width;
  3106. } modedesc_t;
  3107.  
  3108. #define MAX_COLUMN_SIZE        5
  3109. #define MODE_AREA_HEIGHT    (MAX_COLUMN_SIZE + 6)
  3110. #define MAX_MODEDESCS        (MAX_COLUMN_SIZE*3)
  3111.  
  3112. static modedesc_t    modedescs[MAX_MODEDESCS];
  3113.  
  3114. /*
  3115. ================
  3116. VID_MenuDraw
  3117. ================
  3118. */
  3119. void VID_MenuDraw (void)
  3120. {
  3121.     qpic_t        *p;
  3122.     char        *ptr;
  3123.     int            lnummodes, i, j, k, column, row, dup, dupmode;
  3124.     char        temp[100];
  3125.     vmode_t        *pv;
  3126.     modedesc_t    tmodedesc;
  3127.  
  3128.     p = Draw_CachePic ("gfx/vidmodes.lmp");
  3129.     M_DrawPic ( (320-p->width)/2, 4, p);
  3130.  
  3131.     for (i=0 ; i<3 ; i++)
  3132.     {
  3133.         ptr = VID_GetModeDescriptionMemCheck (i);
  3134.         modedescs[i].modenum = modelist[i].modenum;
  3135.         modedescs[i].desc = ptr;
  3136.         modedescs[i].ismode13 = 0;
  3137.         modedescs[i].iscur = 0;
  3138.  
  3139.         if (vid_modenum == i)
  3140.             modedescs[i].iscur = 1;
  3141.     }
  3142.  
  3143.     vid_wmodes = 3;
  3144.     lnummodes = VID_NumModes ();
  3145.     
  3146.     for (i=3 ; i<lnummodes ; i++)
  3147.     {
  3148.         ptr = VID_GetModeDescriptionMemCheck (i);
  3149.         pv = VID_GetModePtr (i);
  3150.  
  3151.     // we only have room for 15 fullscreen modes, so don't allow
  3152.     // 360-wide modes, because if there are 5 320-wide modes and
  3153.     // 5 360-wide modes, we'll run out of space
  3154.         if (ptr && ((pv->width != 360) || COM_CheckParm("-allow360")))
  3155.         {
  3156.             dup = 0;
  3157.  
  3158.             for (j=3 ; j<vid_wmodes ; j++)
  3159.             {
  3160.                 if (!strcmp (modedescs[j].desc, ptr))
  3161.                 {
  3162.                     dup = 1;
  3163.                     dupmode = j;
  3164.                     break;
  3165.                 }
  3166.             }
  3167.  
  3168.             if (dup || (vid_wmodes < MAX_MODEDESCS))       
  3169.             {
  3170.                 if (!dup || !modedescs[dupmode].ismode13 || COM_CheckParm("-noforcevga"))
  3171.                 {
  3172.                     if (dup)
  3173.                     {
  3174.                         k = dupmode;
  3175.                     }
  3176.                     else
  3177.                     {
  3178.                         k = vid_wmodes;
  3179.                     }
  3180.  
  3181.                     modedescs[k].modenum = i;
  3182.                     modedescs[k].desc = ptr;
  3183.                     modedescs[k].ismode13 = pv->mode13;
  3184.                     modedescs[k].iscur = 0;
  3185.                     modedescs[k].width = pv->width;
  3186.  
  3187.                     if (i == vid_modenum)
  3188.                         modedescs[k].iscur = 1;
  3189.  
  3190.                     if (!dup)
  3191.                         vid_wmodes++;
  3192.                 }
  3193.             }
  3194.         }
  3195.     }
  3196.  
  3197. // sort the modes on width (to handle picking up oddball dibonly modes
  3198. // after all the others)
  3199.     for (i=3 ; i<(vid_wmodes-1) ; i++)
  3200.     {
  3201.         for (j=(i+1) ; j<vid_wmodes ; j++)
  3202.         {
  3203.             if (modedescs[i].width > modedescs[j].width)
  3204.             {
  3205.                 tmodedesc = modedescs[i];
  3206.                 modedescs[i] = modedescs[j];
  3207.                 modedescs[j] = tmodedesc;
  3208.             }
  3209.         }
  3210.     }
  3211.  
  3212.  
  3213.     M_Print (13*8, 36, "Windowed Modes");
  3214.  
  3215.     column = 16;
  3216.     row = 36+2*8;
  3217.  
  3218.     for (i=0 ; i<3; i++)
  3219.     {
  3220.         if (modedescs[i].iscur)
  3221.             M_PrintWhite (column, row, modedescs[i].desc);
  3222.         else
  3223.             M_Print (column, row, modedescs[i].desc);
  3224.  
  3225.         column += 13*8;
  3226.     }
  3227.  
  3228.     if (vid_wmodes > 3)
  3229.     {
  3230.         M_Print (12*8, 36+4*8, "Fullscreen Modes");
  3231.  
  3232.         column = 16;
  3233.         row = 36+6*8;
  3234.  
  3235.         for (i=3 ; i<vid_wmodes ; i++)
  3236.         {
  3237.             if (modedescs[i].iscur)
  3238.                 M_PrintWhite (column, row, modedescs[i].desc);
  3239.             else
  3240.                 M_Print (column, row, modedescs[i].desc);
  3241.  
  3242.             column += 13*8;
  3243.  
  3244.             if (((i - 3) % VID_ROW_SIZE) == (VID_ROW_SIZE - 1))
  3245.             {
  3246.                 column = 16;
  3247.                 row += 8;
  3248.             }
  3249.         }
  3250.     }
  3251.  
  3252. // line cursor
  3253.     if (vid_testingmode)
  3254.     {
  3255.         sprintf (temp, "TESTING %s",
  3256.                 modedescs[vid_line].desc);
  3257.         M_Print (13*8, 36 + MODE_AREA_HEIGHT * 8 + 8*4, temp);
  3258.         M_Print (9*8, 36 + MODE_AREA_HEIGHT * 8 + 8*6,
  3259.                 "Please wait 5 seconds...");
  3260.     }
  3261.     else
  3262.     {
  3263.         M_Print (9*8, 36 + MODE_AREA_HEIGHT * 8 + 8,
  3264.                 "Press Enter to set mode");
  3265.         M_Print (6*8, 36 + MODE_AREA_HEIGHT * 8 + 8*3,
  3266.                 "T to test mode for 5 seconds");
  3267.         ptr = VID_GetModeDescription2 (vid_modenum);
  3268.  
  3269.         if (ptr)
  3270.         {
  3271.             sprintf (temp, "D to set default: %s", ptr);
  3272.             M_Print (2*8, 36 + MODE_AREA_HEIGHT * 8 + 8*5, temp);
  3273.         }
  3274.  
  3275.         ptr = VID_GetModeDescription2 ((int)_vid_default_mode_win.value);
  3276.  
  3277.         if (ptr)
  3278.         {
  3279.             sprintf (temp, "Current default: %s", ptr);
  3280.             M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*6, temp);
  3281.         }
  3282.  
  3283.         M_Print (15*8, 36 + MODE_AREA_HEIGHT * 8 + 8*8,
  3284.                 "Esc to exit");
  3285.  
  3286.         row = 36 + 2*8 + (vid_line / VID_ROW_SIZE) * 8;
  3287.         column = 8 + (vid_line % VID_ROW_SIZE) * 13*8;
  3288.  
  3289.         if (vid_line >= 3)
  3290.             row += 3*8;
  3291.  
  3292.         M_DrawCharacter (column, row, 12+((int)(realtime*4)&1));
  3293.     }
  3294. }
  3295.  
  3296.  
  3297. /*
  3298. ================
  3299. VID_MenuKey
  3300. ================
  3301. */
  3302. void VID_MenuKey (int key)
  3303. {
  3304.     if (vid_testingmode)
  3305.         return;
  3306.  
  3307.     switch (key)
  3308.     {
  3309.     case K_ESCAPE:
  3310.         S_LocalSound ("misc/menu1.wav");
  3311.         M_Menu_Options_f ();
  3312.         break;
  3313.  
  3314.     case K_LEFTARROW:
  3315.  
  3316.         S_LocalSound ("misc/menu1.wav");
  3317.         vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
  3318.                    ((vid_line + 2) % VID_ROW_SIZE);
  3319.  
  3320.         if (vid_line >= vid_wmodes)
  3321.             vid_line = vid_wmodes - 1;
  3322.         break;
  3323.  
  3324.     case K_RIGHTARROW:
  3325.         S_LocalSound ("misc/menu1.wav");
  3326.         vid_line = ((vid_line / VID_ROW_SIZE) * VID_ROW_SIZE) +
  3327.                    ((vid_line + 4) % VID_ROW_SIZE);
  3328.  
  3329.         if (vid_line >= vid_wmodes)
  3330.             vid_line = (vid_line / VID_ROW_SIZE) * VID_ROW_SIZE;
  3331.         break;
  3332.  
  3333.     case K_UPARROW:
  3334.         S_LocalSound ("misc/menu1.wav");
  3335.         vid_line -= VID_ROW_SIZE;
  3336.  
  3337.         if (vid_line < 0)
  3338.         {
  3339.             vid_line += ((vid_wmodes + (VID_ROW_SIZE - 1)) /
  3340.                     VID_ROW_SIZE) * VID_ROW_SIZE;
  3341.  
  3342.             while (vid_line >= vid_wmodes)
  3343.                 vid_line -= VID_ROW_SIZE;
  3344.         }
  3345.         break;
  3346.  
  3347.     case K_DOWNARROW:
  3348.         S_LocalSound ("misc/menu1.wav");
  3349.         vid_line += VID_ROW_SIZE;
  3350.  
  3351.         if (vid_line >= vid_wmodes)
  3352.         {
  3353.             vid_line -= ((vid_wmodes + (VID_ROW_SIZE - 1)) /
  3354.                     VID_ROW_SIZE) * VID_ROW_SIZE;
  3355.  
  3356.             while (vid_line < 0)
  3357.                 vid_line += VID_ROW_SIZE;
  3358.         }
  3359.         break;
  3360.  
  3361.     case K_ENTER:
  3362.         S_LocalSound ("misc/menu1.wav");
  3363.         VID_SetMode (modedescs[vid_line].modenum, vid_curpal);
  3364.         break;
  3365.  
  3366.     case 'T':
  3367.     case 't':
  3368.         S_LocalSound ("misc/menu1.wav");
  3369.     // have to set this before setting the mode because WM_PAINT
  3370.     // happens during the mode set and does a VID_Update, which
  3371.     // checks vid_testingmode
  3372.         vid_testingmode = 1;
  3373.         vid_testendtime = realtime + 5.0;
  3374.  
  3375.         if (!VID_SetMode (modedescs[vid_line].modenum, vid_curpal))
  3376.         {
  3377.             vid_testingmode = 0;
  3378.         }
  3379.         break;
  3380.  
  3381.     case 'D':
  3382.     case 'd':
  3383.         S_LocalSound ("misc/menu1.wav");
  3384.         firstupdate = 0;
  3385.         Cvar_SetValue ("_vid_default_mode_win", vid_modenum);
  3386.         break;
  3387.  
  3388.     default:
  3389.         break;
  3390.     }
  3391. }
  3392.