server: Define a generic context structure instead of using the platform-specific...
[wine] / dlls / winedos / vga.c
index eb08e36..6c9085e 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * VGA hardware emulation
- * 
- * Copyright 1998 Ove Kåven (with some help from Marcus Meissner)
+ *
+ * Copyright 1998 Ove Kåven (with some help from Marcus Meissner)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#include <stdarg.h>
 #include <string.h>
+
+#define NONAMELESSUNION
+#define NONAMELESSSTRUCT
+#include "windef.h"
 #include "winbase.h"
 #include "wingdi.h"
 #include "winuser.h"
 #include "wincon.h"
-#include "miscemu.h"
 #include "dosexe.h"
 #include "vga.h"
 #include "ddraw.h"
@@ -35,25 +39,257 @@ static IDirectDraw *lpddraw = NULL;
 static IDirectDrawSurface *lpddsurf;
 static IDirectDrawPalette *lpddpal;
 static DDSURFACEDESC sdesc;
-static LONG vga_polling,vga_refresh;
-static HANDLE poll_timer;
 
-static int vga_width;
-static int vga_height;
-static int vga_depth;
+static BOOL vga_retrace_vertical;
+static BOOL vga_retrace_horizontal;
+
+/*
+ * Size and location of VGA controller window to framebuffer.
+ *
+ * Note: We support only single window even though some
+ *       controllers support two. This should not be changed unless
+ *       there are programs that depend on having two windows.
+ */
+#define VGA_WINDOW_SIZE  (64 * 1024)
+#define VGA_WINDOW_START ((char *)0xa0000)
+
+/*
+ * Size and location of CGA controller window to framebuffer.
+ */
+#define CGA_WINDOW_SIZE  (32 * 1024)
+#define CGA_WINDOW_START ((char *)0xb8000)
+
+/*
+ * VGA controller memory is emulated using linear framebuffer.
+ * This frambuffer also acts as an interface
+ * between VGA controller emulation and DirectDraw.
+ *
+ * vga_fb_width: Display width in pixels. Can be modified when
+ *               display mode is changed.
+ * vga_fb_height: Display height in pixels. Can be modified when
+ *                display mode is changed.
+ * vga_fb_depth: Number of bits used to store single pixel color information.
+ *               Each pixel uses (vga_fb_depth+7)/8 bytes because
+ *               1-16 color modes are mapped to 256 color mode.
+ *               Can be modified when display mode is changed.
+ * vga_fb_pitch: How many bytes to add to pointer in order to move
+ *               from one row to another. This is fixed in VGA modes,
+ *               but can be modified in SVGA modes.
+ * vga_fb_offset: Offset added to framebuffer start address in order
+ *                to find the display origin. Programs use this to do
+ *                double buffering and to scroll display. The value can
+ *                be modified in VGA and SVGA modes.
+ * vga_fb_size: How many bytes are allocated to framebuffer.
+ *              VGA framebuffers are always larger than display size and
+ *              SVGA framebuffers may also be.
+ * vga_fb_data: Pointer to framebuffer start.
+ * vga_fb_window: Offset of 64k window 0xa0000 in bytes from framebuffer start.
+ *                This value is >= 0, if mode uses linear framebuffer and
+ *                -1, if mode uses color planes. This value is fixed
+ *                in all modes except 0x13 (256 color VGA) where
+ *                0 means normal mode and -1 means Mode-X (unchained mode).
+ */
+static int   vga_fb_width;
+static int   vga_fb_height;
+static int   vga_fb_depth;
+static int   vga_fb_pitch;
+static int   vga_fb_offset;
+static int   vga_fb_size = 0;
+static char *vga_fb_data = 0;
+static int   vga_fb_window = 0;
+static int   vga_fb_window_size;
+static char *vga_fb_window_data;
+static PALETTEENTRY *vga_fb_palette;
+static unsigned vga_fb_palette_index;
+static unsigned vga_fb_palette_size;
+static BOOL  vga_fb_bright;
+static BOOL  vga_fb_enabled;
+
+/*
+ * VGA text mode data.
+ *
+ * vga_text_attr: Current active attribute.
+ * vga_text_old: Last data sent to console. 
+ *               This is used to optimize console updates.
+ * vga_text_width:  Width of the text display in characters.
+ * vga_text_height: Height of the text display in characters.
+ * vga_text_x: Current cursor X-position. Starts from zero.
+ * vga_text_y: Current cursor Y-position. Starts from zero.
+ * vga_text_console: TRUE if stdout is console, 
+ *                   FALSE if it is regular file.
+ */
+static BYTE  vga_text_attr;
+static char *vga_text_old = NULL;
+static BYTE  vga_text_width;
+static BYTE  vga_text_height;
+static BYTE  vga_text_x;
+static BYTE  vga_text_y;
+static BOOL  vga_text_console;
+
+/*
+ * VGA controller ports 0x3c0, 0x3c4, 0x3ce and 0x3d4 are
+ * indexed registers. These ports are used to select VGA controller
+ * subregister that can be written to or read from using ports 0x3c1,
+ * 0x3c5, 0x3cf or 0x3d5. Selected subregister indexes are
+ * stored in variables vga_index_*.
+ *
+ * Port 0x3c0 is special because it is both index and
+ * data-write register. Flip-flop vga_address_3c0 tells whether
+ * the port acts currently as an address register. Reading from port
+ * 0x3da resets the flip-flop to address mode.
+ */
+static BYTE vga_index_3c0;
+static BYTE vga_index_3c4;
+static BYTE vga_index_3ce;
+static BYTE vga_index_3d4;
+static BOOL vga_address_3c0 = TRUE;
+
+/*
+ * List of supported video modes.
+ *
+ * should be expanded to contain most or all information
+ * as required for SVGA VESA mode info block for VESA BIOS subsystem 1 (see _ModeInfoBlock)
+ * this will allow proper support for FIXME items in VGA/VESA mode configuration
+ *
+ * FIXME - verify and define support for VESA modes
+ * FIXME - add # bit planes, # video memory banks, & memory model
+ */
+static WORD VGA_CurrentMode;
+static BOOL CGA_ColorComposite = FALSE;  /* behave like composite monitor */
+
+const VGA_MODE VGA_modelist[] =
+{
+    /* Mode, ModeType, TextCols, TextRows, CharWidth, CharHeight, Width, Height, Depth, Colors, ScreenPages, Supported*/
+    /* VGA modes */
+    {0x0000,    TEXT, 40, 25,  9, 16,  360,  400,  0,  16, 8, TRUE},   /* VGA/CGA text mode 0 */
+    {0x0001,    TEXT, 40, 25,  9, 16,  360,  400,  0,  16, 8, TRUE},   /* VGA/CGA text mode 1 */
+    {0x0002,    TEXT, 80, 25,  9, 16,  360,  400,  0,  16, 8, TRUE},   /* VGA/CGA text mode 2 */
+    {0x0003,    TEXT, 80, 25,  9, 16,  360,  400,  0,  16, 8, TRUE},   /* VGA/CGA text mode 3 */
+    {0x0004, GRAPHIC, 40, 25,  8,  8,  320,  200,  2,   4, 1, TRUE},   /* VGA/CGA graphics mode 4 */
+    {0x0005, GRAPHIC, 40, 25,  8,  8,  320,  200,  2,   4, 1, TRUE},   /* VGA/CGA graphics mode 5 */
+    {0x0006, GRAPHIC, 80, 25,  8,  8,  640,  200,  1,   2, 1, TRUE},   /* VGA/CGA graphics mode 6 */
+    {0x0007,    TEXT, 80, 25,  9, 16,  720,  400,  0,   0, 8, FALSE},   /* VGA text mode 7 - FIXME bad default address */
+    {0x000d, GRAPHIC, 40, 25,  8,  8,  320,  200,  4,  16, 8, FALSE},   /* VGA graphics mode 13 */
+    {0x000e, GRAPHIC, 80, 25,  8,  8,  640,  200,  4,  16, 4, FALSE},   /* VGA graphics mode 14 */
+    {0x000f, GRAPHIC, 80, 25,  8, 14,  640,  350,  0,   0, 2, FALSE},   /* VGA graphics mode 15 */
+    {0x0010, GRAPHIC, 80, 25,  8, 14,  640,  350,  4,  16, 2, FALSE},   /* VGA graphics mode 16 */
+    {0x0012, GRAPHIC, 80, 30,  8, 16,  640,  480,  1,   2, 1, FALSE},   /* VGA graphics mode 17 */
+    {0x0012, GRAPHIC, 80, 30,  8, 16,  640,  480,  4,  16, 1, FALSE},   /* VGA graphics mode 18 */
+    {0x0013, GRAPHIC, 40, 25,  8,  8,  320,  200,  8, 256, 1, TRUE},   /* VGA graphics mode 19 */
+    /* VESA 7-bit modes */
+    {0x006a, GRAPHIC,  0,  0,  0,  0,  800,  600,  4,  16, 1, TRUE},   /* VESA graphics mode, same as 0x102 */
+    /* VESA 15-bit modes */
+    {0x0100, GRAPHIC,  0,  0,  0,  0,  640,  400,  8, 256, 1, TRUE},   /* VESA graphics mode */
+    {0x0101, GRAPHIC,  0,  0,  0,  0,  640,  480,  8, 256, 1, TRUE},   /* VESA graphics mode */
+    {0x0102, GRAPHIC,  0,  0,  0,  0,  800,  600,  4,  16, 1, TRUE},   /* VESA graphics mode */
+    {0x0103, GRAPHIC,  0,  0,  0,  0,  800,  600,  8, 256, 1, TRUE},   /* VESA graphics mode */
+    {0x0104, GRAPHIC,  0,  0,  0,  0, 1024,  768,  4,  16, 1, TRUE},   /* VESA graphics mode */
+    {0x0105, GRAPHIC,  0,  0,  0,  0, 1024,  768,  8, 256, 1, TRUE},   /* VESA graphics mode */
+    {0x0106, GRAPHIC,  0,  0,  0,  0, 1280, 1024,  4,  16, 1, TRUE},   /* VESA graphics mode */
+    {0x0107, GRAPHIC,  0,  0,  0,  0, 1280, 1024,  8, 256, 1, TRUE},   /* VESA graphics mode */
+    {0x0108,    TEXT,  0,  0,  0,  0,   80,   60,  0,   0, 1, TRUE},   /* VESA text mode */
+    {0x0109,    TEXT,  0,  0,  0,  0,  132,   25,  0,   0, 1, TRUE},   /* VESA text mode */
+    {0x010a,    TEXT,  0,  0,  0,  0,  132,   43,  0,   0, 1, TRUE},   /* VESA text mode */
+    {0x010b,    TEXT,  0,  0,  0,  0,  132,   50,  0,   0, 1, TRUE},   /* VESA text mode */
+    {0x010c,    TEXT,  0,  0,  0,  0,  132,   60,  0,   0, 1, TRUE},   /* VESA text mode */
+    /* VESA 1.2 modes */
+    {0x010d, GRAPHIC,  0,  0,  0,  0,  320,  200, 15,   0, 1, TRUE},   /* VESA graphics mode, 32K colors */
+    {0x010e, GRAPHIC,  0,  0,  0,  0,  320,  200, 16,   0, 1, TRUE},   /* VESA graphics mode, 64K colors */
+    {0x010f, GRAPHIC,  0,  0,  0,  0,  320,  200, 24,   0, 1, TRUE},   /* VESA graphics mode, 16.8 Million colors */
+    {0x0110, GRAPHIC,  0,  0,  0,  0,  640,  480, 15,   0, 1, TRUE},   /* VESA graphics mode, 32K colors */
+    {0x0111, GRAPHIC,  0,  0,  0,  0,  640,  480, 16,   0, 1, TRUE},   /* VESA graphics mode, 64K colors */
+    {0x0112, GRAPHIC,  0,  0,  0,  0,  640,  480, 24,   0, 1, TRUE},   /* VESA graphics mode, 16.8 Million colors */
+    {0x0113, GRAPHIC,  0,  0,  0,  0,  800,  600, 15,   0, 1, TRUE},   /* VESA graphics mode, 32K colors */
+    {0x0114, GRAPHIC,  0,  0,  0,  0,  800,  600, 16,   0, 1, TRUE},   /* VESA graphics mode, 64K colors */
+    {0x0115, GRAPHIC,  0,  0,  0,  0,  800,  600, 24,   0, 1, TRUE},   /* VESA graphics mode, 16.8 Million colors */
+    {0x0116, GRAPHIC,  0,  0,  0,  0, 1024,  768, 15,   0, 1, TRUE},   /* VESA graphics mode, 32K colors */
+    {0x0117, GRAPHIC,  0,  0,  0,  0, 1024,  768, 16,   0, 1, TRUE},   /* VESA graphics mode, 64K colors */
+    {0x0118, GRAPHIC,  0,  0,  0,  0, 1024,  768, 24,   0, 1, TRUE},   /* VESA graphics mode, 16.8 Million colors */
+    {0x0119, GRAPHIC,  0,  0,  0,  0, 1280, 1024, 15,   0, 1, TRUE},   /* VESA graphics mode, 32K colors */
+    {0x011a, GRAPHIC,  0,  0,  0,  0, 1280, 1024, 16,   0, 1, TRUE},   /* VESA graphics mode, 64K colors */
+    {0x011b, GRAPHIC,  0,  0,  0,  0, 1280, 1024, 24,   0, 1, TRUE},   /* VESA graphics mode, 16.8 Million colors */
+    {0xffff,    TEXT,  0,  0,  0,  0,    0,    0,  0,   0, 1, FALSE}
+};
+
+/*
+ * This mutex is used to protect VGA state during asynchronous
+ * screen updates (see VGA_Poll). It makes sure that VGA state changes
+ * are atomic and the user interface is protected from flicker and
+ * corruption.
+ *
+ * The mutex actually serializes VGA operations and the screen update. 
+ * Which means that whenever VGA_Poll occurs, application stalls if it 
+ * tries to modify VGA state. This is not how real VGA adapters work,
+ * but it makes timing and correctness issues much easier to deal with.
+ */
+static CRITICAL_SECTION vga_lock;
+static CRITICAL_SECTION_DEBUG critsect_debug =
+{
+    0, 0, &vga_lock,
+    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
+      0, 0, { (DWORD_PTR)(__FILE__ ": vga_lock") }
+};
+static CRITICAL_SECTION vga_lock = { &critsect_debug, -1, 0, 0, 0, 0 };
 
 typedef HRESULT (WINAPI *DirectDrawCreateProc)(LPGUID,LPDIRECTDRAW *,LPUNKNOWN);
 static DirectDrawCreateProc pDirectDrawCreate;
 
 static void CALLBACK VGA_Poll( LPVOID arg, DWORD low, DWORD high );
 
+static HWND vga_hwnd = NULL;
+
+/*
+ * CGA palette 1
+ */
+static PALETTEENTRY cga_palette1[] = {
+  {0x00, 0x00, 0x00}, /* 0 - Black */
+  {0x00, 0xAA, 0xAA}, /* 1 - Cyan */
+  {0xAA, 0x00, 0xAA}, /* 2 - Magenta */
+  {0xAA, 0xAA, 0xAA}  /* 3 - White */
+};
+
+/*
+ * CGA palette 1 in the bright variant
+ * intensities, when signalled to do so
+ * in register 0x3d9
+ */
+static PALETTEENTRY cga_palette1_bright[] = {
+  {0x00, 0x00, 0x00}, /* 0 - Black */
+  {0x55, 0xFF, 0xFF}, /* 1 - Light cyan */
+  {0xFF, 0x55, 0xFF}, /* 2 - Light magenta */
+  {0xFF, 0xFF, 0xFF}, /* 3 - Bright White */
+};
+
+/*
+ * CGA palette 2
+ */
+static PALETTEENTRY cga_palette2[] = {
+  {0x00, 0x00, 0x00}, /* 0 - Black */
+  {0x00, 0xAA, 0x00}, /* 1 - Green */
+  {0xAA, 0x00, 0x00}, /* 2 - Red */
+  {0xAA, 0x55, 0x00}  /* 3 - Brown */
+};
+
 /*
- * For simplicity, I'm creating a second palette.
- * 16 color accesses will use these pointers and insert
- * entries from the 64-color palette into the default
- * palette.   --Robert 'Admiral' Coeyman
+ * CGA palette 2 in the bright variant
+ * intensities, when signalled to do so
+ * in register 0x3d9
  */
+static PALETTEENTRY cga_palette2_bright[] = {
+  {0x00, 0x00, 0x00}, /* 0 - Black */
+  {0x55, 0xFF, 0x55}, /* 1 - Light green */
+  {0xFF, 0x55, 0x55}, /* 2 - Light red */
+  {0xFF, 0xFF, 0x55}, /* 3 - Yellow */
+};
 
+/*
+ *  VGA Palette Registers, in actual 16 bit color
+ *  port 3C0H - 6 bit rgbRGB format
+ *
+ *  16 color accesses will use these pointers and insert
+ *  entries from the 64-color palette (mode 18) into the default
+ *  palette.   --Robert 'Admiral' Coeyman
+ */
 static char vga_16_palette[17]={
   0x00,  /* 0 - Black         */
   0x01,  /* 1 - Blue          */
@@ -62,7 +298,7 @@ static char vga_16_palette[17]={
   0x04,  /* 4 - Red           */
   0x05,  /* 5 - Magenta       */
   0x14,  /* 6 - Brown         */
-  0x07,  /* 7 - Light gray    */
+  0x07,  /* 7 - White (Light gray)        */
   0x38,  /* 8 - Dark gray     */
   0x39,  /* 9 - Light blue    */
   0x3a,  /* A - Light green   */
@@ -70,35 +306,286 @@ static char vga_16_palette[17]={
   0x3c,  /* C - Light red     */
   0x3d,  /* D - Light magenta */
   0x3e,  /* E - Yellow        */
-  0x3f,  /* F - White         */
+  0x3f,  /* F - Bright White (White) */
   0x00   /* Border Color      */
 };
 
+/*
+ *  Mode 19 Default Color Register Setting
+ *  DAC palette registers, converted from actual 18 bit color to 24.
+ */
 static PALETTEENTRY vga_def_palette[256]={
 /* red  green  blue */
-  {0x00, 0x00, 0x00}, /* 0 - Black */
-  {0x00, 0x00, 0x80}, /* 1 - Blue */
-  {0x00, 0x80, 0x00}, /* 2 - Green */
-  {0x00, 0x80, 0x80}, /* 3 - Cyan */
-  {0x80, 0x00, 0x00}, /* 4 - Red */
-  {0x80, 0x00, 0x80}, /* 5 - Magenta */
-  {0x80, 0x80, 0x00}, /* 6 - Brown */
-  {0xC0, 0xC0, 0xC0}, /* 7 - Light gray */
-  {0x80, 0x80, 0x80}, /* 8 - Dark gray */
-  {0x00, 0x00, 0xFF}, /* 9 - Light blue */
-  {0x00, 0xFF, 0x00}, /* A - Light green */
-  {0x00, 0xFF, 0xFF}, /* B - Light cyan */
-  {0xFF, 0x00, 0x00}, /* C - Light red */
-  {0xFF, 0x00, 0xFF}, /* D - Light magenta */
-  {0xFF, 0xFF, 0x00}, /* E - Yellow */
-  {0xFF, 0xFF, 0xFF}, /* F - White */
-  {0,0,0} /* FIXME: a series of continuous rainbow hues should follow */
+  /* 16 colors in IRGB values */
+  {0x00, 0x00, 0x00}, /* 0 (0) - Black */
+  {0x00, 0x00, 0xAA}, /* 1 (1) - Blue */
+  {0x00, 0xAA, 0x00}, /* 2 (2) - Green */
+  {0x00, 0xAA, 0xAA}, /* 3 (3) - Cyan */
+  {0xAA, 0x00, 0x00}, /* 4 (4) - Red */
+  {0xAA, 0x00, 0xAA}, /* 5 (5) - Magenta */
+  {0xAA, 0x55, 0x00}, /* 6 (6) - Brown */
+  {0xAA, 0xAA, 0xAA}, /* 7 (7) - White (Light gray) */
+  {0x55, 0x55, 0x55}, /* 8 (8) - Dark gray */
+  {0x55, 0x55, 0xFF}, /* 9 (9) - Light blue */
+  {0x55, 0xFF, 0x55}, /* 10 (A) - Light green */
+  {0x55, 0xFF, 0xFF}, /* 11 (B) - Light cyan */
+  {0xFF, 0x55, 0x55}, /* 12 (C) - Light red */
+  {0xFF, 0x55, 0xFF}, /* 13 (D) - Light magenta */
+  {0xFF, 0xFF, 0x55}, /* 14 (E) -  Yellow */
+  {0xFF, 0xFF, 0xFF}, /* 15 (F) - Bright White (White) */
+  /* 16 shades of gray */
+  {0x00, 0x00, 0x00}, /* 16 (10) */
+  {0x10, 0x10, 0x10}, /* 17 (11) */
+  {0x20, 0x20, 0x20}, /* 18 (12) */
+  {0x35, 0x35, 0x35}, /* 19 (13) */
+  {0x45, 0x45, 0x45}, /* 20 (14) */
+  {0x55, 0x55, 0x55}, /* 21 (15) */
+  {0x65, 0x65, 0x65}, /* 22 (16) */
+  {0x75, 0x75, 0x75}, /* 23 (17) */
+  {0x8A, 0x8A, 0x8A}, /* 24 (18) */
+  {0x9A, 0x9A, 0x9A}, /* 25 (19) */
+  {0xAA, 0xAA, 0xAA}, /* 26 (1A) */
+  {0xBA, 0xBA, 0xBA}, /* 27 (1B) */
+  {0xCA, 0xCA, 0xCA}, /* 28 (1C) */
+  {0xDF, 0xDF, 0xDF}, /* 29 (1D) */
+  {0xEF, 0xEF, 0xEF}, /* 30 (1E) */
+  {0xFF, 0xFF, 0xFF}, /* 31 (1F) */
+  /* High Intensity group - 72 colors in 1/3 saturation groups (20H-37H high) */
+  {0x00, 0x00, 0xFF}, /* 32 (20) */
+  {0x41, 0x00, 0xFF}, /* 33 (21) */
+  {0x82, 0x00, 0xFF}, /* 34 (22) */
+  {0xBE, 0x00, 0xFF}, /* 35 (23) */
+  {0xFF, 0x00, 0xFF}, /* 36 (24) */
+  {0xFF, 0x00, 0xBE}, /* 37 (25) */
+  {0xFF, 0x00, 0x82}, /* 38 (26) */
+  {0xFF, 0x00, 0x41}, /* 39 (27) */
+  {0xFF, 0x00, 0x00}, /* 40 (28) */
+  {0xFF, 0x41, 0x00}, /* 41 (29) */
+  {0xFF, 0x82, 0x00}, /* 42 (2A) */
+  {0xFF, 0xBE, 0x00}, /* 43 (2B) */
+  {0xFF, 0xFF, 0x00}, /* 44 (2C) */
+  {0xBE, 0xFF, 0x00}, /* 45 (2D) */
+  {0x82, 0xFF, 0x00}, /* 46 (2E) */
+  {0x41, 0xFF, 0x00}, /* 47 (2F) */
+  {0x00, 0xFF, 0x00}, /* 48 (30) */
+  {0x00, 0xFF, 0x41}, /* 49 (31) */
+  {0x00, 0xFF, 0x82}, /* 50 (32) */
+  {0x00, 0xFF, 0xBE}, /* 51 (33) */
+  {0x00, 0xFF, 0xFF}, /* 52 (34) */
+  {0x00, 0xBE, 0xFF}, /* 53 (35) */
+  {0x00, 0x82, 0xFF}, /* 54 (36) */
+  {0x00, 0x41, 0xFF}, /* 55 (37) */
+  /* High Intensity group - 72 colors in 2/3 saturation groups (38H-4FH moderate) */
+  {0x82, 0x82, 0xFF}, /* 56 (38) */
+  {0x9E, 0x82, 0xFF}, /* 57 (39) */
+  {0xBE, 0x82, 0xFF}, /* 58 (3A) */
+  {0xDF, 0x82, 0xFF}, /* 59 (3B) */
+  {0xFF, 0x82, 0xFF}, /* 60 (3C) */
+  {0xFF, 0x82, 0xDF}, /* 61 (3D) */
+  {0xFF, 0x82, 0xBE}, /* 62 (3E) */
+  {0xFF, 0x82, 0x9E}, /* 63 (3F) */
+  {0xFF, 0x82, 0x82}, /* 64 (40) */
+  {0xFF, 0x9E, 0x82}, /* 65 (41) */
+  {0xFF, 0xBE, 0x82}, /* 66 (42) */
+  {0xFF, 0xDF, 0x82}, /* 67 (43) */
+  {0xFF, 0xFF, 0x82}, /* 68 (44) */
+  {0xDF, 0xFF, 0x82}, /* 69 (45) */
+  {0xBE, 0xFF, 0x82}, /* 70 (46) */
+  {0x9E, 0xFF, 0x82}, /* 71 (47) */
+  {0x82, 0xFF, 0x82}, /* 72 (48) */
+  {0x82, 0xFF, 0x9E}, /* 73 (49) */
+  {0x82, 0xFF, 0xBE}, /* 74 (4A) */
+  {0x82, 0xFF, 0xDF}, /* 75 (4B) */
+  {0x82, 0xFF, 0xFF}, /* 76 (4C) */
+  {0x82, 0xDF, 0xFF}, /* 77 (4D) */
+  {0x82, 0xBE, 0xFF}, /* 78 (4E) */
+  {0x82, 0x9E, 0xFF}, /* 79 (4F) */
+  /* High Intensity group - 72 colors in 3/3 saturation groups (50H-67H low) */
+  {0xBA, 0xBA, 0xFF}, /* 80 (50) */
+  {0xCA, 0xBA, 0xFF}, /* 81 (51) */
+  {0xDF, 0xBA, 0xFF}, /* 82 (52) */
+  {0xEF, 0xBA, 0xFF}, /* 83 (53) */
+  {0xFF, 0xBA, 0xFF}, /* 84 (54) */
+  {0xFF, 0xBA, 0xEF}, /* 85 (55) */
+  {0xFF, 0xBA, 0xDF}, /* 86 (56) */
+  {0xFF, 0xBA, 0xCA}, /* 87 (57) */
+  {0xFF, 0xBA, 0xBA}, /* 88 (58) */
+  {0xFF, 0xCA, 0xBA}, /* 89 (59) */
+  {0xFF, 0xDF, 0xBA}, /* 90 (5A) */
+  {0xFF, 0xEF, 0xBA}, /* 91 (5B) */
+  {0xFF, 0xFF, 0xBA}, /* 92 (5C) */
+  {0xEF, 0xFF, 0xBA}, /* 93 (5D) */
+  {0xDF, 0xFF, 0xBA}, /* 94 (5E) */
+  {0xCA, 0xFF, 0xBA}, /* 95 (5F) */
+  {0xBA, 0xFF, 0xBA}, /* 96 (60) */
+  {0xBA, 0xFF, 0xCA}, /* 97 (61) */
+  {0xBA, 0xFF, 0xDF}, /* 98 (62) */
+  {0xBA, 0xFF, 0xEF}, /* 99 (63) */
+  {0xBA, 0xFF, 0xFF}, /* 100 (64) */
+  {0xBA, 0xEF, 0xFF}, /* 101 (65) */
+  {0xBA, 0xDF, 0xFF}, /* 102 (66) */
+  {0xBA, 0xCA, 0xFF}, /* 103 (67) */
+  /* Medium Intensity group - 72 colors in 1/3 saturation groups (68H-7FH high) */
+  {0x00, 0x00, 0x71}, /* 104 (68) */
+  {0x1C, 0x00, 0x71}, /* 105 (69) */
+  {0x39, 0x00, 0x71}, /* 106 (6A) */
+  {0x55, 0x00, 0x71}, /* 107 (6B) */
+  {0x71, 0x00, 0x71}, /* 108 (6C) */
+  {0x71, 0x00, 0x55}, /* 109 (6D) */
+  {0x71, 0x00, 0x39}, /* 110 (6E) */
+  {0x71, 0x00, 0x1C}, /* 111 (6F) */
+  {0x71, 0x00, 0x00}, /* 112 (70) */
+  {0x71, 0x1C, 0x00}, /* 113 (71) */
+  {0x71, 0x39, 0x00}, /* 114 (72) */
+  {0x71, 0x55, 0x00}, /* 115 (73) */
+  {0x71, 0x71, 0x00}, /* 116 (74) */
+  {0x55, 0x71, 0x00}, /* 117 (75) */
+  {0x39, 0x71, 0x00}, /* 118 (76) */
+  {0x1C, 0x71, 0x00}, /* 119 (77) */
+  {0x00, 0x71, 0x00}, /* 120 (78) */
+  {0x00, 0x71, 0x1C}, /* 121 (79) */
+  {0x00, 0x71, 0x39}, /* 122 (7A) */
+  {0x00, 0x71, 0x55}, /* 123 (7B) */
+  {0x00, 0x71, 0x71}, /* 124 (7C) */
+  {0x00, 0x55, 0x71}, /* 125 (7D) */
+  {0x00, 0x39, 0x71}, /* 126 (7E) */
+  {0x00, 0x1C, 0x71}, /* 127 (7F) */
+  /* Medium Intensity group - 72 colors in 2/3 saturation groups (80H-97H moderate) */
+  {0x39, 0x39, 0x71}, /* 128 (80) */
+  {0x45, 0x39, 0x71}, /* 129 (81) */
+  {0x55, 0x39, 0x71}, /* 130 (82) */
+  {0x61, 0x39, 0x71}, /* 131 (83) */
+  {0x71, 0x39, 0x71}, /* 132 (84) */
+  {0x71, 0x39, 0x61}, /* 133 (85) */
+  {0x71, 0x39, 0x55}, /* 134 (86) */
+  {0x71, 0x39, 0x45}, /* 135 (87) */
+  {0x71, 0x39, 0x39}, /* 136 (88) */
+  {0x71, 0x45, 0x39}, /* 137 (89) */
+  {0x71, 0x55, 0x39}, /* 138 (8A) */
+  {0x71, 0x61, 0x39}, /* 139 (8B) */
+  {0x71, 0x71, 0x39}, /* 140 (8C) */
+  {0x61, 0x71, 0x39}, /* 141 (8D) */
+  {0x55, 0x71, 0x39}, /* 142 (8E) */
+  {0x45, 0x71, 0x39}, /* 143 (8F) */
+  {0x39, 0x71, 0x39}, /* 144 (90) */
+  {0x39, 0x71, 0x45}, /* 145 (91) */
+  {0x39, 0x71, 0x55}, /* 146 (92) */
+  {0x39, 0x71, 0x61}, /* 147 (93) */
+  {0x39, 0x71, 0x71}, /* 148 (94) */
+  {0x39, 0x61, 0x71}, /* 149 (95) */
+  {0x39, 0x55, 0x71}, /* 150 (96) */
+  {0x39, 0x45, 0x71}, /* 151 (97) */
+  /* Medium Intensity group - 72 colors in 3/3 saturation groups (98H-AFH low) */
+  {0x51, 0x51, 0x71}, /* 152 (98) */
+  {0x59, 0x51, 0x71}, /* 153 (99) */
+  {0x61, 0x51, 0x71}, /* 154 (9A) */
+  {0x69, 0x51, 0x71}, /* 155 (9B) */
+  {0x71, 0x51, 0x71}, /* 156 (9C) */
+  {0x71, 0x51, 0x69}, /* 157 (9D) */
+  {0x71, 0x51, 0x61}, /* 158 (9E) */
+  {0x71, 0x51, 0x59}, /* 159 (9F) */
+  {0x71, 0x51, 0x51}, /* 160 (A0) */
+  {0x71, 0x59, 0x51}, /* 161 (A1) */
+  {0x71, 0x61, 0x51}, /* 162 (A2) */
+  {0x71, 0x69, 0x51}, /* 163 (A3) */
+  {0x71, 0x71, 0x51}, /* 164 (A4) */
+  {0x69, 0x71, 0x51}, /* 165 (A5) */
+  {0x61, 0x71, 0x51}, /* 166 (A6) */
+  {0x59, 0x71, 0x51}, /* 167 (A7) */
+  {0x51, 0x71, 0x51}, /* 168 (A8) */
+  {0x51, 0x71, 0x59}, /* 169 (A9) */
+  {0x51, 0x71, 0x61}, /* 170 (AA) */
+  {0x51, 0x71, 0x69}, /* 171 (AB) */
+  {0x51, 0x71, 0x71}, /* 172 (AC) */
+  {0x51, 0x69, 0x71}, /* 173 (AD) */
+  {0x51, 0x61, 0x71}, /* 174 (AE) */
+  {0x51, 0x59, 0x71}, /* 175 (AF) */
+  /* Low Intensity group - 72 colors in 1/3 saturation groups (B0H-C7H high) */
+  {0x00, 0x00, 0x41}, /* 176 (B0) */
+  {0x10, 0x00, 0x41}, /* 177 (B1) */
+  {0x20, 0x00, 0x41}, /* 178 (B2) */
+  {0x31, 0x00, 0x41}, /* 179 (B3) */
+  {0x41, 0x00, 0x41}, /* 180 (B4) */
+  {0x41, 0x00, 0x31}, /* 181 (B5) */
+  {0x41, 0x00, 0x20}, /* 182 (B6) */
+  {0x41, 0x00, 0x10}, /* 183 (B7) */
+  {0x41, 0x00, 0x00}, /* 184 (B8) */
+  {0x41, 0x10, 0x00}, /* 185 (B9) */
+  {0x41, 0x20, 0x00}, /* 186 (BA) */
+  {0x41, 0x31, 0x00}, /* 187 (BB) */
+  {0x41, 0x41, 0x00}, /* 188 (BC) */
+  {0x31, 0x41, 0x00}, /* 189 (BD) */
+  {0x20, 0x41, 0x00}, /* 190 (BE) */
+  {0x10, 0x41, 0x00}, /* 191 (BF) */
+  {0x00, 0x41, 0x00}, /* 192 (C0) */
+  {0x00, 0x41, 0x10}, /* 193 (C1) */
+  {0x00, 0x41, 0x20}, /* 194 (C2) */
+  {0x00, 0x41, 0x31}, /* 195 (C3) */
+  {0x00, 0x41, 0x41}, /* 196 (C4) */
+  {0x00, 0x31, 0x41}, /* 197 (C5) */
+  {0x00, 0x20, 0x41}, /* 198 (C6) */
+  {0x00, 0x10, 0x41}, /* 199 (C7) */
+  /* Low Intensity group - 72 colors in 2/3 saturation groups (C8H-DFH moderate) */
+  {0x20, 0x20, 0x41}, /* 200 (C8) */
+  {0x28, 0x20, 0x41}, /* 201 (C9) */
+  {0x31, 0x20, 0x41}, /* 202 (CA) */
+  {0x39, 0x20, 0x41}, /* 203 (CB) */
+  {0x41, 0x20, 0x41}, /* 204 (CC) */
+  {0x41, 0x20, 0x39}, /* 205 (CD) */
+  {0x41, 0x20, 0x31}, /* 206 (CE) */
+  {0x41, 0x20, 0x28}, /* 207 (CF) */
+  {0x41, 0x20, 0x20}, /* 208 (D0) */
+  {0x41, 0x28, 0x20}, /* 209 (D1) */
+  {0x41, 0x31, 0x20}, /* 210 (D2) */
+  {0x41, 0x39, 0x20}, /* 211 (D3) */
+  {0x41, 0x41, 0x20}, /* 212 (D4) */
+  {0x39, 0x41, 0x20}, /* 213 (D5) */
+  {0x31, 0x41, 0x20}, /* 214 (D6) */
+  {0x28, 0x41, 0x20}, /* 215 (D7) */
+  {0x20, 0x41, 0x20}, /* 216 (D8) */
+  {0x20, 0x41, 0x28}, /* 217 (D9) */
+  {0x20, 0x41, 0x31}, /* 218 (DA) */
+  {0x20, 0x41, 0x39}, /* 219 (DB) */
+  {0x20, 0x41, 0x41}, /* 220 (DC) */
+  {0x20, 0x39, 0x41}, /* 221 (DD) */
+  {0x20, 0x31, 0x41}, /* 222 (DE) */
+  {0x20, 0x28, 0x41}, /* 223 (DF) */
+  /* Low Intensity group - 72 colors in 3/3 saturation groups (E0H-F7H low) */
+  {0x2D, 0x2D, 0x41}, /* 223 (E0) */
+  {0x31, 0x2D, 0x41}, /* 224 (E1) */
+  {0x35, 0x2D, 0x41}, /* 225 (E2) */
+  {0x3D, 0x2D, 0x41}, /* 226 (E3) */
+  {0x41, 0x2D, 0x41}, /* 227 (E4) */
+  {0x41, 0x2D, 0x3D}, /* 228 (E5) */
+  {0x41, 0x2D, 0x35}, /* 229 (E6) */
+  {0x41, 0x2D, 0x31}, /* 230 (E7) */
+  {0x41, 0x2D, 0x2D}, /* 231 (E8) */
+  {0x41, 0x31, 0x2D}, /* 232 (E9) */
+  {0x41, 0x35, 0x2D}, /* 233 (EA) */
+  {0x41, 0x3D, 0x2D}, /* 234 (EB) */
+  {0x41, 0x41, 0x2D}, /* 235 (EC) */
+  {0x3D, 0x41, 0x2D}, /* 236 (ED) */
+  {0x35, 0x41, 0x2D}, /* 237 (EE) */
+  {0x31, 0x41, 0x2D}, /* 238 (EF) */
+  {0x2D, 0x41, 0x2D}, /* 239 (F0) */
+  {0x2D, 0x41, 0x31}, /* 240 (F1) */
+  {0x2D, 0x41, 0x35}, /* 241 (F2) */
+  {0x2D, 0x41, 0x3D}, /* 242 (F3) */
+  {0x2D, 0x41, 0x41}, /* 243 (F4) */
+  {0x2D, 0x3D, 0x41}, /* 244 (F5) */
+  {0x2D, 0x35, 0x41}, /* 245 (F6) */
+  {0x2D, 0x31, 0x41}, /* 246 (F7) */
+  /* Fill up remainder of palettes with black */
+  {0,0,0}
 };
 
-/* 
- *   This palette is the dos default, converted from 18 bit color to 24. 
- *      It contains only 64 entries of colors--all others are zeros.
- *          --Robert 'Admiral' Coeyman
+/*
+ *  Mode 18 Default Color Register Setting
+ *  DAC palette registers, converted from actual 18 bit color to 24.
+ *
+ *  This palette is the dos default, converted from 18 bit color to 24.
+ *  It contains only 64 entries of colors--all others are zeros.
+ *      --Robert 'Admiral' Coeyman
  */
 static PALETTEENTRY vga_def64_palette[256]={
 /* red  green  blue */
@@ -109,7 +596,7 @@ static PALETTEENTRY vga_def64_palette[256]={
   {0xaa, 0x00, 0x00}, /* 0x04      Red        */
   {0xaa, 0x00, 0xaa}, /* 0x05      Magenta    */
   {0xaa, 0xaa, 0x00}, /* 0x06      */
-  {0xaa, 0xaa, 0xaa}, /* 0x07      Light Gray */
+  {0xaa, 0xaa, 0xaa}, /* 0x07      White (Light Gray) */
   {0x00, 0x00, 0x55}, /* 0x08      */
   {0x00, 0x00, 0xff}, /* 0x09      */
   {0x00, 0xaa, 0x55}, /* 0x0a      */
@@ -177,24 +664,46 @@ static void CALLBACK set_timer_rate( ULONG_PTR arg )
 {
     LARGE_INTEGER when;
 
-    when.s.LowPart = when.s.HighPart = 0;
+    when.u.LowPart = when.u.HighPart = 0;
     SetWaitableTimer( VGA_timer, &when, arg, VGA_Poll, 0, FALSE );
 }
 
 static DWORD CALLBACK VGA_TimerThread( void *dummy )
 {
-    for (;;) WaitForMultipleObjectsEx( 0, NULL, FALSE, INFINITE, TRUE );
+    for (;;) SleepEx( INFINITE, TRUE );
+    return 0;
 }
 
 static void VGA_DeinstallTimer(void)
 {
     if (VGA_timer_thread)
     {
+        /*
+         * Make sure the update thread is not holding
+         * system resources when we kill it.
+         *
+         * Now, we only need to worry about update thread
+         * getting terminated while in EnterCriticalSection 
+         * or WaitForMultipleObjectsEx.
+         *
+         * FIXME: Is this a problem?
+         */
+        EnterCriticalSection(&vga_lock);
+
         CancelWaitableTimer( VGA_timer );
         CloseHandle( VGA_timer );
         TerminateThread( VGA_timer_thread, 0 );
         CloseHandle( VGA_timer_thread );
         VGA_timer_thread = 0;
+
+        LeaveCriticalSection(&vga_lock);
+
+        /*
+         * Synchronize display. This makes sure that
+         * changes to display become visible even if program 
+         * terminates before update thread had time to run.
+         */
+        VGA_Poll( 0, 0, 0 );
     }
 }
 
@@ -208,16 +717,21 @@ static void VGA_InstallTimer(unsigned Rate)
     QueueUserAPC( set_timer_rate, VGA_timer_thread, (ULONG_PTR)Rate );
 }
 
-HANDLE VGA_AlphaConsole(void)
+static BOOL VGA_IsTimerRunning(void)
+{
+    return VGA_timer_thread ? TRUE : FALSE;
+}
+
+static HANDLE VGA_AlphaConsole(void)
 {
     /* this assumes that no Win32 redirection has taken place, but then again,
      * only 16-bit apps are likely to use this part of Wine... */
     return GetStdHandle(STD_OUTPUT_HANDLE);
 }
 
-char*VGA_AlphaBuffer(void)
+static char*VGA_AlphaBuffer(void)
 {
-    return DOSMEM_MapDosToLinear(0xb8000);
+    return (char *)0xb8000;
 }
 
 /*** GRAPHICS MODE ***/
@@ -227,14 +741,51 @@ typedef struct {
   int ret;
 } ModeSet;
 
+
+/**********************************************************************
+ *         VGA_SyncWindow
+ *
+ * Copy VGA window into framebuffer (if argument is TRUE) or
+ * part of framebuffer into VGA window (if argument is FALSE).
+ */
+static void VGA_SyncWindow( BOOL target_is_fb )
+{
+    int size = vga_fb_window_size;
+
+    /* Window does not overlap framebuffer. */
+    if (vga_fb_window >= vga_fb_size)
+        return;
+
+    /* Check if window overlaps framebuffer only partially. */
+    if (vga_fb_size - vga_fb_window < vga_fb_window_size)
+        size = vga_fb_size - vga_fb_window;
+
+    if (target_is_fb)
+        memmove( vga_fb_data + vga_fb_window, vga_fb_window_data, size );
+    else
+        memmove( vga_fb_window_data, vga_fb_data + vga_fb_window, size );
+}
+
+
+static void WINAPI VGA_DoExit(ULONG_PTR arg)
+{
+    VGA_DeinstallTimer();
+    IDirectDrawSurface_SetPalette(lpddsurf,NULL);
+    IDirectDrawSurface_Release(lpddsurf);
+    lpddsurf=NULL;
+    IDirectDrawPalette_Release(lpddpal);
+    lpddpal=NULL;
+    IDirectDraw_Release(lpddraw);
+    lpddraw=NULL;
+}
+
 static void WINAPI VGA_DoSetMode(ULONG_PTR arg)
 {
-    LRESULT    res;
-    HWND       hwnd;
+    HRESULT    res;
     ModeSet *par = (ModeSet *)arg;
     par->ret=1;
 
-    if (lpddraw) VGA_Exit();
+    if (lpddraw) VGA_DoExit(0);
     if (!lpddraw) {
         if (!pDirectDrawCreate)
         {
@@ -247,47 +798,62 @@ static void WINAPI VGA_DoSetMode(ULONG_PTR arg)
         }
         res = pDirectDrawCreate(NULL,&lpddraw,NULL);
         if (!lpddraw) {
-            ERR("DirectDraw is not available (res = %lx)\n",res);
+            ERR("DirectDraw is not available (res = 0x%x)\n",res);
             return;
         }
-       hwnd = CreateWindowExA(0,"STATIC","WINEDOS VGA",WS_POPUP|WS_BORDER|WS_CAPTION|WS_SYSMENU,0,0,par->Xres,par->Yres,0,0,0,NULL);
-       if (!hwnd) {
-           ERR("Failed to create user window.\n");
-       }
-        if ((res=IDirectDraw_SetCooperativeLevel(lpddraw,hwnd,DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE))) {
-           ERR("Could not set cooperative level to exclusive (%lx)\n",res);
+        if (!vga_hwnd) {
+            vga_hwnd = CreateWindowExA(0,"STATIC","WINEDOS VGA",
+                                       WS_POPUP|WS_VISIBLE|SS_NOTIFY,0,0,
+                                       par->Xres,par->Yres,0,0,0,NULL);
+            if (!vga_hwnd) {
+                ERR("Failed to create user window.\n");
+                IDirectDraw_Release(lpddraw);
+                lpddraw=NULL;
+                return;
+            }
+        }
+        else
+            SetWindowPos(vga_hwnd,0,0,0,par->Xres,par->Yres,SWP_NOMOVE|SWP_NOZORDER);
+
+        res=IDirectDraw_SetCooperativeLevel(lpddraw,vga_hwnd,DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE);
+        if (res != S_OK) {
+           ERR("Could not set cooperative level to exclusive (0x%x)\n",res);
        }
 
-        if ((res=IDirectDraw_SetDisplayMode(lpddraw,par->Xres,par->Yres,par->Depth))) {
-            ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = %lx!\n",par->Xres,par->Yres,par->Depth,res);
+        res=IDirectDraw_SetDisplayMode(lpddraw,par->Xres,par->Yres,par->Depth);
+        if (res != S_OK) {
+            ERR("DirectDraw does not support requested display mode (%dx%dx%d), res = 0x%x!\n",par->Xres,par->Yres,par->Depth,res);
             IDirectDraw_Release(lpddraw);
             lpddraw=NULL;
             return;
         }
 
         res=IDirectDraw_CreatePalette(lpddraw,DDPCAPS_8BIT,NULL,&lpddpal,NULL);
-        if (res) {
-           ERR("Could not create palette (res = %lx)\n",res);
+        if (res != S_OK) {
+           ERR("Could not create palette (res = 0x%x)\n",res);
             IDirectDraw_Release(lpddraw);
             lpddraw=NULL;
             return;
         }
-        if ((res=IDirectDrawPalette_SetEntries(lpddpal,0,0,256,vga_def_palette))) {
-            ERR("Could not set default palette entries (res = %lx)\n", res);
+
+        res=IDirectDrawPalette_SetEntries(lpddpal,0,0,vga_fb_palette_size,vga_fb_palette);
+        if (res != S_OK) {
+           ERR("Could not set default palette entries (res = 0x%x)\n", res);
         }
 
         memset(&sdesc,0,sizeof(sdesc));
         sdesc.dwSize=sizeof(sdesc);
        sdesc.dwFlags = DDSD_CAPS;
        sdesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
-        if (IDirectDraw_CreateSurface(lpddraw,&sdesc,&lpddsurf,NULL)||(!lpddsurf)) {
+        res=IDirectDraw_CreateSurface(lpddraw,&sdesc,&lpddsurf,NULL);
+        if (res != S_OK || !lpddsurf) {
             ERR("DirectDraw surface is not available\n");
             IDirectDraw_Release(lpddraw);
             lpddraw=NULL;
             return;
         }
         IDirectDrawSurface_SetPalette(lpddsurf,lpddpal);
-        vga_refresh=0;
+        vga_retrace_vertical = vga_retrace_horizontal = FALSE;
         /* poll every 20ms (50fps should provide adequate responsiveness) */
         VGA_InstallTimer(20);
     }
@@ -295,23 +861,140 @@ static void WINAPI VGA_DoSetMode(ULONG_PTR arg)
     return;
 }
 
-int VGA_SetMode(unsigned Xres,unsigned Yres,unsigned Depth)
+/**********************************************************************\
+* VGA_GetModeInfo
+*
+* Returns mode information, given mode number
+\**********************************************************************/
+const VGA_MODE *VGA_GetModeInfo(WORD mode)
+{
+    const VGA_MODE *ModeInfo = VGA_modelist;
+
+    /*
+     * Filter out flags.
+     */
+    mode &= 0x17f;
+
+    while (ModeInfo->Mode != 0xffff)
+    {
+        if (ModeInfo->Mode == mode)
+            return ModeInfo;
+        ModeInfo++;
+    }
+    return NULL;
+}
+
+const VGA_MODE *VGA_GetModeInfoList(void)
+{
+    return VGA_modelist;
+}
+
+int VGA_SetMode(WORD mode)
+{
+    const VGA_MODE *ModeInfo;
+    /* get info on VGA mode & set appropriately */
+    VGA_CurrentMode = mode;
+    ModeInfo = VGA_GetModeInfo(VGA_CurrentMode);
+
+    /* check if mode is supported */
+    if (ModeInfo->Supported)
+    {
+       FIXME("Setting VGA mode %i - Supported mode - Improve reporting of missing capabilities for modes & modetypes.\n", mode);
+    }
+    else
+    {
+       FIXME("Setting VGA mode %i - Unsupported mode - Will doubtfully work at all, but we'll try anyways.\n", mode);
+    }
+
+    /* set up graphic or text display */
+    if (ModeInfo->ModeType == TEXT)
+    {
+       VGA_SetAlphaMode(ModeInfo->TextCols, ModeInfo->TextRows);
+    }
+    else
+    {
+       return VGA_SetGraphicMode(mode);
+    }
+    return 0; /* assume all good & return zero */
+}
+
+int VGA_SetGraphicMode(WORD mode)
 {
     ModeSet par;
+    int     newSize;
+
+    /* get info on VGA mode & set appropriately */
+    const VGA_MODE *ModeInfo = VGA_GetModeInfo(VGA_CurrentMode);
+    /* check if we're assuming composite display */
+    if ((mode == 6) && (CGA_ColorComposite))
+    {
+       vga_fb_width = (ModeInfo->Width / 4);
+       vga_fb_height = ModeInfo->Height;
+       vga_fb_depth = (ModeInfo->Depth * 4);
+    }
+    else
+    {
+       vga_fb_width = ModeInfo->Width;
+       vga_fb_height = ModeInfo->Height;
+       vga_fb_depth = ModeInfo->Depth;
+    }
+    vga_fb_offset = 0;
+    vga_fb_pitch = vga_fb_width * ((vga_fb_depth + 7) / 8);
 
-    vga_width = Xres;
-    vga_height = Yres;
-    vga_depth = Depth;
+    newSize = vga_fb_width * vga_fb_height * ((vga_fb_depth + 7) / 8);
+    if(newSize < 256 * 1024)
+      newSize = 256 * 1024;
+
+    if(vga_fb_size < newSize) {
+      HeapFree(GetProcessHeap(), 0, vga_fb_data);
+      vga_fb_data = HeapAlloc(GetProcessHeap(), 0, newSize);
+      vga_fb_size = newSize;
+    }
 
-    if(Xres >= 640 || Yres >= 480) {
-      par.Xres = Xres;
-      par.Yres = Yres;
+    if(vga_fb_width >= 640 || vga_fb_height >= 480) {
+      par.Xres = vga_fb_width;
+      par.Yres = vga_fb_height;
     } else {
       par.Xres = 640;
       par.Yres = 480;
     }
 
-    par.Depth = (Depth < 8) ? 8 : Depth;
+    /* Setup window */
+    if(vga_fb_depth >= 8)
+    {
+      vga_fb_window_data = VGA_WINDOW_START;
+      vga_fb_window_size = VGA_WINDOW_SIZE;
+      vga_fb_palette = vga_def_palette;
+      vga_fb_palette_size = 256;
+    }
+    else
+    {
+      vga_fb_window_data = CGA_WINDOW_START;
+      vga_fb_window_size = CGA_WINDOW_SIZE;
+      if(vga_fb_depth == 2)
+      {
+        /* Select default 2 bit CGA palette */
+        vga_fb_palette = cga_palette1;
+        vga_fb_palette_size = 4;
+      }
+      else
+      {
+        /* Top of VGA palette is same as 4 bit CGA palette */
+        vga_fb_palette = vga_def_palette;
+        vga_fb_palette_size = 16;
+      }
+
+      vga_fb_palette_index = 0;
+      vga_fb_bright = 0;
+    }
+
+    /* Clean the HW buffer */
+    memset(vga_fb_window_data, 0x00, vga_fb_window_size);
+
+    /* Reset window start */
+    VGA_SetWindowStart(0);
+
+    par.Depth = (vga_fb_depth < 8) ? 8 : vga_fb_depth;
 
     MZ_RunInThread(VGA_DoSetMode, (ULONG_PTR)&par);
     return par.ret;
@@ -327,19 +1010,7 @@ int VGA_GetMode(unsigned*Height,unsigned*Width,unsigned*Depth)
     return 0;
 }
 
-static void WINAPI VGA_DoExit(ULONG_PTR arg)
-{
-    VGA_DeinstallTimer();
-    IDirectDrawSurface_SetPalette(lpddsurf,NULL);
-    IDirectDrawSurface_Release(lpddsurf);
-    lpddsurf=NULL;
-    IDirectDrawPalette_Release(lpddpal);
-    lpddpal=NULL;
-    IDirectDraw_Release(lpddraw);
-    lpddraw=NULL;
-}
-
-void VGA_Exit(void)
+static void VGA_Exit(void)
 {
     if (lpddraw) MZ_RunInThread(VGA_DoExit, 0);
 }
@@ -350,7 +1021,7 @@ void VGA_SetPalette(PALETTEENTRY*pal,int start,int len)
     IDirectDrawPalette_SetEntries(lpddpal,0,start,len,pal);
 }
 
-/* set a single color in 16 color mode. */
+/* set a single [char wide] color in 16 color mode. */
 void VGA_SetColor16(int reg,int color)
 {
        PALETTEENTRY *pal;
@@ -361,26 +1032,43 @@ void VGA_SetColor16(int reg,int color)
        vga_16_palette[reg]=(char)color;
 }
 
-void VGA_SetQuadPalette(RGBQUAD*color,int start,int len)
+/* Get a single [char wide] color in 16 color mode. */
+char VGA_GetColor16(int reg)
 {
-    PALETTEENTRY pal[256];
-    int c;
 
-    if (!lpddraw) return;
-    for (c=0; c<len; c++) {
-        pal[c].peRed  =color[c].rgbRed;
-        pal[c].peGreen=color[c].rgbGreen;
-        pal[c].peBlue =color[c].rgbBlue;
-        pal[c].peFlags=0;
-    }
-    IDirectDrawPalette_SetEntries(lpddpal,0,start,len,pal);
+    if (!lpddraw) return 0;
+       return vga_16_palette[reg];
+}
+
+/* set all 17 [char wide] colors at once in 16 color mode. */
+void VGA_Set16Palette(char *Table)
+{
+       PALETTEENTRY *pal;
+       int c;
+
+    if (!lpddraw) return;         /* return if we're in text only mode */
+    memcpy( Table, vga_16_palette, 17 ); /* copy the entries into the table */
+
+    for (c=0; c<17; c++) {                                /* 17 entries */
+       pal= &vga_def64_palette[(int)vga_16_palette[c]];  /* get color  */
+        IDirectDrawPalette_SetEntries(lpddpal,0,c,1,pal); /* set entry  */
+       TRACE("Palette register %d set to %d\n",c,(int)vga_16_palette[c]);
+   } /* end of the counting loop */
+}
+
+/* Get all 17 [ char wide ] colors at once in 16 color mode. */
+void VGA_Get16Palette(char *Table)
+{
+
+    if (!lpddraw) return;         /* return if we're in text only mode */
+    memcpy( vga_16_palette, Table, 17 ); /* copy the entries into the table */
 }
 
-LPSTR VGA_Lock(unsigned*Pitch,unsigned*Height,unsigned*Width,unsigned*Depth)
+static LPSTR VGA_Lock(unsigned*Pitch,unsigned*Height,unsigned*Width,unsigned*Depth)
 {
     if (!lpddraw) return NULL;
     if (!lpddsurf) return NULL;
-    if (IDirectDrawSurface_Lock(lpddsurf,NULL,&sdesc,0,0)) {
+    if (IDirectDrawSurface_Lock(lpddsurf,NULL,&sdesc,0,0) != S_OK) {
         ERR("could not lock surface!\n");
         return NULL;
     }
@@ -391,162 +1079,651 @@ LPSTR VGA_Lock(unsigned*Pitch,unsigned*Height,unsigned*Width,unsigned*Depth)
     return sdesc.lpSurface;
 }
 
-void VGA_Unlock(void)
+static void VGA_Unlock(void)
 {
     IDirectDrawSurface_Unlock(lpddsurf,sdesc.lpSurface);
 }
 
-/*** TEXT MODE ***/
+/*
+ * Set start of 64k window at 0xa0000 in bytes.
+ * If value is -1, initialize color plane support.
+ * If value is >= 0, window contains direct copy of framebuffer.
+ */
+void VGA_SetWindowStart(int start)
+{
+    if(start == vga_fb_window)
+        return;
+
+    EnterCriticalSection(&vga_lock);
+
+    if(vga_fb_window == -1)
+        FIXME("Remove VGA memory emulation.\n");
+    else
+        VGA_SyncWindow( TRUE );
+
+    vga_fb_window = start;
+
+    if(vga_fb_window == -1)
+        FIXME("Install VGA memory emulation.\n");
+    else
+        VGA_SyncWindow( FALSE );
+
+    LeaveCriticalSection(&vga_lock);
+}
 
-int VGA_SetAlphaMode(unsigned Xres,unsigned Yres)
+/*
+ * Get start of 64k window at 0xa0000 in bytes.
+ * Value is -1 in color plane modes.
+ */
+int VGA_GetWindowStart(void)
 {
-    COORD siz;
+    return vga_fb_window;
+}
 
-    if (lpddraw) VGA_Exit();
 
-    /* the xterm is slow, so refresh only every 200ms (5fps) */
-    VGA_InstallTimer(200);
+/**********************************************************************
+ *         VGA_DoShowMouse
+ *
+ * Callback for VGA_ShowMouse.
+ */
+static void WINAPI VGA_DoShowMouse( ULONG_PTR show )
+{
+    INT rv;
 
-    siz.X = Xres;
-    siz.Y = Yres;
-    SetConsoleScreenBufferSize(VGA_AlphaConsole(),siz);
-    return 0;
+    do
+    {
+        rv = ShowCursor( show );
+    }
+    while( show ? (rv < 0) : (rv >= 0) );
+}
+
+
+/**********************************************************************
+ *         VGA_ShowMouse
+ *
+ * If argument is TRUE, unconditionally show mouse cursor.
+ * If argument is FALSE, unconditionally hide mouse cursor.
+ * This only works in graphics mode.
+ */
+void VGA_ShowMouse( BOOL show )
+{
+    if (lpddraw)
+        MZ_RunInThread( VGA_DoShowMouse, (ULONG_PTR)show );
+}
+
+
+/**********************************************************************
+ *         VGA_UpdatePalette
+ *
+ * Update the current palette
+ *
+ * Note: When updating the current CGA palette, palette index 0
+ * refers to palette2, and index 1 is palette1 (default palette)
+ */
+void VGA_UpdatePalette(void)
+{
+  /* Figure out which palette is used now */
+  if(vga_fb_bright == TRUE)
+  {
+    if(vga_fb_palette_index == 0)
+    {
+      vga_fb_palette = cga_palette2_bright;
+    }
+    else if(vga_fb_palette_index == 1)
+    {
+      vga_fb_palette = cga_palette1_bright;
+    }
+  }
+  else
+  {
+    if(vga_fb_palette_index == 0)
+    {
+      vga_fb_palette = cga_palette2;
+    }
+    else if(vga_fb_palette_index == 1)
+    {
+      vga_fb_palette = cga_palette1;
+    }
+  }
+
+  /* Now update the palette */
+  VGA_SetPalette(vga_fb_palette,0,4);
+}
+
+/**********************************************************************
+ *         VGA_SetBright
+ *
+ * Select if using a "bright" palette or not.
+ * This is a property of the CGA controller
+ */
+void VGA_SetBright(BOOL bright)
+{
+  TRACE("%i\n", bright);
+
+  /* Remember the "bright" value used by the CGA controller */
+  vga_fb_bright = bright;
+}
+
+/**********************************************************************
+ *         VGA_SetEnabled
+ *
+ * Select if output is enabled or disabled
+ * This is a property of the CGA controller
+ */
+static void VGA_SetEnabled(BOOL enabled)
+{
+  TRACE("%i\n", enabled);
+
+  /* Check if going from enabled to disabled */
+  if(vga_fb_enabled == TRUE && enabled == FALSE)
+  {
+    /* Clear frame buffer */
+    memset(vga_fb_window_data, 0x00, vga_fb_window_size);
+  }
+
+  /* Remember the "enabled" value */
+  vga_fb_enabled = enabled;
+}
+
+/**********************************************************************
+ *         VGA_SetPaletteIndex
+ *
+ * Select the index of the palette which is currently in use
+ * This is a property of the CGA controller
+ */
+void VGA_SetPaletteIndex(unsigned index)
+{
+  TRACE("%i\n", index);
+
+  /* Remember the palette index, which is only used by CGA for now */
+  vga_fb_palette_index = index;
 }
 
-void VGA_GetAlphaMode(unsigned*Xres,unsigned*Yres)
+/**********************************************************************
+ *         VGA_WritePixel
+ *
+ * Write data to the framebuffer
+ * This is a property of the CGA controller, but might be supported
+ * later by other framebuffer types
+ */
+void VGA_WritePixel(unsigned color, unsigned page, unsigned col, unsigned row)
+{
+  int off;
+  int bits;
+  int pos;
+
+  /* Calculate CGA byte offset */
+  char *data = vga_fb_window_data;
+  off = row & 1 ? (8 * 1024) : 0;
+  off += (80 * (row/2));
+  off += col/4;
+
+  /* Calculate bits offset */
+  pos = 6 - (col%4 * 2);
+
+  /* Clear current data */
+  bits = 0x03 << pos;
+  data[off] &= ~bits;
+
+  /* Set new data */
+  bits = color << pos;
+  data[off] |= bits;
+}
+
+/*** TEXT MODE ***/
+
+/* prepare the text mode video memory copy that is used to only
+ * update the video memory line that did get updated. */
+static void VGA_PrepareVideoMemCopy(unsigned Xres, unsigned Yres)
+{
+    char *p, *p2;
+    unsigned int i;
+
+    /*
+     * Allocate space for char + attr.
+     */
+
+    if (vga_text_old)
+        vga_text_old = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 
+                                vga_text_old, Xres * Yres * 2 );
+    else
+        vga_text_old = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 
+                                 Xres * Yres * 2 );
+    p = VGA_AlphaBuffer();
+    p2 = vga_text_old;
+
+    /* make sure the video mem copy contains the exact opposite of our
+     * actual text mode memory area to make sure the screen
+     * does get updated fully initially */
+    for (i=0; i < Xres*Yres*2; i++)
+       *p2++ = *p++ ^ 0xff; /* XOR it */
+}
+
+/**********************************************************************
+ *         VGA_SetAlphaMode
+ *
+ * Set VGA emulation to text mode.
+ */
+void VGA_SetAlphaMode(unsigned Xres,unsigned Yres)
+{
+    VGA_Exit();
+    VGA_DeinstallTimer();
+    
+    VGA_PrepareVideoMemCopy(Xres, Yres);
+    vga_text_width = Xres;
+    vga_text_height = Yres;
+
+    if (vga_text_x >= vga_text_width || vga_text_y >= vga_text_height)
+        VGA_SetCursorPos(0,0);
+
+    if(vga_text_console) {
+        COORD size;
+        size.X = Xres;
+        size.Y = Yres;
+        SetConsoleScreenBufferSize( VGA_AlphaConsole(), size );
+
+        /* poll every 30ms (33fps should provide adequate responsiveness) */
+        VGA_InstallTimer(30);
+    }
+}
+
+/**********************************************************************
+ *         VGA_InitAlphaMode
+ *
+ * Initialize VGA text mode handling and return default text mode.
+ * This function does not set VGA emulation to text mode.
+ */
+void VGA_InitAlphaMode(unsigned*Xres,unsigned*Yres)
 {
     CONSOLE_SCREEN_BUFFER_INFO info;
-    GetConsoleScreenBufferInfo(VGA_AlphaConsole(),&info);
-    if (Xres) *Xres=info.dwSize.X;
-    if (Yres) *Yres=info.dwSize.Y;
+
+    if(GetConsoleScreenBufferInfo( VGA_AlphaConsole(), &info ))
+    {
+        vga_text_console = TRUE;
+        vga_text_x = info.dwCursorPosition.X;
+        vga_text_y = info.dwCursorPosition.Y;
+        vga_text_attr = info.wAttributes;
+        *Xres = info.dwSize.X;
+        *Yres = info.dwSize.Y;
+    } 
+    else
+    {
+        vga_text_console = FALSE;
+        vga_text_x = 0;
+        vga_text_y = 0;
+        vga_text_attr = 0x0f;
+        *Xres = 80;
+        *Yres = 25;
+    }
 }
 
-void VGA_SetCursorPos(unsigned X,unsigned Y)
+/**********************************************************************
+ *         VGA_GetAlphaMode
+ *
+ * Get current text mode. Returns TRUE and sets resolution if
+ * any VGA text mode has been initialized.
+ */
+BOOL VGA_GetAlphaMode(unsigned*Xres,unsigned*Yres)
+{
+    if (vga_text_width != 0 && vga_text_height != 0) {
+        *Xres = vga_text_width;
+        *Yres = vga_text_height;
+        return TRUE;
+    } else
+        return FALSE;
+}
+
+void VGA_SetCursorShape(unsigned char start_options, unsigned char end)
 {
-    COORD pos;
+    CONSOLE_CURSOR_INFO cci;
 
-    if (!poll_timer) VGA_SetAlphaMode(80, 25);
-    pos.X = X;
-    pos.Y = Y;
-    SetConsoleCursorPosition(VGA_AlphaConsole(),pos);
+    /* standard cursor settings:
+     * 0x0607 == CGA, 0x0b0c == monochrome, 0x0d0e == EGA/VGA */
+
+    /* calculate percentage from bottom - assuming VGA (bottom 0x0e) */
+    cci.dwSize = ((end & 0x1f) - (start_options & 0x1f))/0x0e * 100;
+    if (!cci.dwSize) cci.dwSize++; /* NULL cursor would make SCCI() fail ! */
+    cci.bVisible = ((start_options & 0x60) != 0x20); /* invisible ? */
+
+    SetConsoleCursorInfo(VGA_AlphaConsole(),&cci);
+}
+
+void VGA_SetCursorPos(unsigned X,unsigned Y)
+{
+    vga_text_x = X;
+    vga_text_y = Y;
 }
 
 void VGA_GetCursorPos(unsigned*X,unsigned*Y)
 {
-    CONSOLE_SCREEN_BUFFER_INFO info;
-    GetConsoleScreenBufferInfo(VGA_AlphaConsole(),&info);
-    if (X) *X=info.dwCursorPosition.X;
-    if (Y) *Y=info.dwCursorPosition.Y;
+    if (X) *X = vga_text_x;
+    if (Y) *Y = vga_text_y;
+}
+
+static void VGA_PutCharAt(unsigned x, unsigned y, BYTE ascii, int attr)
+{
+    const VGA_MODE *ModeInfo = VGA_GetModeInfo(VGA_CurrentMode);
+    if ( ModeInfo->ModeType == TEXT )
+    {
+       char *dat = VGA_AlphaBuffer() + ((vga_text_width * y + x) * 2);
+       dat[0] = ascii;
+       if (attr>=0)
+          dat[1] = attr;
+    }
+    else
+    {
+       FIXME("Write %c at (%i,%i) - not yet supported in graphic modes.\n", (char)ascii, x, y);
+    }
 }
 
 void VGA_WriteChars(unsigned X,unsigned Y,unsigned ch,int attr,int count)
 {
-    unsigned XR, YR;
-    char*dat;
+    EnterCriticalSection(&vga_lock);
+
+    while (count--) 
+        VGA_PutCharAt(X + count, Y, ch, attr);
+
+    LeaveCriticalSection(&vga_lock);
+}
+
+void VGA_PutChar(BYTE ascii)
+{
+    DWORD w;
+
+    EnterCriticalSection(&vga_lock);
+
+    switch(ascii) {
+    case '\b':
+        if (vga_text_x)
+        {
+            vga_text_x--;
+            VGA_PutCharAt(vga_text_x, vga_text_y, ' ', 0);
+        }
+        break;
+
+    case '\t':
+        vga_text_x += ((vga_text_x + 8) & ~7) - vga_text_x;
+        break;
+
+    case '\n':
+        vga_text_y++;
+        vga_text_x = 0;
+        break;
+
+    case '\a':
+        break;
+
+    case '\r':
+        vga_text_x = 0;
+        break;
+
+    default:
+        VGA_PutCharAt(vga_text_x, vga_text_y, ascii, vga_text_attr);
+        vga_text_x++;
+    }
+
+    if (vga_text_x >= vga_text_width)
+    {
+        vga_text_x = 0;
+        vga_text_y++;
+    }
 
-    VGA_GetAlphaMode(&XR, &YR);
-    dat = VGA_AlphaBuffer() + ((XR*Y + X) * 2);
-    /* FIXME: also call WriteConsoleOutputA, for better responsiveness */
-    while (count--) {
-        *dat++ = ch;
-        if (attr>=0) *dat = attr;
-        dat++;
+    if (vga_text_y >= vga_text_height)
+    {
+        vga_text_y = vga_text_height - 1;
+        VGA_ScrollUpText( 0, 0, 
+                          vga_text_height - 1, vga_text_width - 1, 
+                          1, vga_text_attr );
     }
+
+    /*
+     * If we don't have a console, write directly to standard output.
+     */
+    if(!vga_text_console)
+        WriteFile(VGA_AlphaConsole(), &ascii, 1, &w, NULL);
+
+    LeaveCriticalSection(&vga_lock);
+}
+
+void VGA_ClearText(unsigned row1, unsigned col1,
+                   unsigned row2, unsigned col2,
+                   BYTE attr)
+{
+    unsigned x, y;
+
+    EnterCriticalSection(&vga_lock);
+
+    for(y=row1; y<=row2; y++)
+        for(x=col1; x<=col2; x++)
+            VGA_PutCharAt(x, y, 0x20, attr);
+
+    LeaveCriticalSection(&vga_lock);
+}
+
+void VGA_ScrollUpText(unsigned row1,  unsigned col1,
+                      unsigned row2,  unsigned col2,
+                      unsigned lines, BYTE attr)
+{
+    char    *buffer = VGA_AlphaBuffer();
+    unsigned y;
+
+    EnterCriticalSection(&vga_lock);
+
+    /*
+     * Scroll buffer.
+     */
+    for (y = row1; y <= row2 - lines; y++)
+        memmove( buffer + col1 + y * vga_text_width * 2,
+                 buffer + col1 + (y + lines) * vga_text_width * 2,
+                 (col2 - col1 + 1) * 2 );
+
+    /*
+     * Fill exposed lines.
+     */
+    for (y = max(row1, row2 - lines + 1); y <= row2; y++)
+        VGA_WriteChars( col1, y, ' ', attr, col2 - col1 + 1 );
+
+    LeaveCriticalSection(&vga_lock);
+}
+
+void VGA_ScrollDownText(unsigned row1,  unsigned col1,
+                        unsigned row2,  unsigned col2,
+                        unsigned lines, BYTE attr)
+{
+    char    *buffer = VGA_AlphaBuffer();
+    unsigned y;
+
+    EnterCriticalSection(&vga_lock);
+
+    /*
+     * Scroll buffer.
+     */
+    for (y = row2; y >= row1 + lines; y--)
+        memmove( buffer + col1 + y * vga_text_width * 2,
+                 buffer + col1 + (y - lines) * vga_text_width * 2,
+                 (col2 - col1 + 1) * 2 );
+
+    /*
+     * Fill exposed lines.
+     */
+    for (y = row1; y <= min(row1 + lines - 1, row2); y++)
+        VGA_WriteChars( col1, y, ' ', attr, col2 - col1 + 1 );
+
+    LeaveCriticalSection(&vga_lock);
+}
+
+void VGA_GetCharacterAtCursor(BYTE *ascii, BYTE *attr)
+{
+    char *dat;
+
+    dat = VGA_AlphaBuffer() + ((vga_text_width * vga_text_y + vga_text_x) * 2);
+
+    *ascii = dat[0];
+    *attr = dat[1];
 }
 
+
 /*** CONTROL ***/
 
+/* FIXME: optimize by doing this only if the data has actually changed
+ *        (in a way similar to DIBSection, perhaps) */
 static void VGA_Poll_Graphics(void)
 {
   unsigned int Pitch, Height, Width, X, Y;
   char *surf;
-  char *dat = DOSMEM_MapDosToLinear(0xa0000);
+  char *dat = vga_fb_data + vga_fb_offset;
+  int   bpp = (vga_fb_depth + 7) / 8;
 
   surf = VGA_Lock(&Pitch,&Height,&Width,NULL);
   if (!surf) return;
 
-  if(vga_width == 320 && vga_depth <= 4)
-    for (Y=0; Y<vga_height; Y++,surf+=Pitch*2,dat+=vga_width/8) {
-      for(X=0; X<vga_width; X+=8) {
-       int offset = X/8;
-       int Z;
-       for(Z=0; Z<8; Z++) {
-         int b0 =  (dat[offset] >> Z) & 0x1;
-         int index = 7-Z;
-         surf[(X+index)*2] = b0;
-         surf[(X+index)*2+1] = b0;
-         surf[(X+index)*2+Pitch] = b0;
-         surf[(X+index)*2+Pitch+1] = b0;
-       }
+  /*
+   * Synchronize framebuffer contents.
+   */
+  if (vga_fb_window != -1)
+      VGA_SyncWindow( TRUE );
+
+  /*
+   * CGA framebuffer (160x200) - CGA_ColorComposite, special subtype of mode 6
+   * This buffer is encoded as following:
+   * - 4 bit pr. pixel, 2 pixels per byte
+   * - 80 bytes per row
+   * - Every second line has an offset of 8096
+   */
+  if(vga_fb_depth == 4 && vga_fb_width == 160 && vga_fb_height == 200){
+    WORD off = 0;
+    BYTE bits = 4;
+    BYTE value;
+    for(Y=0; Y<vga_fb_height; Y++, surf+=(Pitch*2)){
+      for(X=0; X<vga_fb_width; X++){
+        off = Y & 1 ? (8 * 1024) : 0;
+        off += (80 * (Y/2));
+        off += X/2;
+        value = (dat[off] >> bits) & 0xF;
+        surf[(X*4)+0] = value;
+        surf[(X*4)+1] = value;
+        surf[(X*4)+2] = value;
+        surf[(X*4)+3] = value;
+        surf[(X*4)+Pitch+0] = value;
+        surf[(X*4)+Pitch+1] = value;
+        surf[(X*4)+Pitch+2] = value;
+        surf[(X*4)+Pitch+3] = value;
+        bits -= 4;
+        bits &= 7;
       }
     }
-
-  if(vga_width == 320 && vga_depth == 8)
-    for (Y=0; Y<vga_height; Y++,surf+=Pitch*2,dat+=vga_width) {
-      for(X=0; X<vga_width; X++) {
-       int b0 = dat[X];
-       surf[X*2] = b0;
-       surf[X*2+1] = b0;
-       surf[X*2+Pitch] = b0;
-       surf[X*2+Pitch+1] = b0;
+  }
+
+  /*
+   * CGA framebuffer (320x200)
+   * This buffer is encoded as following:
+   * - 2 bits per color, 4 pixels per byte
+   * - 80 bytes per row
+   * - Every second line has an offset of 8096
+   */
+  else if(vga_fb_depth == 2 && vga_fb_width == 320 && vga_fb_height == 200){
+    WORD off = 0;
+    BYTE bits = 6;
+    BYTE value;
+    /* Go thru rows */
+    for(Y=0; Y<vga_fb_height; Y++, surf+=(Pitch*2)){
+      for(X=0; X<vga_fb_width; X++){
+        off = Y & 1 ? (8 * 1024) : 0;
+        off += (80 * (Y/2));
+        off += X/4;
+        value = (dat[off] >> bits) & 0x3;
+        surf[(X*2)] = value;
+        surf[(X*2)+1] = value;
+        surf[(X*2)+Pitch] = value;
+        surf[(X*2)+Pitch+1] = value;
+        bits -= 2;
+        bits &= 7;
       }
     }
-
-  if(vga_depth <= 4)
-    for (Y=0; Y<vga_height; Y++,surf+=Pitch,dat+=vga_width/8) {
-      for(X=0; X<vga_width; X+=8) {
-       int offset = X/8;
-       int Z;
-       for(Z=0; Z<8; Z++) {
-         int b0 =  (dat[offset] >> Z) & 0x1;
-         int index = 7-Z;
-         surf[X+index] = b0;
-       }
+  }
+
+  /*
+   * Double VGA framebuffer (320x200 -> 640x400), if needed.
+   */
+  else if(Height >= 2 * vga_fb_height && Width >= 2 * vga_fb_width && bpp == 1)
+    for (Y=0; Y<vga_fb_height; Y++,surf+=Pitch*2,dat+=vga_fb_pitch)
+      for (X=0; X<vga_fb_width; X++) {
+       BYTE value = dat[X];
+       surf[X*2] = value;
+       surf[X*2+1] = value;
+       surf[X*2+Pitch] = value;
+       surf[X*2+Pitch+1] = value;
       }
-    }
+  /*
+   * Linear Buffer, including mode 19
+   */
+  else
+    for (Y=0; Y<vga_fb_height; Y++,surf+=Pitch,dat+=vga_fb_pitch)
+      memcpy(surf, dat, vga_fb_width * bpp);
 
   VGA_Unlock();
 }
 
+static void VGA_Poll_Text(void)
+{
+    char *dat, *old, *p_line;
+    unsigned int X, Y;
+    CHAR_INFO ch[256]; /* that should suffice for the largest text width */
+    COORD siz, off;
+    SMALL_RECT dest;
+    HANDLE con = VGA_AlphaConsole();
+    BOOL linechanged = FALSE; /* video memory area differs from stored copy? */
+
+    /* Synchronize cursor position. */
+    off.X = vga_text_x;
+    off.Y = vga_text_y;
+    SetConsoleCursorPosition(con,off);
+
+    dat = VGA_AlphaBuffer();
+    old = vga_text_old; /* pointer to stored video mem copy */
+    siz.X = vga_text_width; siz.Y = 1;
+    off.X = 0; off.Y = 0;
+
+    /* copy from virtual VGA frame buffer to console */
+    for (Y=0; Y<vga_text_height; Y++) {
+       linechanged = memcmp(dat, old, vga_text_width*2);
+       if (linechanged)
+       {
+           /*TRACE("line %d changed\n", Y);*/
+           p_line = dat;
+            for (X=0; X<vga_text_width; X++) {
+                ch[X].Char.AsciiChar = *p_line++;
+                /* WriteConsoleOutputA doesn't like "dead" chars */
+                if (ch[X].Char.AsciiChar == '\0')
+                    ch[X].Char.AsciiChar = ' ';
+                ch[X].Attributes = *p_line++;
+            }
+            dest.Top=Y; dest.Bottom=Y;
+            dest.Left=0; dest.Right=vga_text_width+1;
+            WriteConsoleOutputA(con, ch, siz, off, &dest);
+           memcpy(old, dat, vga_text_width*2);
+       }
+       /* advance to next text line */
+       dat += vga_text_width*2;
+       old += vga_text_width*2;
+    }
+}
 
 static void CALLBACK VGA_Poll( LPVOID arg, DWORD low, DWORD high )
 {
-    char *dat;
-    unsigned int Height,Width,Y,X;
-
-    if (!InterlockedExchangeAdd(&vga_polling, 1)) {
-        /* FIXME: optimize by doing this only if the data has actually changed
-         *        (in a way similar to DIBSection, perhaps) */
-        if (lpddraw) {
-         VGA_Poll_Graphics();
-        } else {
-          /* text mode */
-          CHAR_INFO ch[80];
-          COORD siz, off;
-          SMALL_RECT dest;
-          HANDLE con = VGA_AlphaConsole();
-
-          VGA_GetAlphaMode(&Width,&Height);
-          dat = VGA_AlphaBuffer();
-          siz.X = 80; siz.Y = 1;
-          off.X = 0; off.Y = 0;
-          /* copy from virtual VGA frame buffer to console */
-          for (Y=0; Y<Height; Y++) {
-              dest.Top=Y; dest.Bottom=Y;
-              for (X=0; X<Width; X++) {
-                  ch[X].Char.AsciiChar = *dat++;
-                 /* WriteConsoleOutputA doesn't like "dead" chars */
-                 if (ch[X].Char.AsciiChar == '\0')
-                     ch[X].Char.AsciiChar = ' ';
-                  ch[X].Attributes = *dat++;
-              }
-              dest.Left=0; dest.Right=Width+1;
-              WriteConsoleOutputA(con, ch, siz, off, &dest);
-          }
-        }
-        vga_refresh=1;
-    }
-    InterlockedDecrement(&vga_polling);
+    EnterCriticalSection(&vga_lock);
+
+    if (lpddraw)
+        VGA_Poll_Graphics();
+    else
+        VGA_Poll_Text();
+
+    /*
+     * Fake start of retrace.
+     */
+    vga_retrace_vertical = TRUE;
+
+    LeaveCriticalSection(&vga_lock);
 }
 
 static BYTE palreg,palcnt;
@@ -555,6 +1732,45 @@ static PALETTEENTRY paldat;
 void VGA_ioport_out( WORD port, BYTE val )
 {
     switch (port) {
+        /* General Register - Feature Control */
+        case 0x3ba:
+           FIXME("Unsupported VGA register: general register - feature control 0x%04x (value 0x%02x)\n", port, val);
+           break;
+        /* Attribute Controller - Address/Other */
+        case 0x3c0:
+           if (vga_address_3c0)
+               vga_index_3c0 = val;
+           else
+               FIXME("Unsupported index, VGA attribute controller register 0x3c0: 0x%02x (value 0x%02x)\n",
+                     vga_index_3c0, val);
+           vga_address_3c0 = !vga_address_3c0;
+           break;
+        /* General Register - Misc output */
+        case 0x3c2:
+           FIXME("Unsupported VGA register: general register - misc output 0x%04x (value 0x%02x)\n", port, val);
+           break;
+        /* General Register - Video subsystem enable */
+        case 0x3c3:
+           FIXME("Unsupported VGA register: general register - video subsystem enable 0x%04x (value 0x%02x)\n", port, val);
+           break;
+        /* Sequencer Register - Address */
+        case 0x3c4:
+           vga_index_3c4 = val;
+           break;
+        /* Sequencer Register - Other */
+        case 0x3c5:
+          switch(vga_index_3c4) {
+               case 0x04: /* Sequencer: Memory Mode Register */
+                  if(vga_fb_depth == 8)
+                      VGA_SetWindowStart((val & 8) ? 0 : -1);
+                  else
+                      FIXME("Memory Mode Register not supported in this mode.\n");
+                  break;
+               default:
+                  FIXME("Unsupported index, VGA sequencer register 0x3c4: 0x%02x (value 0x%02x)\n",
+                        vga_index_3c4, val);
+           }
+           break;
         case 0x3c8:
             palreg=val; palcnt=0; break;
         case 0x3c9:
@@ -564,6 +1780,126 @@ void VGA_ioport_out( WORD port, BYTE val )
                 palcnt=0;
             }
             break;
+        /* Graphics Controller Register - Address */
+        case 0x3ce:
+            vga_index_3ce = val;
+           break;
+        /* Graphics Controller Register - Other */
+        case 0x3cf:
+           FIXME("Unsupported index, VGA graphics controller register - other 0x3ce: 0x%02x (value 0x%02x)\n",
+                 vga_index_3ce, val);
+           break;
+        /* CRT Controller Register - Index (MDA) */
+        case 0x3b4:
+        /* CRT Controller Register - Index (CGA) */
+        case 0x3d4:
+           vga_index_3d4 = val;
+           break;
+        /* CRT Controller Register - Other (MDA) */
+        case 0x3b5:
+        /* CRT Controller Register - Other (CGA) */
+        case 0x3d5:
+           FIXME("Unsupported index, VGA crt controller register 0x3b4/0x3d4: 0x%02x (value 0x%02x)\n",
+                 vga_index_3d4, val);
+           break;
+        /* Mode control register - 6845 Motorola (MDA) */
+        case 0x3b8:
+        /* Mode control register - 6845 Motorola (CGA) */
+        case 0x3d8:
+           /*
+            *  xxxxxxx1 = 80x25 text
+            *  xxxxxxx0 = 40x25 text (default)
+            *  xxxxxx1x = graphics (320x200)
+            *  xxxxxx0x = text
+            *  xxxxx1xx = B/W
+            *  xxxxx0xx = color
+            *  xxxx1xxx = enable video signal
+            *  xxx1xxxx = 640x200 B/W graphics
+            *  xx1xxxxx = blink
+            */
+
+           /* check bits 6 and 7 */
+           if (val & 0xC0)
+           {
+              FIXME("Unsupported value, VGA register 0x3d8: 0x%02x - bits 7 and 6 not supported.\n", val);
+           }
+           /* check bits 5 - blink on */
+           if (val & 0x20)
+           {
+              FIXME("Unsupported value, VGA register 0x3d8: 0x%02x (bit 5) - blink is not supported.\n", val);
+           }
+           /* Enable Video Signal (bit 3) - Set the enabled bit */
+           VGA_SetEnabled((val & 0x08) && 1);
+
+           /* xxx1x010 - Detect 160x200, 16 color mode (CGA composite) */
+           if( (val & 0x17) == 0x12 )
+           {
+             /* Switch to 160x200x4 composite mode - special case of mode 6 */
+             CGA_ColorComposite = TRUE;
+             VGA_SetMode(6);
+           }
+           else
+           {
+             /* turn off composite colors otherwise, including 320x200 (80x200 16 color) */
+             CGA_ColorComposite = FALSE;
+           }
+
+           /* xxx0x100 - Detect VGA mode 0 */
+           if( (val & 0x17) == 0x04 )
+           {
+             VGA_SetMode(0);
+           }
+           /* xxx0x000 - Detect VGA mode 1 */
+           else if( (val & 0x17) == 0x00 )
+           {
+             VGA_SetMode(1);
+           }
+           /* xxx0x101 - Detect VGA mode 2 */
+           else if( (val & 0x17) == 0x05 )
+           {
+             VGA_SetMode(2);
+           }
+           /* xxx0x001 - Detect VGA mode 3 */
+           else if( (val & 0x17) == 0x01 )
+           {
+             VGA_SetMode(3);
+           }
+           /* xxx0x010 - Detect VGA mode 4 */
+           else if( (val & 0x17) == 0x02 )
+           {
+             VGA_SetMode(4);
+           }
+           /* xxx0x110 - Detect VGA mode 5 */
+           else if( (val & 0x17) == 0x06 )
+           {
+             VGA_SetMode(5);
+           }
+           /* xxx1x110 - Detect VGA mode 6 */
+           else if( (val & 0x17) == 0x16 )
+           {
+             VGA_SetMode(6);
+           }
+           /* unsupported mode */
+           else
+           {
+             FIXME("Unsupported value, VGA register 0x3d8: 0x%02x - unrecognized MDA/CGA mode\n", val); /* Set the enabled bit */
+           }
+
+           break;
+
+        /* Colour control register (CGA) */
+        case 0x3d9:
+           /* Set bright */
+           VGA_SetBright((val & 0x10) && 1);
+
+           /* Set palette index */
+           VGA_SetPaletteIndex((val & 0x20) && 1);
+
+           /* Now update the palette */
+           VGA_UpdatePalette();
+           break;
+        default:
+            FIXME("Unsupported VGA register: 0x%04x (value 0x%02x)\n", port, val);
     }
 }
 
@@ -572,14 +1908,105 @@ BYTE VGA_ioport_in( WORD port )
     BYTE ret;
 
     switch (port) {
+        /* Attribute Controller - Other */
+        case 0x3c1:
+           FIXME("Unsupported index, VGA attribute controller register 0x3c0: 0x%02x\n",
+                 vga_index_3c0);
+           return 0xff;
+        /* General Register - Input status 0 */
+        case 0x3c2:
+           ret=0xff;
+           FIXME("Unsupported VGA register: general register - input status 0 0x%04x\n", port);
+           break;
+        /* General Register - Video subsystem enable */
+        case 0x3c3:
+           ret=0xff;
+           FIXME("Unsupported VGA register: general register - video subsystem enable 0x%04x\n", port);
+           break;
+        /* Sequencer Register - Other */
+        case 0x3c5:
+           switch(vga_index_3c4) {
+               case 0x04: /* Sequencer: Memory Mode Register */
+                    return (VGA_GetWindowStart() == -1) ? 0xf7 : 0xff;
+               default:
+                   FIXME("Unsupported index, register 0x3c4: 0x%02x\n",
+                         vga_index_3c4);
+                   return 0xff;
+           }
+        /* General Register -  DAC State */
+        case 0x3c7:
+           ret=0xff;
+           FIXME("Unsupported VGA register: general register - DAC State 0x%04x\n", port);
+           break;
+        /* General Register - Feature control */
+        case 0x3ca:
+           ret=0xff;
+           FIXME("Unsupported VGA register: general register - Feature control 0x%04x\n", port);
+           break;
+        /* General Register - Misc output */
+        case 0x3cc:
+           ret=0xff;
+           FIXME("Unsupported VGA register: general register - Feature control 0x%04x\n", port);
+           break;
+        /* Graphics Controller Register - Other */
+        case 0x3cf:
+           FIXME("Unsupported index, register 0x3ce: 0x%02x\n",
+                 vga_index_3ce);
+           return 0xff;
+        /* CRT Controller Register - Other (MDA) */
+        case 0x3b5:
+        /* CRT Controller Register - Other (CGA) */
+        case 0x3d5:
+           FIXME("Unsupported index, VGA crt controller register 0x3b4/0x3d4: 0x%02x\n",
+                 vga_index_3d4);
+           return 0xff;
+        /* General Register - Input status 1 (MDA) */
+        case 0x3ba:
+        /* General Register - Input status 1 (CGA) */
         case 0x3da:
-            /* since we don't (yet?) serve DOS VM requests while VGA_Poll is running,
-               we need to fake the occurrence of the vertical refresh */
-            ret=vga_refresh?0x00:0x08;
-            vga_refresh=0;
+            /*
+             * Read from this register resets register 0x3c0 address flip-flop.
+             */
+            vga_address_3c0 = TRUE;
+
+            /*
+             * Read from this register returns following bits:
+             *   xxxx1xxx = Vertical retrace in progress if set.
+             *   xxxxx1xx = Light pen switched on.
+             *   xxxxxx1x = Light pen trigger set.
+             *   xxxxxxx1 = Either vertical or horizontal retrace 
+             *              in progress if set.
+             */
+            ret = 0;
+            if (vga_retrace_vertical)
+                ret |= 9;
+            if (vga_retrace_horizontal)
+                ret |= 3;
+            
+            /*
+             * If VGA mode has been set, vertical retrace is
+             * turned on once a frame and cleared after each read.
+             * This might cause applications that synchronize with
+             * vertical retrace to actually skip one frame but that
+             * is probably not a problem.
+             * 
+             * If no VGA mode has been set, vertical retrace is faked
+             * by toggling the value after every read.
+             */
+            if (VGA_IsTimerRunning())
+                vga_retrace_vertical = FALSE;
+            else
+                vga_retrace_vertical = !vga_retrace_vertical;
+
+            /*
+             * Toggle horizontal retrace.
+             */
+            vga_retrace_horizontal = !vga_retrace_horizontal;
             break;
+
         default:
             ret=0xff;
+            FIXME("Unsupported VGA register: 0x%04x\n", port);
     }
     return ret;
 }