--- a/src/video/windx5/SDL_dx5video.c	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/windx5/SDL_dx5video.c	Mon Jul 10 21:04:37 2006 +0000
@@ -56,14 +56,17 @@
 
 
 /* DirectX function pointers for video and events */
-HRESULT (WINAPI *DDrawCreate)( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
-HRESULT (WINAPI *DInputCreate)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUT *ppDI, LPUNKNOWN punkOuter);
+HRESULT(WINAPI * DDrawCreate) (GUID FAR * lpGUID, LPDIRECTDRAW FAR * lplpDD,
+                               IUnknown FAR * pUnkOuter);
+HRESULT(WINAPI * DInputCreate) (HINSTANCE hinst, DWORD dwVersion,
+                                LPDIRECTINPUT * ppDI, LPUNKNOWN punkOuter);
 
 /* This is the rect EnumModes2 uses */
-struct DX5EnumRect {
-	SDL_Rect r;
-	int refreshRate;
-	struct DX5EnumRect* next;
+struct DX5EnumRect
+{
+    SDL_Rect r;
+    int refreshRate;
+    struct DX5EnumRect *next;
 };
 static struct DX5EnumRect *enumlists[NUM_MODELISTS];
 
@@ -74,262 +77,262 @@
 /* Keyboard */
 
 static DIOBJECTDATAFORMAT KBD_fmt[] = {
-	{ &GUID_Key, 0, 0x8000000C, 0x00000000 },
-	{ &GUID_Key, 1, 0x8000010C, 0x00000000 },
-	{ &GUID_Key, 2, 0x8000020C, 0x00000000 },
-	{ &GUID_Key, 3, 0x8000030C, 0x00000000 },
-	{ &GUID_Key, 4, 0x8000040C, 0x00000000 },
-	{ &GUID_Key, 5, 0x8000050C, 0x00000000 },
-	{ &GUID_Key, 6, 0x8000060C, 0x00000000 },
-	{ &GUID_Key, 7, 0x8000070C, 0x00000000 },
-	{ &GUID_Key, 8, 0x8000080C, 0x00000000 },
-	{ &GUID_Key, 9, 0x8000090C, 0x00000000 },
-	{ &GUID_Key, 10, 0x80000A0C, 0x00000000 },
-	{ &GUID_Key, 11, 0x80000B0C, 0x00000000 },
-	{ &GUID_Key, 12, 0x80000C0C, 0x00000000 },
-	{ &GUID_Key, 13, 0x80000D0C, 0x00000000 },
-	{ &GUID_Key, 14, 0x80000E0C, 0x00000000 },
-	{ &GUID_Key, 15, 0x80000F0C, 0x00000000 },
-	{ &GUID_Key, 16, 0x8000100C, 0x00000000 },
-	{ &GUID_Key, 17, 0x8000110C, 0x00000000 },
-	{ &GUID_Key, 18, 0x8000120C, 0x00000000 },
-	{ &GUID_Key, 19, 0x8000130C, 0x00000000 },
-	{ &GUID_Key, 20, 0x8000140C, 0x00000000 },
-	{ &GUID_Key, 21, 0x8000150C, 0x00000000 },
-	{ &GUID_Key, 22, 0x8000160C, 0x00000000 },
-	{ &GUID_Key, 23, 0x8000170C, 0x00000000 },
-	{ &GUID_Key, 24, 0x8000180C, 0x00000000 },
-	{ &GUID_Key, 25, 0x8000190C, 0x00000000 },
-	{ &GUID_Key, 26, 0x80001A0C, 0x00000000 },
-	{ &GUID_Key, 27, 0x80001B0C, 0x00000000 },
-	{ &GUID_Key, 28, 0x80001C0C, 0x00000000 },
-	{ &GUID_Key, 29, 0x80001D0C, 0x00000000 },
-	{ &GUID_Key, 30, 0x80001E0C, 0x00000000 },
-	{ &GUID_Key, 31, 0x80001F0C, 0x00000000 },
-	{ &GUID_Key, 32, 0x8000200C, 0x00000000 },
-	{ &GUID_Key, 33, 0x8000210C, 0x00000000 },
-	{ &GUID_Key, 34, 0x8000220C, 0x00000000 },
-	{ &GUID_Key, 35, 0x8000230C, 0x00000000 },
-	{ &GUID_Key, 36, 0x8000240C, 0x00000000 },
-	{ &GUID_Key, 37, 0x8000250C, 0x00000000 },
-	{ &GUID_Key, 38, 0x8000260C, 0x00000000 },
-	{ &GUID_Key, 39, 0x8000270C, 0x00000000 },
-	{ &GUID_Key, 40, 0x8000280C, 0x00000000 },
-	{ &GUID_Key, 41, 0x8000290C, 0x00000000 },
-	{ &GUID_Key, 42, 0x80002A0C, 0x00000000 },
-	{ &GUID_Key, 43, 0x80002B0C, 0x00000000 },
-	{ &GUID_Key, 44, 0x80002C0C, 0x00000000 },
-	{ &GUID_Key, 45, 0x80002D0C, 0x00000000 },
-	{ &GUID_Key, 46, 0x80002E0C, 0x00000000 },
-	{ &GUID_Key, 47, 0x80002F0C, 0x00000000 },
-	{ &GUID_Key, 48, 0x8000300C, 0x00000000 },
-	{ &GUID_Key, 49, 0x8000310C, 0x00000000 },
-	{ &GUID_Key, 50, 0x8000320C, 0x00000000 },
-	{ &GUID_Key, 51, 0x8000330C, 0x00000000 },
-	{ &GUID_Key, 52, 0x8000340C, 0x00000000 },
-	{ &GUID_Key, 53, 0x8000350C, 0x00000000 },
-	{ &GUID_Key, 54, 0x8000360C, 0x00000000 },
-	{ &GUID_Key, 55, 0x8000370C, 0x00000000 },
-	{ &GUID_Key, 56, 0x8000380C, 0x00000000 },
-	{ &GUID_Key, 57, 0x8000390C, 0x00000000 },
-	{ &GUID_Key, 58, 0x80003A0C, 0x00000000 },
-	{ &GUID_Key, 59, 0x80003B0C, 0x00000000 },
-	{ &GUID_Key, 60, 0x80003C0C, 0x00000000 },
-	{ &GUID_Key, 61, 0x80003D0C, 0x00000000 },
-	{ &GUID_Key, 62, 0x80003E0C, 0x00000000 },
-	{ &GUID_Key, 63, 0x80003F0C, 0x00000000 },
-	{ &GUID_Key, 64, 0x8000400C, 0x00000000 },
-	{ &GUID_Key, 65, 0x8000410C, 0x00000000 },
-	{ &GUID_Key, 66, 0x8000420C, 0x00000000 },
-	{ &GUID_Key, 67, 0x8000430C, 0x00000000 },
-	{ &GUID_Key, 68, 0x8000440C, 0x00000000 },
-	{ &GUID_Key, 69, 0x8000450C, 0x00000000 },
-	{ &GUID_Key, 70, 0x8000460C, 0x00000000 },
-	{ &GUID_Key, 71, 0x8000470C, 0x00000000 },
-	{ &GUID_Key, 72, 0x8000480C, 0x00000000 },
-	{ &GUID_Key, 73, 0x8000490C, 0x00000000 },
-	{ &GUID_Key, 74, 0x80004A0C, 0x00000000 },
-	{ &GUID_Key, 75, 0x80004B0C, 0x00000000 },
-	{ &GUID_Key, 76, 0x80004C0C, 0x00000000 },
-	{ &GUID_Key, 77, 0x80004D0C, 0x00000000 },
-	{ &GUID_Key, 78, 0x80004E0C, 0x00000000 },
-	{ &GUID_Key, 79, 0x80004F0C, 0x00000000 },
-	{ &GUID_Key, 80, 0x8000500C, 0x00000000 },
-	{ &GUID_Key, 81, 0x8000510C, 0x00000000 },
-	{ &GUID_Key, 82, 0x8000520C, 0x00000000 },
-	{ &GUID_Key, 83, 0x8000530C, 0x00000000 },
-	{ &GUID_Key, 84, 0x8000540C, 0x00000000 },
-	{ &GUID_Key, 85, 0x8000550C, 0x00000000 },
-	{ &GUID_Key, 86, 0x8000560C, 0x00000000 },
-	{ &GUID_Key, 87, 0x8000570C, 0x00000000 },
-	{ &GUID_Key, 88, 0x8000580C, 0x00000000 },
-	{ &GUID_Key, 89, 0x8000590C, 0x00000000 },
-	{ &GUID_Key, 90, 0x80005A0C, 0x00000000 },
-	{ &GUID_Key, 91, 0x80005B0C, 0x00000000 },
-	{ &GUID_Key, 92, 0x80005C0C, 0x00000000 },
-	{ &GUID_Key, 93, 0x80005D0C, 0x00000000 },
-	{ &GUID_Key, 94, 0x80005E0C, 0x00000000 },
-	{ &GUID_Key, 95, 0x80005F0C, 0x00000000 },
-	{ &GUID_Key, 96, 0x8000600C, 0x00000000 },
-	{ &GUID_Key, 97, 0x8000610C, 0x00000000 },
-	{ &GUID_Key, 98, 0x8000620C, 0x00000000 },
-	{ &GUID_Key, 99, 0x8000630C, 0x00000000 },
-	{ &GUID_Key, 100, 0x8000640C, 0x00000000 },
-	{ &GUID_Key, 101, 0x8000650C, 0x00000000 },
-	{ &GUID_Key, 102, 0x8000660C, 0x00000000 },
-	{ &GUID_Key, 103, 0x8000670C, 0x00000000 },
-	{ &GUID_Key, 104, 0x8000680C, 0x00000000 },
-	{ &GUID_Key, 105, 0x8000690C, 0x00000000 },
-	{ &GUID_Key, 106, 0x80006A0C, 0x00000000 },
-	{ &GUID_Key, 107, 0x80006B0C, 0x00000000 },
-	{ &GUID_Key, 108, 0x80006C0C, 0x00000000 },
-	{ &GUID_Key, 109, 0x80006D0C, 0x00000000 },
-	{ &GUID_Key, 110, 0x80006E0C, 0x00000000 },
-	{ &GUID_Key, 111, 0x80006F0C, 0x00000000 },
-	{ &GUID_Key, 112, 0x8000700C, 0x00000000 },
-	{ &GUID_Key, 113, 0x8000710C, 0x00000000 },
-	{ &GUID_Key, 114, 0x8000720C, 0x00000000 },
-	{ &GUID_Key, 115, 0x8000730C, 0x00000000 },
-	{ &GUID_Key, 116, 0x8000740C, 0x00000000 },
-	{ &GUID_Key, 117, 0x8000750C, 0x00000000 },
-	{ &GUID_Key, 118, 0x8000760C, 0x00000000 },
-	{ &GUID_Key, 119, 0x8000770C, 0x00000000 },
-	{ &GUID_Key, 120, 0x8000780C, 0x00000000 },
-	{ &GUID_Key, 121, 0x8000790C, 0x00000000 },
-	{ &GUID_Key, 122, 0x80007A0C, 0x00000000 },
-	{ &GUID_Key, 123, 0x80007B0C, 0x00000000 },
-	{ &GUID_Key, 124, 0x80007C0C, 0x00000000 },
-	{ &GUID_Key, 125, 0x80007D0C, 0x00000000 },
-	{ &GUID_Key, 126, 0x80007E0C, 0x00000000 },
-	{ &GUID_Key, 127, 0x80007F0C, 0x00000000 },
-	{ &GUID_Key, 128, 0x8000800C, 0x00000000 },
-	{ &GUID_Key, 129, 0x8000810C, 0x00000000 },
-	{ &GUID_Key, 130, 0x8000820C, 0x00000000 },
-	{ &GUID_Key, 131, 0x8000830C, 0x00000000 },
-	{ &GUID_Key, 132, 0x8000840C, 0x00000000 },
-	{ &GUID_Key, 133, 0x8000850C, 0x00000000 },
-	{ &GUID_Key, 134, 0x8000860C, 0x00000000 },
-	{ &GUID_Key, 135, 0x8000870C, 0x00000000 },
-	{ &GUID_Key, 136, 0x8000880C, 0x00000000 },
-	{ &GUID_Key, 137, 0x8000890C, 0x00000000 },
-	{ &GUID_Key, 138, 0x80008A0C, 0x00000000 },
-	{ &GUID_Key, 139, 0x80008B0C, 0x00000000 },
-	{ &GUID_Key, 140, 0x80008C0C, 0x00000000 },
-	{ &GUID_Key, 141, 0x80008D0C, 0x00000000 },
-	{ &GUID_Key, 142, 0x80008E0C, 0x00000000 },
-	{ &GUID_Key, 143, 0x80008F0C, 0x00000000 },
-	{ &GUID_Key, 144, 0x8000900C, 0x00000000 },
-	{ &GUID_Key, 145, 0x8000910C, 0x00000000 },
-	{ &GUID_Key, 146, 0x8000920C, 0x00000000 },
-	{ &GUID_Key, 147, 0x8000930C, 0x00000000 },
-	{ &GUID_Key, 148, 0x8000940C, 0x00000000 },
-	{ &GUID_Key, 149, 0x8000950C, 0x00000000 },
-	{ &GUID_Key, 150, 0x8000960C, 0x00000000 },
-	{ &GUID_Key, 151, 0x8000970C, 0x00000000 },
-	{ &GUID_Key, 152, 0x8000980C, 0x00000000 },
-	{ &GUID_Key, 153, 0x8000990C, 0x00000000 },
-	{ &GUID_Key, 154, 0x80009A0C, 0x00000000 },
-	{ &GUID_Key, 155, 0x80009B0C, 0x00000000 },
-	{ &GUID_Key, 156, 0x80009C0C, 0x00000000 },
-	{ &GUID_Key, 157, 0x80009D0C, 0x00000000 },
-	{ &GUID_Key, 158, 0x80009E0C, 0x00000000 },
-	{ &GUID_Key, 159, 0x80009F0C, 0x00000000 },
-	{ &GUID_Key, 160, 0x8000A00C, 0x00000000 },
-	{ &GUID_Key, 161, 0x8000A10C, 0x00000000 },
-	{ &GUID_Key, 162, 0x8000A20C, 0x00000000 },
-	{ &GUID_Key, 163, 0x8000A30C, 0x00000000 },
-	{ &GUID_Key, 164, 0x8000A40C, 0x00000000 },
-	{ &GUID_Key, 165, 0x8000A50C, 0x00000000 },
-	{ &GUID_Key, 166, 0x8000A60C, 0x00000000 },
-	{ &GUID_Key, 167, 0x8000A70C, 0x00000000 },
-	{ &GUID_Key, 168, 0x8000A80C, 0x00000000 },
-	{ &GUID_Key, 169, 0x8000A90C, 0x00000000 },
-	{ &GUID_Key, 170, 0x8000AA0C, 0x00000000 },
-	{ &GUID_Key, 171, 0x8000AB0C, 0x00000000 },
-	{ &GUID_Key, 172, 0x8000AC0C, 0x00000000 },
-	{ &GUID_Key, 173, 0x8000AD0C, 0x00000000 },
-	{ &GUID_Key, 174, 0x8000AE0C, 0x00000000 },
-	{ &GUID_Key, 175, 0x8000AF0C, 0x00000000 },
-	{ &GUID_Key, 176, 0x8000B00C, 0x00000000 },
-	{ &GUID_Key, 177, 0x8000B10C, 0x00000000 },
-	{ &GUID_Key, 178, 0x8000B20C, 0x00000000 },
-	{ &GUID_Key, 179, 0x8000B30C, 0x00000000 },
-	{ &GUID_Key, 180, 0x8000B40C, 0x00000000 },
-	{ &GUID_Key, 181, 0x8000B50C, 0x00000000 },
-	{ &GUID_Key, 182, 0x8000B60C, 0x00000000 },
-	{ &GUID_Key, 183, 0x8000B70C, 0x00000000 },
-	{ &GUID_Key, 184, 0x8000B80C, 0x00000000 },
-	{ &GUID_Key, 185, 0x8000B90C, 0x00000000 },
-	{ &GUID_Key, 186, 0x8000BA0C, 0x00000000 },
-	{ &GUID_Key, 187, 0x8000BB0C, 0x00000000 },
-	{ &GUID_Key, 188, 0x8000BC0C, 0x00000000 },
-	{ &GUID_Key, 189, 0x8000BD0C, 0x00000000 },
-	{ &GUID_Key, 190, 0x8000BE0C, 0x00000000 },
-	{ &GUID_Key, 191, 0x8000BF0C, 0x00000000 },
-	{ &GUID_Key, 192, 0x8000C00C, 0x00000000 },
-	{ &GUID_Key, 193, 0x8000C10C, 0x00000000 },
-	{ &GUID_Key, 194, 0x8000C20C, 0x00000000 },
-	{ &GUID_Key, 195, 0x8000C30C, 0x00000000 },
-	{ &GUID_Key, 196, 0x8000C40C, 0x00000000 },
-	{ &GUID_Key, 197, 0x8000C50C, 0x00000000 },
-	{ &GUID_Key, 198, 0x8000C60C, 0x00000000 },
-	{ &GUID_Key, 199, 0x8000C70C, 0x00000000 },
-	{ &GUID_Key, 200, 0x8000C80C, 0x00000000 },
-	{ &GUID_Key, 201, 0x8000C90C, 0x00000000 },
-	{ &GUID_Key, 202, 0x8000CA0C, 0x00000000 },
-	{ &GUID_Key, 203, 0x8000CB0C, 0x00000000 },
-	{ &GUID_Key, 204, 0x8000CC0C, 0x00000000 },
-	{ &GUID_Key, 205, 0x8000CD0C, 0x00000000 },
-	{ &GUID_Key, 206, 0x8000CE0C, 0x00000000 },
-	{ &GUID_Key, 207, 0x8000CF0C, 0x00000000 },
-	{ &GUID_Key, 208, 0x8000D00C, 0x00000000 },
-	{ &GUID_Key, 209, 0x8000D10C, 0x00000000 },
-	{ &GUID_Key, 210, 0x8000D20C, 0x00000000 },
-	{ &GUID_Key, 211, 0x8000D30C, 0x00000000 },
-	{ &GUID_Key, 212, 0x8000D40C, 0x00000000 },
-	{ &GUID_Key, 213, 0x8000D50C, 0x00000000 },
-	{ &GUID_Key, 214, 0x8000D60C, 0x00000000 },
-	{ &GUID_Key, 215, 0x8000D70C, 0x00000000 },
-	{ &GUID_Key, 216, 0x8000D80C, 0x00000000 },
-	{ &GUID_Key, 217, 0x8000D90C, 0x00000000 },
-	{ &GUID_Key, 218, 0x8000DA0C, 0x00000000 },
-	{ &GUID_Key, 219, 0x8000DB0C, 0x00000000 },
-	{ &GUID_Key, 220, 0x8000DC0C, 0x00000000 },
-	{ &GUID_Key, 221, 0x8000DD0C, 0x00000000 },
-	{ &GUID_Key, 222, 0x8000DE0C, 0x00000000 },
-	{ &GUID_Key, 223, 0x8000DF0C, 0x00000000 },
-	{ &GUID_Key, 224, 0x8000E00C, 0x00000000 },
-	{ &GUID_Key, 225, 0x8000E10C, 0x00000000 },
-	{ &GUID_Key, 226, 0x8000E20C, 0x00000000 },
-	{ &GUID_Key, 227, 0x8000E30C, 0x00000000 },
-	{ &GUID_Key, 228, 0x8000E40C, 0x00000000 },
-	{ &GUID_Key, 229, 0x8000E50C, 0x00000000 },
-	{ &GUID_Key, 230, 0x8000E60C, 0x00000000 },
-	{ &GUID_Key, 231, 0x8000E70C, 0x00000000 },
-	{ &GUID_Key, 232, 0x8000E80C, 0x00000000 },
-	{ &GUID_Key, 233, 0x8000E90C, 0x00000000 },
-	{ &GUID_Key, 234, 0x8000EA0C, 0x00000000 },
-	{ &GUID_Key, 235, 0x8000EB0C, 0x00000000 },
-	{ &GUID_Key, 236, 0x8000EC0C, 0x00000000 },
-	{ &GUID_Key, 237, 0x8000ED0C, 0x00000000 },
-	{ &GUID_Key, 238, 0x8000EE0C, 0x00000000 },
-	{ &GUID_Key, 239, 0x8000EF0C, 0x00000000 },
-	{ &GUID_Key, 240, 0x8000F00C, 0x00000000 },
-	{ &GUID_Key, 241, 0x8000F10C, 0x00000000 },
-	{ &GUID_Key, 242, 0x8000F20C, 0x00000000 },
-	{ &GUID_Key, 243, 0x8000F30C, 0x00000000 },
-	{ &GUID_Key, 244, 0x8000F40C, 0x00000000 },
-	{ &GUID_Key, 245, 0x8000F50C, 0x00000000 },
-	{ &GUID_Key, 246, 0x8000F60C, 0x00000000 },
-	{ &GUID_Key, 247, 0x8000F70C, 0x00000000 },
-	{ &GUID_Key, 248, 0x8000F80C, 0x00000000 },
-	{ &GUID_Key, 249, 0x8000F90C, 0x00000000 },
-	{ &GUID_Key, 250, 0x8000FA0C, 0x00000000 },
-	{ &GUID_Key, 251, 0x8000FB0C, 0x00000000 },
-	{ &GUID_Key, 252, 0x8000FC0C, 0x00000000 },
-	{ &GUID_Key, 253, 0x8000FD0C, 0x00000000 },
-	{ &GUID_Key, 254, 0x8000FE0C, 0x00000000 },
-	{ &GUID_Key, 255, 0x8000FF0C, 0x00000000 },
+    {&GUID_Key, 0, 0x8000000C, 0x00000000},
+    {&GUID_Key, 1, 0x8000010C, 0x00000000},
+    {&GUID_Key, 2, 0x8000020C, 0x00000000},
+    {&GUID_Key, 3, 0x8000030C, 0x00000000},
+    {&GUID_Key, 4, 0x8000040C, 0x00000000},
+    {&GUID_Key, 5, 0x8000050C, 0x00000000},
+    {&GUID_Key, 6, 0x8000060C, 0x00000000},
+    {&GUID_Key, 7, 0x8000070C, 0x00000000},
+    {&GUID_Key, 8, 0x8000080C, 0x00000000},
+    {&GUID_Key, 9, 0x8000090C, 0x00000000},
+    {&GUID_Key, 10, 0x80000A0C, 0x00000000},
+    {&GUID_Key, 11, 0x80000B0C, 0x00000000},
+    {&GUID_Key, 12, 0x80000C0C, 0x00000000},
+    {&GUID_Key, 13, 0x80000D0C, 0x00000000},
+    {&GUID_Key, 14, 0x80000E0C, 0x00000000},
+    {&GUID_Key, 15, 0x80000F0C, 0x00000000},
+    {&GUID_Key, 16, 0x8000100C, 0x00000000},
+    {&GUID_Key, 17, 0x8000110C, 0x00000000},
+    {&GUID_Key, 18, 0x8000120C, 0x00000000},
+    {&GUID_Key, 19, 0x8000130C, 0x00000000},
+    {&GUID_Key, 20, 0x8000140C, 0x00000000},
+    {&GUID_Key, 21, 0x8000150C, 0x00000000},
+    {&GUID_Key, 22, 0x8000160C, 0x00000000},
+    {&GUID_Key, 23, 0x8000170C, 0x00000000},
+    {&GUID_Key, 24, 0x8000180C, 0x00000000},
+    {&GUID_Key, 25, 0x8000190C, 0x00000000},
+    {&GUID_Key, 26, 0x80001A0C, 0x00000000},
+    {&GUID_Key, 27, 0x80001B0C, 0x00000000},
+    {&GUID_Key, 28, 0x80001C0C, 0x00000000},
+    {&GUID_Key, 29, 0x80001D0C, 0x00000000},
+    {&GUID_Key, 30, 0x80001E0C, 0x00000000},
+    {&GUID_Key, 31, 0x80001F0C, 0x00000000},
+    {&GUID_Key, 32, 0x8000200C, 0x00000000},
+    {&GUID_Key, 33, 0x8000210C, 0x00000000},
+    {&GUID_Key, 34, 0x8000220C, 0x00000000},
+    {&GUID_Key, 35, 0x8000230C, 0x00000000},
+    {&GUID_Key, 36, 0x8000240C, 0x00000000},
+    {&GUID_Key, 37, 0x8000250C, 0x00000000},
+    {&GUID_Key, 38, 0x8000260C, 0x00000000},
+    {&GUID_Key, 39, 0x8000270C, 0x00000000},
+    {&GUID_Key, 40, 0x8000280C, 0x00000000},
+    {&GUID_Key, 41, 0x8000290C, 0x00000000},
+    {&GUID_Key, 42, 0x80002A0C, 0x00000000},
+    {&GUID_Key, 43, 0x80002B0C, 0x00000000},
+    {&GUID_Key, 44, 0x80002C0C, 0x00000000},
+    {&GUID_Key, 45, 0x80002D0C, 0x00000000},
+    {&GUID_Key, 46, 0x80002E0C, 0x00000000},
+    {&GUID_Key, 47, 0x80002F0C, 0x00000000},
+    {&GUID_Key, 48, 0x8000300C, 0x00000000},
+    {&GUID_Key, 49, 0x8000310C, 0x00000000},
+    {&GUID_Key, 50, 0x8000320C, 0x00000000},
+    {&GUID_Key, 51, 0x8000330C, 0x00000000},
+    {&GUID_Key, 52, 0x8000340C, 0x00000000},
+    {&GUID_Key, 53, 0x8000350C, 0x00000000},
+    {&GUID_Key, 54, 0x8000360C, 0x00000000},
+    {&GUID_Key, 55, 0x8000370C, 0x00000000},
+    {&GUID_Key, 56, 0x8000380C, 0x00000000},
+    {&GUID_Key, 57, 0x8000390C, 0x00000000},
+    {&GUID_Key, 58, 0x80003A0C, 0x00000000},
+    {&GUID_Key, 59, 0x80003B0C, 0x00000000},
+    {&GUID_Key, 60, 0x80003C0C, 0x00000000},
+    {&GUID_Key, 61, 0x80003D0C, 0x00000000},
+    {&GUID_Key, 62, 0x80003E0C, 0x00000000},
+    {&GUID_Key, 63, 0x80003F0C, 0x00000000},
+    {&GUID_Key, 64, 0x8000400C, 0x00000000},
+    {&GUID_Key, 65, 0x8000410C, 0x00000000},
+    {&GUID_Key, 66, 0x8000420C, 0x00000000},
+    {&GUID_Key, 67, 0x8000430C, 0x00000000},
+    {&GUID_Key, 68, 0x8000440C, 0x00000000},
+    {&GUID_Key, 69, 0x8000450C, 0x00000000},
+    {&GUID_Key, 70, 0x8000460C, 0x00000000},
+    {&GUID_Key, 71, 0x8000470C, 0x00000000},
+    {&GUID_Key, 72, 0x8000480C, 0x00000000},
+    {&GUID_Key, 73, 0x8000490C, 0x00000000},
+    {&GUID_Key, 74, 0x80004A0C, 0x00000000},
+    {&GUID_Key, 75, 0x80004B0C, 0x00000000},
+    {&GUID_Key, 76, 0x80004C0C, 0x00000000},
+    {&GUID_Key, 77, 0x80004D0C, 0x00000000},
+    {&GUID_Key, 78, 0x80004E0C, 0x00000000},
+    {&GUID_Key, 79, 0x80004F0C, 0x00000000},
+    {&GUID_Key, 80, 0x8000500C, 0x00000000},
+    {&GUID_Key, 81, 0x8000510C, 0x00000000},
+    {&GUID_Key, 82, 0x8000520C, 0x00000000},
+    {&GUID_Key, 83, 0x8000530C, 0x00000000},
+    {&GUID_Key, 84, 0x8000540C, 0x00000000},
+    {&GUID_Key, 85, 0x8000550C, 0x00000000},
+    {&GUID_Key, 86, 0x8000560C, 0x00000000},
+    {&GUID_Key, 87, 0x8000570C, 0x00000000},
+    {&GUID_Key, 88, 0x8000580C, 0x00000000},
+    {&GUID_Key, 89, 0x8000590C, 0x00000000},
+    {&GUID_Key, 90, 0x80005A0C, 0x00000000},
+    {&GUID_Key, 91, 0x80005B0C, 0x00000000},
+    {&GUID_Key, 92, 0x80005C0C, 0x00000000},
+    {&GUID_Key, 93, 0x80005D0C, 0x00000000},
+    {&GUID_Key, 94, 0x80005E0C, 0x00000000},
+    {&GUID_Key, 95, 0x80005F0C, 0x00000000},
+    {&GUID_Key, 96, 0x8000600C, 0x00000000},
+    {&GUID_Key, 97, 0x8000610C, 0x00000000},
+    {&GUID_Key, 98, 0x8000620C, 0x00000000},
+    {&GUID_Key, 99, 0x8000630C, 0x00000000},
+    {&GUID_Key, 100, 0x8000640C, 0x00000000},
+    {&GUID_Key, 101, 0x8000650C, 0x00000000},
+    {&GUID_Key, 102, 0x8000660C, 0x00000000},
+    {&GUID_Key, 103, 0x8000670C, 0x00000000},
+    {&GUID_Key, 104, 0x8000680C, 0x00000000},
+    {&GUID_Key, 105, 0x8000690C, 0x00000000},
+    {&GUID_Key, 106, 0x80006A0C, 0x00000000},
+    {&GUID_Key, 107, 0x80006B0C, 0x00000000},
+    {&GUID_Key, 108, 0x80006C0C, 0x00000000},
+    {&GUID_Key, 109, 0x80006D0C, 0x00000000},
+    {&GUID_Key, 110, 0x80006E0C, 0x00000000},
+    {&GUID_Key, 111, 0x80006F0C, 0x00000000},
+    {&GUID_Key, 112, 0x8000700C, 0x00000000},
+    {&GUID_Key, 113, 0x8000710C, 0x00000000},
+    {&GUID_Key, 114, 0x8000720C, 0x00000000},
+    {&GUID_Key, 115, 0x8000730C, 0x00000000},
+    {&GUID_Key, 116, 0x8000740C, 0x00000000},
+    {&GUID_Key, 117, 0x8000750C, 0x00000000},
+    {&GUID_Key, 118, 0x8000760C, 0x00000000},
+    {&GUID_Key, 119, 0x8000770C, 0x00000000},
+    {&GUID_Key, 120, 0x8000780C, 0x00000000},
+    {&GUID_Key, 121, 0x8000790C, 0x00000000},
+    {&GUID_Key, 122, 0x80007A0C, 0x00000000},
+    {&GUID_Key, 123, 0x80007B0C, 0x00000000},
+    {&GUID_Key, 124, 0x80007C0C, 0x00000000},
+    {&GUID_Key, 125, 0x80007D0C, 0x00000000},
+    {&GUID_Key, 126, 0x80007E0C, 0x00000000},
+    {&GUID_Key, 127, 0x80007F0C, 0x00000000},
+    {&GUID_Key, 128, 0x8000800C, 0x00000000},
+    {&GUID_Key, 129, 0x8000810C, 0x00000000},
+    {&GUID_Key, 130, 0x8000820C, 0x00000000},
+    {&GUID_Key, 131, 0x8000830C, 0x00000000},
+    {&GUID_Key, 132, 0x8000840C, 0x00000000},
+    {&GUID_Key, 133, 0x8000850C, 0x00000000},
+    {&GUID_Key, 134, 0x8000860C, 0x00000000},
+    {&GUID_Key, 135, 0x8000870C, 0x00000000},
+    {&GUID_Key, 136, 0x8000880C, 0x00000000},
+    {&GUID_Key, 137, 0x8000890C, 0x00000000},
+    {&GUID_Key, 138, 0x80008A0C, 0x00000000},
+    {&GUID_Key, 139, 0x80008B0C, 0x00000000},
+    {&GUID_Key, 140, 0x80008C0C, 0x00000000},
+    {&GUID_Key, 141, 0x80008D0C, 0x00000000},
+    {&GUID_Key, 142, 0x80008E0C, 0x00000000},
+    {&GUID_Key, 143, 0x80008F0C, 0x00000000},
+    {&GUID_Key, 144, 0x8000900C, 0x00000000},
+    {&GUID_Key, 145, 0x8000910C, 0x00000000},
+    {&GUID_Key, 146, 0x8000920C, 0x00000000},
+    {&GUID_Key, 147, 0x8000930C, 0x00000000},
+    {&GUID_Key, 148, 0x8000940C, 0x00000000},
+    {&GUID_Key, 149, 0x8000950C, 0x00000000},
+    {&GUID_Key, 150, 0x8000960C, 0x00000000},
+    {&GUID_Key, 151, 0x8000970C, 0x00000000},
+    {&GUID_Key, 152, 0x8000980C, 0x00000000},
+    {&GUID_Key, 153, 0x8000990C, 0x00000000},
+    {&GUID_Key, 154, 0x80009A0C, 0x00000000},
+    {&GUID_Key, 155, 0x80009B0C, 0x00000000},
+    {&GUID_Key, 156, 0x80009C0C, 0x00000000},
+    {&GUID_Key, 157, 0x80009D0C, 0x00000000},
+    {&GUID_Key, 158, 0x80009E0C, 0x00000000},
+    {&GUID_Key, 159, 0x80009F0C, 0x00000000},
+    {&GUID_Key, 160, 0x8000A00C, 0x00000000},
+    {&GUID_Key, 161, 0x8000A10C, 0x00000000},
+    {&GUID_Key, 162, 0x8000A20C, 0x00000000},
+    {&GUID_Key, 163, 0x8000A30C, 0x00000000},
+    {&GUID_Key, 164, 0x8000A40C, 0x00000000},
+    {&GUID_Key, 165, 0x8000A50C, 0x00000000},
+    {&GUID_Key, 166, 0x8000A60C, 0x00000000},
+    {&GUID_Key, 167, 0x8000A70C, 0x00000000},
+    {&GUID_Key, 168, 0x8000A80C, 0x00000000},
+    {&GUID_Key, 169, 0x8000A90C, 0x00000000},
+    {&GUID_Key, 170, 0x8000AA0C, 0x00000000},
+    {&GUID_Key, 171, 0x8000AB0C, 0x00000000},
+    {&GUID_Key, 172, 0x8000AC0C, 0x00000000},
+    {&GUID_Key, 173, 0x8000AD0C, 0x00000000},
+    {&GUID_Key, 174, 0x8000AE0C, 0x00000000},
+    {&GUID_Key, 175, 0x8000AF0C, 0x00000000},
+    {&GUID_Key, 176, 0x8000B00C, 0x00000000},
+    {&GUID_Key, 177, 0x8000B10C, 0x00000000},
+    {&GUID_Key, 178, 0x8000B20C, 0x00000000},
+    {&GUID_Key, 179, 0x8000B30C, 0x00000000},
+    {&GUID_Key, 180, 0x8000B40C, 0x00000000},
+    {&GUID_Key, 181, 0x8000B50C, 0x00000000},
+    {&GUID_Key, 182, 0x8000B60C, 0x00000000},
+    {&GUID_Key, 183, 0x8000B70C, 0x00000000},
+    {&GUID_Key, 184, 0x8000B80C, 0x00000000},
+    {&GUID_Key, 185, 0x8000B90C, 0x00000000},
+    {&GUID_Key, 186, 0x8000BA0C, 0x00000000},
+    {&GUID_Key, 187, 0x8000BB0C, 0x00000000},
+    {&GUID_Key, 188, 0x8000BC0C, 0x00000000},
+    {&GUID_Key, 189, 0x8000BD0C, 0x00000000},
+    {&GUID_Key, 190, 0x8000BE0C, 0x00000000},
+    {&GUID_Key, 191, 0x8000BF0C, 0x00000000},
+    {&GUID_Key, 192, 0x8000C00C, 0x00000000},
+    {&GUID_Key, 193, 0x8000C10C, 0x00000000},
+    {&GUID_Key, 194, 0x8000C20C, 0x00000000},
+    {&GUID_Key, 195, 0x8000C30C, 0x00000000},
+    {&GUID_Key, 196, 0x8000C40C, 0x00000000},
+    {&GUID_Key, 197, 0x8000C50C, 0x00000000},
+    {&GUID_Key, 198, 0x8000C60C, 0x00000000},
+    {&GUID_Key, 199, 0x8000C70C, 0x00000000},
+    {&GUID_Key, 200, 0x8000C80C, 0x00000000},
+    {&GUID_Key, 201, 0x8000C90C, 0x00000000},
+    {&GUID_Key, 202, 0x8000CA0C, 0x00000000},
+    {&GUID_Key, 203, 0x8000CB0C, 0x00000000},
+    {&GUID_Key, 204, 0x8000CC0C, 0x00000000},
+    {&GUID_Key, 205, 0x8000CD0C, 0x00000000},
+    {&GUID_Key, 206, 0x8000CE0C, 0x00000000},
+    {&GUID_Key, 207, 0x8000CF0C, 0x00000000},
+    {&GUID_Key, 208, 0x8000D00C, 0x00000000},
+    {&GUID_Key, 209, 0x8000D10C, 0x00000000},
+    {&GUID_Key, 210, 0x8000D20C, 0x00000000},
+    {&GUID_Key, 211, 0x8000D30C, 0x00000000},
+    {&GUID_Key, 212, 0x8000D40C, 0x00000000},
+    {&GUID_Key, 213, 0x8000D50C, 0x00000000},
+    {&GUID_Key, 214, 0x8000D60C, 0x00000000},
+    {&GUID_Key, 215, 0x8000D70C, 0x00000000},
+    {&GUID_Key, 216, 0x8000D80C, 0x00000000},
+    {&GUID_Key, 217, 0x8000D90C, 0x00000000},
+    {&GUID_Key, 218, 0x8000DA0C, 0x00000000},
+    {&GUID_Key, 219, 0x8000DB0C, 0x00000000},
+    {&GUID_Key, 220, 0x8000DC0C, 0x00000000},
+    {&GUID_Key, 221, 0x8000DD0C, 0x00000000},
+    {&GUID_Key, 222, 0x8000DE0C, 0x00000000},
+    {&GUID_Key, 223, 0x8000DF0C, 0x00000000},
+    {&GUID_Key, 224, 0x8000E00C, 0x00000000},
+    {&GUID_Key, 225, 0x8000E10C, 0x00000000},
+    {&GUID_Key, 226, 0x8000E20C, 0x00000000},
+    {&GUID_Key, 227, 0x8000E30C, 0x00000000},
+    {&GUID_Key, 228, 0x8000E40C, 0x00000000},
+    {&GUID_Key, 229, 0x8000E50C, 0x00000000},
+    {&GUID_Key, 230, 0x8000E60C, 0x00000000},
+    {&GUID_Key, 231, 0x8000E70C, 0x00000000},
+    {&GUID_Key, 232, 0x8000E80C, 0x00000000},
+    {&GUID_Key, 233, 0x8000E90C, 0x00000000},
+    {&GUID_Key, 234, 0x8000EA0C, 0x00000000},
+    {&GUID_Key, 235, 0x8000EB0C, 0x00000000},
+    {&GUID_Key, 236, 0x8000EC0C, 0x00000000},
+    {&GUID_Key, 237, 0x8000ED0C, 0x00000000},
+    {&GUID_Key, 238, 0x8000EE0C, 0x00000000},
+    {&GUID_Key, 239, 0x8000EF0C, 0x00000000},
+    {&GUID_Key, 240, 0x8000F00C, 0x00000000},
+    {&GUID_Key, 241, 0x8000F10C, 0x00000000},
+    {&GUID_Key, 242, 0x8000F20C, 0x00000000},
+    {&GUID_Key, 243, 0x8000F30C, 0x00000000},
+    {&GUID_Key, 244, 0x8000F40C, 0x00000000},
+    {&GUID_Key, 245, 0x8000F50C, 0x00000000},
+    {&GUID_Key, 246, 0x8000F60C, 0x00000000},
+    {&GUID_Key, 247, 0x8000F70C, 0x00000000},
+    {&GUID_Key, 248, 0x8000F80C, 0x00000000},
+    {&GUID_Key, 249, 0x8000F90C, 0x00000000},
+    {&GUID_Key, 250, 0x8000FA0C, 0x00000000},
+    {&GUID_Key, 251, 0x8000FB0C, 0x00000000},
+    {&GUID_Key, 252, 0x8000FC0C, 0x00000000},
+    {&GUID_Key, 253, 0x8000FD0C, 0x00000000},
+    {&GUID_Key, 254, 0x8000FE0C, 0x00000000},
+    {&GUID_Key, 255, 0x8000FF0C, 0x00000000},
 };
 
 const DIDATAFORMAT c_dfDIKeyboard = { 24, 16, 0x00000002, 256, 256, KBD_fmt };
@@ -338,13 +341,13 @@
 /* Mouse */
 
 static DIOBJECTDATAFORMAT PTR_fmt[] = {
-	{ &GUID_XAxis, 0, 0x00FFFF03, 0x00000000 },
-	{ &GUID_YAxis, 4, 0x00FFFF03, 0x00000000 },
-	{ &GUID_ZAxis, 8, 0x80FFFF03, 0x00000000 },
-	{ NULL, 12, 0x00FFFF0C, 0x00000000 },
-	{ NULL, 13, 0x00FFFF0C, 0x00000000 },
-	{ NULL, 14, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 15, 0x80FFFF0C, 0x00000000 },
+    {&GUID_XAxis, 0, 0x00FFFF03, 0x00000000},
+    {&GUID_YAxis, 4, 0x00FFFF03, 0x00000000},
+    {&GUID_ZAxis, 8, 0x80FFFF03, 0x00000000},
+    {NULL, 12, 0x00FFFF0C, 0x00000000},
+    {NULL, 13, 0x00FFFF0C, 0x00000000},
+    {NULL, 14, 0x80FFFF0C, 0x00000000},
+    {NULL, 15, 0x80FFFF0C, 0x00000000},
 };
 
 const DIDATAFORMAT c_dfDIMouse = { 24, 16, 0x00000002, 16, 7, PTR_fmt };
@@ -353,78 +356,81 @@
 /* Joystick */
 
 static DIOBJECTDATAFORMAT JOY_fmt[] = {
-	{ &GUID_XAxis, 0, 0x80FFFF03, 0x00000100 },
-	{ &GUID_YAxis, 4, 0x80FFFF03, 0x00000100 },
-	{ &GUID_ZAxis, 8, 0x80FFFF03, 0x00000100 },
-	{ &GUID_RxAxis, 12, 0x80FFFF03, 0x00000100 },
-	{ &GUID_RyAxis, 16, 0x80FFFF03, 0x00000100 },
-	{ &GUID_RzAxis, 20, 0x80FFFF03, 0x00000100 },
-	{ &GUID_Slider, 24, 0x80FFFF03, 0x00000100 },
-	{ &GUID_Slider, 28, 0x80FFFF03, 0x00000100 },
-	{ &GUID_POV, 32, 0x80FFFF10, 0x00000000 },
-	{ &GUID_POV, 36, 0x80FFFF10, 0x00000000 },
-	{ &GUID_POV, 40, 0x80FFFF10, 0x00000000 },
-	{ &GUID_POV, 44, 0x80FFFF10, 0x00000000 },
-	{ NULL, 48, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 49, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 50, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 51, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 52, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 53, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 54, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 55, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 56, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 57, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 58, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 59, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 60, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 61, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 62, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 63, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 64, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 65, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 66, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 67, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 68, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 69, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 70, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 71, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 72, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 73, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 74, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 75, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 76, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 77, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 78, 0x80FFFF0C, 0x00000000 },
-	{ NULL, 79, 0x80FFFF0C, 0x00000000 },
+    {&GUID_XAxis, 0, 0x80FFFF03, 0x00000100},
+    {&GUID_YAxis, 4, 0x80FFFF03, 0x00000100},
+    {&GUID_ZAxis, 8, 0x80FFFF03, 0x00000100},
+    {&GUID_RxAxis, 12, 0x80FFFF03, 0x00000100},
+    {&GUID_RyAxis, 16, 0x80FFFF03, 0x00000100},
+    {&GUID_RzAxis, 20, 0x80FFFF03, 0x00000100},
+    {&GUID_Slider, 24, 0x80FFFF03, 0x00000100},
+    {&GUID_Slider, 28, 0x80FFFF03, 0x00000100},
+    {&GUID_POV, 32, 0x80FFFF10, 0x00000000},
+    {&GUID_POV, 36, 0x80FFFF10, 0x00000000},
+    {&GUID_POV, 40, 0x80FFFF10, 0x00000000},
+    {&GUID_POV, 44, 0x80FFFF10, 0x00000000},
+    {NULL, 48, 0x80FFFF0C, 0x00000000},
+    {NULL, 49, 0x80FFFF0C, 0x00000000},
+    {NULL, 50, 0x80FFFF0C, 0x00000000},
+    {NULL, 51, 0x80FFFF0C, 0x00000000},
+    {NULL, 52, 0x80FFFF0C, 0x00000000},
+    {NULL, 53, 0x80FFFF0C, 0x00000000},
+    {NULL, 54, 0x80FFFF0C, 0x00000000},
+    {NULL, 55, 0x80FFFF0C, 0x00000000},
+    {NULL, 56, 0x80FFFF0C, 0x00000000},
+    {NULL, 57, 0x80FFFF0C, 0x00000000},
+    {NULL, 58, 0x80FFFF0C, 0x00000000},
+    {NULL, 59, 0x80FFFF0C, 0x00000000},
+    {NULL, 60, 0x80FFFF0C, 0x00000000},
+    {NULL, 61, 0x80FFFF0C, 0x00000000},
+    {NULL, 62, 0x80FFFF0C, 0x00000000},
+    {NULL, 63, 0x80FFFF0C, 0x00000000},
+    {NULL, 64, 0x80FFFF0C, 0x00000000},
+    {NULL, 65, 0x80FFFF0C, 0x00000000},
+    {NULL, 66, 0x80FFFF0C, 0x00000000},
+    {NULL, 67, 0x80FFFF0C, 0x00000000},
+    {NULL, 68, 0x80FFFF0C, 0x00000000},
+    {NULL, 69, 0x80FFFF0C, 0x00000000},
+    {NULL, 70, 0x80FFFF0C, 0x00000000},
+    {NULL, 71, 0x80FFFF0C, 0x00000000},
+    {NULL, 72, 0x80FFFF0C, 0x00000000},
+    {NULL, 73, 0x80FFFF0C, 0x00000000},
+    {NULL, 74, 0x80FFFF0C, 0x00000000},
+    {NULL, 75, 0x80FFFF0C, 0x00000000},
+    {NULL, 76, 0x80FFFF0C, 0x00000000},
+    {NULL, 77, 0x80FFFF0C, 0x00000000},
+    {NULL, 78, 0x80FFFF0C, 0x00000000},
+    {NULL, 79, 0x80FFFF0C, 0x00000000},
 };
 
 const DIDATAFORMAT c_dfDIJoystick = { 24, 16, 0x00000001, 80, 44, JOY_fmt };
 
 
 /* Initialization/Query functions */
-static int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat);
-static SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
-static SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int DX5_VideoInit(_THIS, SDL_PixelFormat * vformat);
+static SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat * format,
+                                Uint32 flags);
+static SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface * current, int width,
+                                     int height, int bpp, Uint32 flags);
 static int DX5_SetColors(_THIS, int firstcolor, int ncolors,
-			 SDL_Color *colors);
-static int DX5_SetGammaRamp(_THIS, Uint16 *ramp);
-static int DX5_GetGammaRamp(_THIS, Uint16 *ramp);
+                         SDL_Color * colors);
+static int DX5_SetGammaRamp(_THIS, Uint16 * ramp);
+static int DX5_GetGammaRamp(_THIS, Uint16 * ramp);
 static void DX5_VideoQuit(_THIS);
 
 /* Hardware surface functions */
-static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface);
-static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
-static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
-static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
-static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
-static int DX5_LockHWSurface(_THIS, SDL_Surface *surface);
-static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface);
-static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface);
-static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface);
+static int DX5_AllocHWSurface(_THIS, SDL_Surface * surface);
+static int DX5_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dst);
+static int DX5_FillHWRect(_THIS, SDL_Surface * dst, SDL_Rect * dstrect,
+                          Uint32 color);
+static int DX5_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key);
+static int DX5_SetHWAlpha(_THIS, SDL_Surface * surface, Uint8 alpha);
+static int DX5_LockHWSurface(_THIS, SDL_Surface * surface);
+static void DX5_UnlockHWSurface(_THIS, SDL_Surface * surface);
+static int DX5_FlipHWSurface(_THIS, SDL_Surface * surface);
+static void DX5_FreeHWSurface(_THIS, SDL_Surface * surface);
 
-static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, 
-				LPDIRECTDRAWSURFACE3 requested, Uint32 flag);
+static int DX5_AllocDDSurface(_THIS, SDL_Surface * surface,
+                              LPDIRECTDRAWSURFACE3 requested, Uint32 flag);
 
 /* Windows message handling functions */
 static void DX5_RealizePalette(_THIS);
@@ -432,1709 +438,1764 @@
 static void DX5_WinPAINT(_THIS, HDC hdc);
 
 /* WinDIB driver functions for manipulating gamma ramps */
-extern int DIB_SetGammaRamp(_THIS, Uint16 *ramp);
-extern int DIB_GetGammaRamp(_THIS, Uint16 *ramp);
+extern int DIB_SetGammaRamp(_THIS, Uint16 * ramp);
+extern int DIB_GetGammaRamp(_THIS, Uint16 * ramp);
 extern void DIB_QuitGamma(_THIS);
 
-/* DX5 driver bootstrap functions */
-
-static int DX5_Available(void)
-{
-	HINSTANCE DInputDLL;
-	HINSTANCE DDrawDLL;
-	int dinput_ok;
-	int ddraw_ok;
-
-	/* Version check DINPUT.DLL and DDRAW.DLL (Is DirectX okay?) */
-	dinput_ok = 0;
-	DInputDLL = LoadLibrary(TEXT("DINPUT.DLL"));
-	if ( DInputDLL != NULL ) {
-		dinput_ok = 1;
-	  	FreeLibrary(DInputDLL);
-	}
-	ddraw_ok = 0;
-	DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL"));
-	if ( DDrawDLL != NULL ) {
-	  HRESULT (WINAPI *DDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
-	  LPDIRECTDRAW DDraw;
-
-	  /* Try to create a valid DirectDraw object */
-	  DDrawCreate = (void *)GetProcAddress(DDrawDLL, TEXT("DirectDrawCreate"));
-	  if ( (DDrawCreate != NULL)
-			&& !FAILED(DDrawCreate(NULL, &DDraw, NULL)) ) {
-	    if ( !FAILED(IDirectDraw_SetCooperativeLevel(DDraw,
-							NULL, DDSCL_NORMAL)) ) {
-	      DDSURFACEDESC desc;
-	      LPDIRECTDRAWSURFACE  DDrawSurf;
-	      LPDIRECTDRAWSURFACE3 DDrawSurf3;
-
-	      /* Try to create a DirectDrawSurface3 object */
-	      SDL_memset(&desc, 0, sizeof(desc));
-	      desc.dwSize = sizeof(desc);
-	      desc.dwFlags = DDSD_CAPS;
-	      desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY;
-	      if ( !FAILED(IDirectDraw_CreateSurface(DDraw, &desc,
-							&DDrawSurf, NULL)) ) {
-	        if ( !FAILED(IDirectDrawSurface_QueryInterface(DDrawSurf,
-			&IID_IDirectDrawSurface3, (LPVOID *)&DDrawSurf3)) ) {
-	          /* Yay! */
-		  ddraw_ok = 1;
-
-	          /* Clean up.. */
-	          IDirectDrawSurface3_Release(DDrawSurf3);
-	        }
-	        IDirectDrawSurface_Release(DDrawSurf);
-	      }
-	    }
-	    IDirectDraw_Release(DDraw);
-	  }
-	  FreeLibrary(DDrawDLL);
-	}
-	return(dinput_ok && ddraw_ok);
-}
-
 /* Functions for loading the DirectX functions dynamically */
+static int DX5_loaded = 0;
 static HINSTANCE DDrawDLL = NULL;
 static HINSTANCE DInputDLL = NULL;
 
-static void DX5_Unload(void)
+void
+DX5_Unload(void)
 {
-	if ( DDrawDLL != NULL ) {
-		FreeLibrary(DDrawDLL);
-		DDrawCreate = NULL;
-		DDrawDLL = NULL;
-	}
-	if ( DInputDLL != NULL ) {
-		FreeLibrary(DInputDLL);
-		DInputCreate = NULL;
-		DInputDLL = NULL;
-	}
+    if (--DX5_loaded == 0) {
+        if (DDrawDLL != NULL) {
+            FreeLibrary(DDrawDLL);
+            DDrawCreate = NULL;
+            DDrawDLL = NULL;
+        }
+        if (DInputDLL != NULL) {
+            FreeLibrary(DInputDLL);
+            DInputCreate = NULL;
+            DInputDLL = NULL;
+        }
+    }
 }
-static int DX5_Load(void)
+int
+DX5_Load(void)
 {
-	int status;
+    int status = 0;
 
-	DX5_Unload();
-	DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL"));
-	if ( DDrawDLL != NULL ) {
-		DDrawCreate = (void *)GetProcAddress(DDrawDLL,
-					TEXT("DirectDrawCreate"));
-	}
-	DInputDLL = LoadLibrary(TEXT("DINPUT.DLL"));
-	if ( DInputDLL != NULL ) {
-		DInputCreate = (void *)GetProcAddress(DInputDLL,
-					TEXT("DirectInputCreateA"));
-	}
-	if ( DDrawDLL && DDrawCreate && DInputDLL && DInputCreate ) {
-		status = 0;
-	} else {
-		DX5_Unload();
-		status = -1;
-	}
-	return status;
+    if (++DX5_loaded == 1) {
+        DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL"));
+        if (DDrawDLL != NULL) {
+            DDrawCreate = (void *) GetProcAddress(DDrawDLL,
+                                                  TEXT("DirectDrawCreate"));
+        }
+        DInputDLL = LoadLibrary(TEXT("DINPUT.DLL"));
+        if (DInputDLL != NULL) {
+            DInputCreate = (void *) GetProcAddress(DInputDLL,
+                                                   TEXT
+                                                   ("DirectInputCreateA"));
+        }
+        if (DDrawDLL && DDrawCreate && DInputDLL && DInputCreate) {
+            status = 0;
+        } else {
+            DX5_Unload();
+            status = -1;
+        }
+    }
+    return status;
 }
 
-static void DX5_DeleteDevice(SDL_VideoDevice *this)
+/* DX5 driver bootstrap functions */
+
+static int
+DX5_Available(void)
 {
-	/* Free DirectDraw object */
-	if ( ddraw2 != NULL ) {
-		IDirectDraw2_Release(ddraw2);
-	}
-	DX5_Unload();
-	if ( this ) {
-		if ( this->hidden ) {
-			SDL_free(this->hidden);
-		}
-		if ( this->gl_data ) {
-			SDL_free(this->gl_data);
-		}
-		SDL_free(this);
-	}
+    int ddraw_ok = 0;
+    HRESULT(WINAPI * DDrawCreate) (GUID *, LPDIRECTDRAW *, IUnknown *);
+    LPDIRECTDRAW DDraw;
+
+    /* Version check DINPUT.DLL and DDRAW.DLL (Is DirectX okay?) */
+    if (DX5_Load() < 0) {
+        return -1;
+    }
+
+    /* Try to create a valid DirectDraw object */
+    DDrawCreate = (void *) GetProcAddress(DDrawDLL, TEXT("DirectDrawCreate"));
+    if ((DDrawCreate != NULL) && !FAILED(DDrawCreate(NULL, &DDraw, NULL))) {
+        if (!FAILED(IDirectDraw_SetCooperativeLevel(DDraw,
+                                                    NULL, DDSCL_NORMAL))) {
+            DDSURFACEDESC desc;
+            LPDIRECTDRAWSURFACE DDrawSurf;
+            LPDIRECTDRAWSURFACE3 DDrawSurf3;
+
+            /* Try to create a DirectDrawSurface3 object */
+            SDL_memset(&desc, 0, sizeof(desc));
+            desc.dwSize = sizeof(desc);
+            desc.dwFlags = DDSD_CAPS;
+            desc.ddsCaps.dwCaps =
+                DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY;
+            if (!FAILED
+                (IDirectDraw_CreateSurface(DDraw, &desc, &DDrawSurf, NULL))) {
+                if (!FAILED
+                    (IDirectDrawSurface_QueryInterface
+                     (DDrawSurf, &IID_IDirectDrawSurface3,
+                      (LPVOID *) & DDrawSurf3))) {
+                    /* Yay! */
+                    ddraw_ok = 1;
+
+                    /* Clean up.. */
+                    IDirectDrawSurface3_Release(DDrawSurf3);
+                }
+                IDirectDrawSurface_Release(DDrawSurf);
+            }
+        }
+        IDirectDraw_Release(DDraw);
+    }
+
+    DX5_Unload();
+
+    return ddraw_ok;
 }
 
-static SDL_VideoDevice *DX5_CreateDevice(int devindex)
+static void
+DX5_DeleteDevice(SDL_VideoDevice * this)
 {
-	SDL_VideoDevice *device;
+    /* Free DirectDraw object */
+    if (ddraw2 != NULL) {
+        IDirectDraw2_Release(ddraw2);
+    }
+    DX5_Unload();
 
-	/* Load DirectX */
-	if ( DX5_Load() < 0 ) {
-		return(NULL);
-	}
+    if (this) {
+        if (this->hidden) {
+            SDL_free(this->hidden);
+        }
+        if (this->gl_data) {
+            SDL_free(this->gl_data);
+        }
+        SDL_free(this);
+    }
+}
 
-	/* Initialize all variables that we clean on shutdown */
-	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
-	if ( device ) {
-		SDL_memset(device, 0, (sizeof *device));
-		device->hidden = (struct SDL_PrivateVideoData *)
-				SDL_malloc((sizeof *device->hidden));
-		device->gl_data = (struct SDL_PrivateGLData *)
-				SDL_malloc((sizeof *device->gl_data));
-	}
-	if ( (device == NULL) || (device->hidden == NULL) ||
-		                 (device->gl_data == NULL) ) {
-		SDL_OutOfMemory();
-		DX5_DeleteDevice(device);
-		return(NULL);
-	}
-	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
-	SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
+static SDL_VideoDevice *
+DX5_CreateDevice(int devindex)
+{
+    SDL_VideoDevice *device;
+
+    /* Load DirectX */
+    if (DX5_Load() < 0) {
+        return (NULL);
+    }
+
+    /* Initialize all variables that we clean on shutdown */
+    device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
+    if (device) {
+        SDL_memset(device, 0, (sizeof *device));
+        device->hidden = (struct SDL_PrivateVideoData *)
+            SDL_malloc((sizeof *device->hidden));
+        device->gl_data = (struct SDL_PrivateGLData *)
+            SDL_malloc((sizeof *device->gl_data));
+    }
+    if ((device == NULL) || (device->hidden == NULL) ||
+        (device->gl_data == NULL)) {
+        SDL_OutOfMemory();
+        DX5_DeleteDevice(device);
+        return (NULL);
+    }
+    SDL_memset(device->hidden, 0, (sizeof *device->hidden));
+    SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
 
-	/* Set the function pointers */
-	device->VideoInit = DX5_VideoInit;
-	device->ListModes = DX5_ListModes;
-	device->SetVideoMode = DX5_SetVideoMode;
-	device->UpdateMouse = WIN_UpdateMouse;
-	device->CreateYUVOverlay = DX5_CreateYUVOverlay;
-	device->SetColors = DX5_SetColors;
-	device->UpdateRects = NULL;
-	device->VideoQuit = DX5_VideoQuit;
-	device->AllocHWSurface = DX5_AllocHWSurface;
-	device->CheckHWBlit = DX5_CheckHWBlit;
-	device->FillHWRect = DX5_FillHWRect;
-	device->SetHWColorKey = DX5_SetHWColorKey;
-	device->SetHWAlpha = DX5_SetHWAlpha;
-	device->LockHWSurface = DX5_LockHWSurface;
-	device->UnlockHWSurface = DX5_UnlockHWSurface;
-	device->FlipHWSurface = DX5_FlipHWSurface;
-	device->FreeHWSurface = DX5_FreeHWSurface;
-	device->SetGammaRamp = DX5_SetGammaRamp;
-	device->GetGammaRamp = DX5_GetGammaRamp;
+    /* Set the function pointers */
+    device->VideoInit = DX5_VideoInit;
+    device->ListModes = DX5_ListModes;
+    device->SetVideoMode = DX5_SetVideoMode;
+    device->UpdateMouse = WIN_UpdateMouse;
+    device->CreateYUVOverlay = DX5_CreateYUVOverlay;
+    device->SetColors = DX5_SetColors;
+    device->UpdateRects = NULL;
+    device->VideoQuit = DX5_VideoQuit;
+    device->AllocHWSurface = DX5_AllocHWSurface;
+    device->CheckHWBlit = DX5_CheckHWBlit;
+    device->FillHWRect = DX5_FillHWRect;
+    device->SetHWColorKey = DX5_SetHWColorKey;
+    device->SetHWAlpha = DX5_SetHWAlpha;
+    device->LockHWSurface = DX5_LockHWSurface;
+    device->UnlockHWSurface = DX5_UnlockHWSurface;
+    device->FlipHWSurface = DX5_FlipHWSurface;
+    device->FreeHWSurface = DX5_FreeHWSurface;
+    device->SetGammaRamp = DX5_SetGammaRamp;
+    device->GetGammaRamp = DX5_GetGammaRamp;
 #if SDL_VIDEO_OPENGL
-	device->GL_LoadLibrary = WIN_GL_LoadLibrary;
-	device->GL_GetProcAddress = WIN_GL_GetProcAddress;
-	device->GL_GetAttribute = WIN_GL_GetAttribute;
-	device->GL_MakeCurrent = WIN_GL_MakeCurrent;
-	device->GL_SwapBuffers = WIN_GL_SwapBuffers;
+    device->GL_LoadLibrary = WIN_GL_LoadLibrary;
+    device->GL_GetProcAddress = WIN_GL_GetProcAddress;
+    device->GL_GetAttribute = WIN_GL_GetAttribute;
+    device->GL_MakeCurrent = WIN_GL_MakeCurrent;
+    device->GL_SwapBuffers = WIN_GL_SwapBuffers;
 #endif
-	device->SetCaption = WIN_SetWMCaption;
-	device->SetIcon = WIN_SetWMIcon;
-	device->IconifyWindow = WIN_IconifyWindow;
-	device->GrabInput = WIN_GrabInput;
-	device->GetWMInfo = WIN_GetWMInfo;
-	device->FreeWMCursor = WIN_FreeWMCursor;
-	device->CreateWMCursor = WIN_CreateWMCursor;
-	device->ShowWMCursor = WIN_ShowWMCursor;
-	device->WarpWMCursor = WIN_WarpWMCursor;
-	device->CheckMouseMode = WIN_CheckMouseMode;
-	device->InitOSKeymap = DX5_InitOSKeymap;
-	device->PumpEvents = DX5_PumpEvents;
+    device->SetCaption = WIN_SetWMCaption;
+    device->SetIcon = WIN_SetWMIcon;
+    device->IconifyWindow = WIN_IconifyWindow;
+    device->GrabInput = WIN_GrabInput;
+    device->GetWMInfo = WIN_GetWMInfo;
+    device->FreeWMCursor = WIN_FreeWMCursor;
+    device->CreateWMCursor = WIN_CreateWMCursor;
+    device->ShowWMCursor = WIN_ShowWMCursor;
+    device->WarpWMCursor = WIN_WarpWMCursor;
+    device->CheckMouseMode = WIN_CheckMouseMode;
+    device->InitOSKeymap = DX5_InitOSKeymap;
+    device->PumpEvents = DX5_PumpEvents;
 
-	/* Set up the windows message handling functions */
-	WIN_RealizePalette = DX5_RealizePalette;
-	WIN_PaletteChanged = DX5_PaletteChanged;
-	WIN_WinPAINT = DX5_WinPAINT;
-	HandleMessage = DX5_HandleMessage;
+    /* Set up the windows message handling functions */
+    WIN_RealizePalette = DX5_RealizePalette;
+    WIN_PaletteChanged = DX5_PaletteChanged;
+    WIN_WinPAINT = DX5_WinPAINT;
+    HandleMessage = DX5_HandleMessage;
 
-	device->free = DX5_DeleteDevice;
+    device->free = DX5_DeleteDevice;
 
-	/* We're finally ready */
-	return device;
+    /* We're finally ready */
+    return device;
 }
 
 VideoBootStrap DIRECTX_bootstrap = {
-	"directx", "Win95/98/2000 DirectX",
-	DX5_Available, DX5_CreateDevice
+    "directx", "Win95/98/2000 DirectX",
+    DX5_Available, DX5_CreateDevice
 };
 
-static int cmpmodes(const void *va, const void *vb)
+static int
+cmpmodes(const void *va, const void *vb)
 {
-    SDL_Rect *a = *(SDL_Rect **)va;
-    SDL_Rect *b = *(SDL_Rect **)vb;
-    if ( a->w == b->w )
+    SDL_Rect *a = *(SDL_Rect **) va;
+    SDL_Rect *b = *(SDL_Rect **) vb;
+    if (a->w == b->w)
         return b->h - a->h;
     else
         return b->w - a->w;
 }
 
-static HRESULT WINAPI EnumModes2(DDSURFACEDESC *desc, VOID *udata)
+static HRESULT WINAPI
+EnumModes2(DDSURFACEDESC * desc, VOID * udata)
 {
-	SDL_VideoDevice *this = (SDL_VideoDevice *)udata;
-	struct DX5EnumRect *enumrect;
+    SDL_VideoDevice *this = (SDL_VideoDevice *) udata;
+    struct DX5EnumRect *enumrect;
 #if defined(NONAMELESSUNION)
-	int bpp = desc->ddpfPixelFormat.u1.dwRGBBitCount;
-	int refreshRate = desc->u2.dwRefreshRate;
+    int bpp = desc->ddpfPixelFormat.u1.dwRGBBitCount;
+    int refreshRate = desc->u2.dwRefreshRate;
 #else
-	int bpp = desc->ddpfPixelFormat.dwRGBBitCount;
-	int refreshRate = desc->dwRefreshRate;
+    int bpp = desc->ddpfPixelFormat.dwRGBBitCount;
+    int refreshRate = desc->dwRefreshRate;
 #endif
-	int maxRefreshRate;
+    int maxRefreshRate;
 
-	if ( desc->dwWidth <= SDL_desktop_mode.dmPelsWidth &&
-	     desc->dwHeight <= SDL_desktop_mode.dmPelsHeight ) {
-		maxRefreshRate = SDL_desktop_mode.dmDisplayFrequency;
-	} else {
-		maxRefreshRate = 85;	/* safe value? */
-	}
+    if (desc->dwWidth <= SDL_desktop_mode.dmPelsWidth &&
+        desc->dwHeight <= SDL_desktop_mode.dmPelsHeight) {
+        maxRefreshRate = SDL_desktop_mode.dmDisplayFrequency;
+    } else {
+        maxRefreshRate = 85;    /* safe value? */
+    }
 
-	switch (bpp)  {
-		case 8:
-		case 16:
-		case 24:
-		case 32:
-			bpp /= 8; --bpp;
-			if ( enumlists[bpp] &&
-			     enumlists[bpp]->r.w == (Uint16)desc->dwWidth &&
-			     enumlists[bpp]->r.h == (Uint16)desc->dwHeight ) {
-				if ( refreshRate > enumlists[bpp]->refreshRate &&
-				     refreshRate <= maxRefreshRate ) {
-					enumlists[bpp]->refreshRate = refreshRate;
+    switch (bpp) {
+    case 8:
+    case 16:
+    case 24:
+    case 32:
+        bpp /= 8;
+        --bpp;
+        if (enumlists[bpp] &&
+            enumlists[bpp]->r.w == (Uint16) desc->dwWidth &&
+            enumlists[bpp]->r.h == (Uint16) desc->dwHeight) {
+            if (refreshRate > enumlists[bpp]->refreshRate &&
+                refreshRate <= maxRefreshRate) {
+                enumlists[bpp]->refreshRate = refreshRate;
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "New refresh rate for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate);
+                fprintf(stderr,
+                        "New refresh rate for %d bpp: %dx%d at %d Hz\n",
+                        (bpp + 1) * 8, (int) desc->dwWidth,
+                        (int) desc->dwHeight, refreshRate);
 #endif
-				}
-				break;
-			}
-			++SDL_nummodes[bpp];
-			enumrect = (struct DX5EnumRect*)SDL_malloc(sizeof(struct DX5EnumRect));
-			if ( !enumrect ) {
-				SDL_OutOfMemory();
-				return(DDENUMRET_CANCEL);
-			}
-			enumrect->refreshRate = refreshRate;
-			enumrect->r.x = 0;
-			enumrect->r.y = 0;
-			enumrect->r.w = (Uint16)desc->dwWidth;
-			enumrect->r.h = (Uint16)desc->dwHeight;
-			enumrect->next = enumlists[bpp];
-			enumlists[bpp] = enumrect;
+            }
+            break;
+        }
+        ++SDL_nummodes[bpp];
+        enumrect =
+            (struct DX5EnumRect *) SDL_malloc(sizeof(struct DX5EnumRect));
+        if (!enumrect) {
+            SDL_OutOfMemory();
+            return (DDENUMRET_CANCEL);
+        }
+        enumrect->refreshRate = refreshRate;
+        enumrect->r.x = 0;
+        enumrect->r.y = 0;
+        enumrect->r.w = (Uint16) desc->dwWidth;
+        enumrect->r.h = (Uint16) desc->dwHeight;
+        enumrect->next = enumlists[bpp];
+        enumlists[bpp] = enumrect;
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "New mode for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate);
+        fprintf(stderr, "New mode for %d bpp: %dx%d at %d Hz\n",
+                (bpp + 1) * 8, (int) desc->dwWidth, (int) desc->dwHeight,
+                refreshRate);
 #endif
-			break;
-	}
+        break;
+    }
 
-	return(DDENUMRET_OK);
+    return (DDENUMRET_OK);
 }
 
-void SetDDerror(const char *function, int code)
+void
+SetDDerror(const char *function, int code)
 {
-	static char *error;
-	static char  errbuf[1024];
+    static char *error;
+    static char errbuf[1024];
 
-	errbuf[0] = 0;
-	switch (code) {
-		case DDERR_GENERIC:
-			error = "Undefined error!";
-			break;
-		case DDERR_EXCEPTION:
-			error = "Exception encountered";
-			break;
-		case DDERR_INVALIDOBJECT:
-			error = "Invalid object";
-			break;
-		case DDERR_INVALIDPARAMS:
-			error = "Invalid parameters";
-			break;
-		case DDERR_NOTFOUND:
-			error = "Object not found";
-			break;
-		case DDERR_INVALIDRECT:
-			error = "Invalid rectangle";
-			break;
-		case DDERR_INVALIDCAPS:
-			error = "Invalid caps member";
-			break;
-		case DDERR_INVALIDPIXELFORMAT:
-			error = "Invalid pixel format";
-			break;
-		case DDERR_OUTOFMEMORY:
-			error = "Out of memory";
-			break;
-		case DDERR_OUTOFVIDEOMEMORY:
-			error = "Out of video memory";
-			break;
-		case DDERR_SURFACEBUSY:
-			error = "Surface busy";
-			break;
-		case DDERR_SURFACELOST:
-			error = "Surface was lost";
-			break;
-		case DDERR_WASSTILLDRAWING:
-			error = "DirectDraw is still drawing";
-			break;
-		case DDERR_INVALIDSURFACETYPE:
-			error = "Invalid surface type";
-			break;
-		case DDERR_NOEXCLUSIVEMODE:
-			error = "Not in exclusive access mode";
-			break;
-		case DDERR_NOPALETTEATTACHED:
-			error = "No palette attached";
-			break;
-		case DDERR_NOPALETTEHW:
-			error = "No palette hardware";
-			break;
-		case DDERR_NOT8BITCOLOR:
-			error = "Not 8-bit color";
-			break;
-		case DDERR_EXCLUSIVEMODEALREADYSET:
-			error = "Exclusive mode was already set";
-			break;
-		case DDERR_HWNDALREADYSET:
-			error = "Window handle already set";
-			break;
-		case DDERR_HWNDSUBCLASSED:
-			error = "Window handle is subclassed";
-			break;
-		case DDERR_NOBLTHW:
-			error = "No blit hardware";
-			break;
-		case DDERR_IMPLICITLYCREATED:
-			error = "Surface was implicitly created";
-			break;
-		case DDERR_INCOMPATIBLEPRIMARY:
-			error = "Incompatible primary surface";
-			break;
-		case DDERR_NOCOOPERATIVELEVELSET:
-			error = "No cooperative level set";
-			break;
-		case DDERR_NODIRECTDRAWHW:
-			error = "No DirectDraw hardware";
-			break;
-		case DDERR_NOEMULATION:
-			error = "No emulation available";
-			break;
-		case DDERR_NOFLIPHW:
-			error = "No flip hardware";
-			break;
-		case DDERR_NOTFLIPPABLE:
-			error = "Surface not flippable";
-			break;
-		case DDERR_PRIMARYSURFACEALREADYEXISTS:
-			error = "Primary surface already exists";
-			break;
-		case DDERR_UNSUPPORTEDMODE:
-			error = "Unsupported mode";
-			break;
-		case DDERR_WRONGMODE:
-			error = "Surface created in different mode";
-			break;
-		case DDERR_UNSUPPORTED:
-			error = "Operation not supported";
-			break;
-		case E_NOINTERFACE:
-			error = "Interface not present";
-			break;
-		default:
-			SDL_snprintf(errbuf, SDL_arraysize(errbuf),
-			         "%s: Unknown DirectDraw error: 0x%x",
-								function, code);
-			break;
-	}
-	if ( ! errbuf[0] ) {
-		SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function, error);
-	}
-	SDL_SetError("%s", errbuf);
-	return;
+    errbuf[0] = 0;
+    switch (code) {
+    case DDERR_GENERIC:
+        error = "Undefined error!";
+        break;
+    case DDERR_EXCEPTION:
+        error = "Exception encountered";
+        break;
+    case DDERR_INVALIDOBJECT:
+        error = "Invalid object";
+        break;
+    case DDERR_INVALIDPARAMS:
+        error = "Invalid parameters";
+        break;
+    case DDERR_NOTFOUND:
+        error = "Object not found";
+        break;
+    case DDERR_INVALIDRECT:
+        error = "Invalid rectangle";
+        break;
+    case DDERR_INVALIDCAPS:
+        error = "Invalid caps member";
+        break;
+    case DDERR_INVALIDPIXELFORMAT:
+        error = "Invalid pixel format";
+        break;
+    case DDERR_OUTOFMEMORY:
+        error = "Out of memory";
+        break;
+    case DDERR_OUTOFVIDEOMEMORY:
+        error = "Out of video memory";
+        break;
+    case DDERR_SURFACEBUSY:
+        error = "Surface busy";
+        break;
+    case DDERR_SURFACELOST:
+        error = "Surface was lost";
+        break;
+    case DDERR_WASSTILLDRAWING:
+        error = "DirectDraw is still drawing";
+        break;
+    case DDERR_INVALIDSURFACETYPE:
+        error = "Invalid surface type";
+        break;
+    case DDERR_NOEXCLUSIVEMODE:
+        error = "Not in exclusive access mode";
+        break;
+    case DDERR_NOPALETTEATTACHED:
+        error = "No palette attached";
+        break;
+    case DDERR_NOPALETTEHW:
+        error = "No palette hardware";
+        break;
+    case DDERR_NOT8BITCOLOR:
+        error = "Not 8-bit color";
+        break;
+    case DDERR_EXCLUSIVEMODEALREADYSET:
+        error = "Exclusive mode was already set";
+        break;
+    case DDERR_HWNDALREADYSET:
+        error = "Window handle already set";
+        break;
+    case DDERR_HWNDSUBCLASSED:
+        error = "Window handle is subclassed";
+        break;
+    case DDERR_NOBLTHW:
+        error = "No blit hardware";
+        break;
+    case DDERR_IMPLICITLYCREATED:
+        error = "Surface was implicitly created";
+        break;
+    case DDERR_INCOMPATIBLEPRIMARY:
+        error = "Incompatible primary surface";
+        break;
+    case DDERR_NOCOOPERATIVELEVELSET:
+        error = "No cooperative level set";
+        break;
+    case DDERR_NODIRECTDRAWHW:
+        error = "No DirectDraw hardware";
+        break;
+    case DDERR_NOEMULATION:
+        error = "No emulation available";
+        break;
+    case DDERR_NOFLIPHW:
+        error = "No flip hardware";
+        break;
+    case DDERR_NOTFLIPPABLE:
+        error = "Surface not flippable";
+        break;
+    case DDERR_PRIMARYSURFACEALREADYEXISTS:
+        error = "Primary surface already exists";
+        break;
+    case DDERR_UNSUPPORTEDMODE:
+        error = "Unsupported mode";
+        break;
+    case DDERR_WRONGMODE:
+        error = "Surface created in different mode";
+        break;
+    case DDERR_UNSUPPORTED:
+        error = "Operation not supported";
+        break;
+    case E_NOINTERFACE:
+        error = "Interface not present";
+        break;
+    default:
+        SDL_snprintf(errbuf, SDL_arraysize(errbuf),
+                     "%s: Unknown DirectDraw error: 0x%x", function, code);
+        break;
+    }
+    if (!errbuf[0]) {
+        SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function,
+                     error);
+    }
+    SDL_SetError("%s", errbuf);
+    return;
 }
 
 
-static int DX5_UpdateVideoInfo(_THIS)
+static int
+DX5_UpdateVideoInfo(_THIS)
 {
-	/* This needs to be DDCAPS_DX5 for the DirectDraw2 interface */
+    /* This needs to be DDCAPS_DX5 for the DirectDraw2 interface */
 #if DIRECTDRAW_VERSION <= 0x300
 #error Your version of DirectX must be greater than or equal to 5.0
 #endif
 #ifndef IDirectDrawGammaControl_SetGammaRamp
-	/*if gamma is undefined then we really have directx <= 0x500*/
-	DDCAPS DDCaps;
+    /*if gamma is undefined then we really have directx <= 0x500 */
+    DDCAPS DDCaps;
 #else
-	DDCAPS_DX5 DDCaps;
+    DDCAPS_DX5 DDCaps;
 #endif
-	HRESULT result;
+    HRESULT result;
 
-	/* Fill in our hardware acceleration capabilities */
-	SDL_memset(&DDCaps, 0, sizeof(DDCaps));
-	DDCaps.dwSize = sizeof(DDCaps);
-	result = IDirectDraw2_GetCaps(ddraw2, (DDCAPS *)&DDCaps, NULL);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDraw2::GetCaps", result);
-		return(-1);
-	}
-	this->info.hw_available = 1;
-	if ( (DDCaps.dwCaps & DDCAPS_BLT) == DDCAPS_BLT ) {
-		this->info.blit_hw = 1;
-	}
-	if ( ((DDCaps.dwCaps & DDCAPS_COLORKEY) == DDCAPS_COLORKEY) &&
-	     ((DDCaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) == DDCKEYCAPS_SRCBLT) ) {
-		this->info.blit_hw_CC = 1;
-	}
-	if ( (DDCaps.dwCaps & DDCAPS_ALPHA) == DDCAPS_ALPHA ) {
-		/* This is only for alpha channel, and DirectX 6
-		   doesn't support 2D alpha blits yet, so set it 0
-		 */
-		this->info.blit_hw_A = 0;
-	}
-	if ( (DDCaps.dwCaps & DDCAPS_CANBLTSYSMEM) == DDCAPS_CANBLTSYSMEM ) {
-		this->info.blit_sw = 1;
-		/* This isn't necessarily true, but the HEL will cover us */
-		this->info.blit_sw_CC = this->info.blit_hw_CC;
-		this->info.blit_sw_A = this->info.blit_hw_A;
-	}
-	if ( (DDCaps.dwCaps & DDCAPS_BLTCOLORFILL) == DDCAPS_BLTCOLORFILL ) {
-		this->info.blit_fill = 1;
-	}
+    /* Fill in our hardware acceleration capabilities */
+    SDL_memset(&DDCaps, 0, sizeof(DDCaps));
+    DDCaps.dwSize = sizeof(DDCaps);
+    result = IDirectDraw2_GetCaps(ddraw2, (DDCAPS *) & DDCaps, NULL);
+    if (result != DD_OK) {
+        SetDDerror("DirectDraw2::GetCaps", result);
+        return (-1);
+    }
+    this->info.hw_available = 1;
+    if ((DDCaps.dwCaps & DDCAPS_BLT) == DDCAPS_BLT) {
+        this->info.blit_hw = 1;
+    }
+    if (((DDCaps.dwCaps & DDCAPS_COLORKEY) == DDCAPS_COLORKEY) &&
+        ((DDCaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) == DDCKEYCAPS_SRCBLT)) {
+        this->info.blit_hw_CC = 1;
+    }
+    if ((DDCaps.dwCaps & DDCAPS_ALPHA) == DDCAPS_ALPHA) {
+        /* This is only for alpha channel, and DirectX 6
+           doesn't support 2D alpha blits yet, so set it 0
+         */
+        this->info.blit_hw_A = 0;
+    }
+    if ((DDCaps.dwCaps & DDCAPS_CANBLTSYSMEM) == DDCAPS_CANBLTSYSMEM) {
+        this->info.blit_sw = 1;
+        /* This isn't necessarily true, but the HEL will cover us */
+        this->info.blit_sw_CC = this->info.blit_hw_CC;
+        this->info.blit_sw_A = this->info.blit_hw_A;
+    }
+    if ((DDCaps.dwCaps & DDCAPS_BLTCOLORFILL) == DDCAPS_BLTCOLORFILL) {
+        this->info.blit_fill = 1;
+    }
 
-	/* Find out how much video memory is available */
-	{ DDSCAPS ddsCaps;
-	  DWORD total_mem;
-		ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
-		result = IDirectDraw2_GetAvailableVidMem(ddraw2,
-						&ddsCaps, &total_mem, NULL);
-		if ( result != DD_OK ) {
-			total_mem = DDCaps.dwVidMemTotal; 
-		}
-		this->info.video_mem = total_mem/1024;
-	}
-	return(0);
+    /* Find out how much video memory is available */
+    {
+        DDSCAPS ddsCaps;
+        DWORD total_mem;
+        ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
+        result = IDirectDraw2_GetAvailableVidMem(ddraw2,
+                                                 &ddsCaps, &total_mem, NULL);
+        if (result != DD_OK) {
+            total_mem = DDCaps.dwVidMemTotal;
+        }
+        this->info.video_mem = total_mem / 1024;
+    }
+    return (0);
 }
 
-int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat)
+int
+DX5_VideoInit(_THIS, SDL_PixelFormat * vformat)
 {
-	HRESULT result;
-	LPDIRECTDRAW ddraw;
-	int i, j;
-	HDC hdc;
+    HRESULT result;
+    LPDIRECTDRAW ddraw;
+    int i, j;
+    HDC hdc;
 
-	/* Intialize everything */
-	ddraw2 = NULL;
-	SDL_primary = NULL;
-	SDL_clipper = NULL;
-	SDL_palette = NULL;
-	for ( i=0; i<NUM_MODELISTS; ++i ) {
-		SDL_nummodes[i] = 0;
-		SDL_modelist[i] = NULL;
-		SDL_modeindex[i] = 0;
-	}
-	colorchange_expected = 0;
+    /* Intialize everything */
+    ddraw2 = NULL;
+    SDL_primary = NULL;
+    SDL_clipper = NULL;
+    SDL_palette = NULL;
+    for (i = 0; i < NUM_MODELISTS; ++i) {
+        SDL_nummodes[i] = 0;
+        SDL_modelist[i] = NULL;
+        SDL_modeindex[i] = 0;
+    }
+    colorchange_expected = 0;
 
-	/* Create the window */
-	if ( DX5_CreateWindow(this) < 0 ) {
-		return(-1);
-	}
-
+    /* Create the window */
+    if (DX5_CreateWindow(this) < 0) {
+        return (-1);
+    }
 #if !SDL_AUDIO_DISABLED
-	DX5_SoundFocus(SDL_Window);
+    DX5_SoundFocus(SDL_Window);
 #endif
 
-	/* Create the DirectDraw object */
-	result = DDrawCreate(NULL, &ddraw, NULL);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawCreate", result);
-		return(-1);
-	}
-	result = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw2,
-							(LPVOID *)&ddraw2);
-	IDirectDraw_Release(ddraw);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDraw::QueryInterface", result);
-		return(-1);
-	}
+    /* Create the DirectDraw object */
+    result = DDrawCreate(NULL, &ddraw, NULL);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawCreate", result);
+        return (-1);
+    }
+    result = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw2,
+                                        (LPVOID *) & ddraw2);
+    IDirectDraw_Release(ddraw);
+    if (result != DD_OK) {
+        SetDDerror("DirectDraw::QueryInterface", result);
+        return (-1);
+    }
 
-	/* Determine the screen depth */
-	hdc = GetDC(SDL_Window);
-	vformat->BitsPerPixel = GetDeviceCaps(hdc,PLANES) *
-					GetDeviceCaps(hdc,BITSPIXEL);
-	ReleaseDC(SDL_Window, hdc);
+    /* Determine the screen depth */
+    hdc = GetDC(SDL_Window);
+    vformat->BitsPerPixel = GetDeviceCaps(hdc, PLANES) *
+        GetDeviceCaps(hdc, BITSPIXEL);
+    ReleaseDC(SDL_Window, hdc);
 
 #ifndef NO_CHANGEDISPLAYSETTINGS
-	/* Query for the desktop resolution */
-	EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode);
-	this->info.current_w = SDL_desktop_mode.dmPelsWidth;
-	this->info.current_h = SDL_desktop_mode.dmPelsHeight;
+    /* Query for the desktop resolution */
+    EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode);
+    this->info.current_w = SDL_desktop_mode.dmPelsWidth;
+    this->info.current_h = SDL_desktop_mode.dmPelsHeight;
 #endif
 
-	/* Enumerate the available fullscreen modes */
-	for ( i=0; i<NUM_MODELISTS; ++i )
-		enumlists[i] = NULL;
+    /* Enumerate the available fullscreen modes */
+    for (i = 0; i < NUM_MODELISTS; ++i)
+        enumlists[i] = NULL;
 
-	result = IDirectDraw2_EnumDisplayModes(ddraw2,DDEDM_REFRESHRATES,NULL,this,EnumModes2);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDraw2::EnumDisplayModes", result);
-		return(-1);
-	}
-	for ( i=0; i<NUM_MODELISTS; ++i ) {
-		struct DX5EnumRect *rect;
-		SDL_modelist[i] = (SDL_Rect **)
-				SDL_malloc((SDL_nummodes[i]+1)*sizeof(SDL_Rect *));
-		if ( SDL_modelist[i] == NULL ) {
-			SDL_OutOfMemory();
-			return(-1);
-		}
-		for ( j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next ) {
-			SDL_modelist[i][j] = &rect->r;
-		}
-		SDL_modelist[i][j] = NULL;
+    result =
+        IDirectDraw2_EnumDisplayModes(ddraw2, DDEDM_REFRESHRATES, NULL, this,
+                                      EnumModes2);
+    if (result != DD_OK) {
+        SetDDerror("DirectDraw2::EnumDisplayModes", result);
+        return (-1);
+    }
+    for (i = 0; i < NUM_MODELISTS; ++i) {
+        struct DX5EnumRect *rect;
+        SDL_modelist[i] = (SDL_Rect **)
+            SDL_malloc((SDL_nummodes[i] + 1) * sizeof(SDL_Rect *));
+        if (SDL_modelist[i] == NULL) {
+            SDL_OutOfMemory();
+            return (-1);
+        }
+        for (j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next) {
+            SDL_modelist[i][j] = &rect->r;
+        }
+        SDL_modelist[i][j] = NULL;
 
-		if ( SDL_nummodes[i] > 0 ) {
-			SDL_qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes);
-		}
-	}
-	
-	/* Fill in some window manager capabilities */
-	this->info.wm_available = 1;
+        if (SDL_nummodes[i] > 0) {
+            SDL_qsort(SDL_modelist[i], SDL_nummodes[i],
+                      sizeof *SDL_modelist[i], cmpmodes);
+        }
+    }
 
-	/* Fill in the video hardware capabilities */
-	DX5_UpdateVideoInfo(this);
+    /* Fill in some window manager capabilities */
+    this->info.wm_available = 1;
 
-	return(0);
+    /* Fill in the video hardware capabilities */
+    DX5_UpdateVideoInfo(this);
+
+    return (0);
 }
 
-SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+SDL_Rect **
+DX5_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
 {
-	int bpp;
+    int bpp;
 
-	bpp = format->BitsPerPixel;
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		/* FIXME:  No support for 1 bpp or 4 bpp formats */
-		switch (bpp) {  /* Does windows support other BPP? */
-			case 8:
-			case 16:
-			case 24:
-			case 32:
-				bpp = (bpp/8)-1;
-				if ( SDL_nummodes[bpp] > 0 )
-					return(SDL_modelist[bpp]);
-				/* Fall through */
-			default:
-				return((SDL_Rect **)0);
-		}
-	} else {
-		if ( this->screen->format->BitsPerPixel == bpp ) {
-			return((SDL_Rect **)-1);
-		} else {
-			return((SDL_Rect **)0);
-		}
-	}
+    bpp = format->BitsPerPixel;
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        /* FIXME:  No support for 1 bpp or 4 bpp formats */
+        switch (bpp) {          /* Does windows support other BPP? */
+        case 8:
+        case 16:
+        case 24:
+        case 32:
+            bpp = (bpp / 8) - 1;
+            if (SDL_nummodes[bpp] > 0)
+                return (SDL_modelist[bpp]);
+            /* Fall through */
+        default:
+            return ((SDL_Rect **) 0);
+        }
+    } else {
+        if (this->screen->format->BitsPerPixel == bpp) {
+            return ((SDL_Rect **) - 1);
+        } else {
+            return ((SDL_Rect **) 0);
+        }
+    }
 }
 
 /* Various screen update functions available */
-static void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects);
-static void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
+static void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect * rects);
+static void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect * rects);
 
-SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current,
-				int width, int height, int bpp, Uint32 flags)
+SDL_Surface *
+DX5_SetVideoMode(_THIS, SDL_Surface * current,
+                 int width, int height, int bpp, Uint32 flags)
 {
-	SDL_Surface *video;
-	HRESULT result;
-	DWORD sharemode;
-	DWORD style;
-	const DWORD directstyle =
-			(WS_POPUP);
-	const DWORD windowstyle = 
-			(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX);
-	const DWORD resizestyle =
-			(WS_THICKFRAME|WS_MAXIMIZEBOX);
-	DDSURFACEDESC ddsd;
-	LPDIRECTDRAWSURFACE  dd_surface1;
-	LPDIRECTDRAWSURFACE3 dd_surface3;
+    SDL_Surface *video;
+    HRESULT result;
+    DWORD sharemode;
+    DWORD style;
+    const DWORD directstyle = (WS_POPUP);
+    const DWORD windowstyle =
+        (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
+    const DWORD resizestyle = (WS_THICKFRAME | WS_MAXIMIZEBOX);
+    DDSURFACEDESC ddsd;
+    LPDIRECTDRAWSURFACE dd_surface1;
+    LPDIRECTDRAWSURFACE3 dd_surface3;
 
-	SDL_resizing = 1;
+    SDL_resizing = 1;
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "Setting %dx%dx%d video mode\n", width, height, bpp);
+    fprintf(stderr, "Setting %dx%dx%d video mode\n", width, height, bpp);
 #endif
-	/* Clean up any previous DirectDraw surfaces */
-	if ( current->hwdata ) {
-		this->FreeHWSurface(this, current);
-		current->hwdata = NULL;
-	}
-	if ( SDL_primary != NULL ) {
-		IDirectDrawSurface3_Release(SDL_primary);
-		SDL_primary = NULL;
-	}
-
+    /* Clean up any previous DirectDraw surfaces */
+    if (current->hwdata) {
+        this->FreeHWSurface(this, current);
+        current->hwdata = NULL;
+    }
+    if (SDL_primary != NULL) {
+        IDirectDrawSurface3_Release(SDL_primary);
+        SDL_primary = NULL;
+    }
 #ifndef NO_CHANGEDISPLAYSETTINGS
-	/* Unset any previous OpenGL fullscreen mode */
-	if ( (current->flags & (SDL_OPENGL|SDL_FULLSCREEN)) ==
-	                       (SDL_OPENGL|SDL_FULLSCREEN) ) {
-		ChangeDisplaySettings(NULL, 0);
-	}
+    /* Unset any previous OpenGL fullscreen mode */
+    if ((current->flags & (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) ==
+        (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) {
+        ChangeDisplaySettings(NULL, 0);
+    }
 #endif
 
-	/* Clean up any GL context that may be hanging around */
-	if ( current->flags & SDL_OPENGL ) {
-		WIN_GL_ShutDown(this);
-	}
+    /* Clean up any GL context that may be hanging around */
+    if (current->flags & SDL_INTERNALOPENGL) {
+        WIN_GL_ShutDown(this);
+    }
 
-	/* If we are setting a GL mode, use GDI, not DirectX (yuck) */
-	if ( flags & SDL_OPENGL ) {
-		Uint32 Rmask, Gmask, Bmask;
+    /* If we are setting a GL mode, use GDI, not DirectX (yuck) */
+    if (flags & SDL_INTERNALOPENGL) {
+        Uint32 Rmask, Gmask, Bmask;
 
-		/* Recalculate the bitmasks if necessary */
-		if ( bpp == current->format->BitsPerPixel ) {
-			video = current;
-		} else {
-			switch (bpp) {
-			    case 15:
-			    case 16:
-				if ( 0 /*DIB_SussScreenDepth() == 15*/ ) {
-					/* 5-5-5 */
-					Rmask = 0x00007c00;
-					Gmask = 0x000003e0;
-					Bmask = 0x0000001f;
-				} else {
-					/* 5-6-5 */
-					Rmask = 0x0000f800;
-					Gmask = 0x000007e0;
-					Bmask = 0x0000001f;
-				}
-				break;
-			    case 24:
-			    case 32:
-				/* GDI defined as 8-8-8 */
-				Rmask = 0x00ff0000;
-				Gmask = 0x0000ff00;
-				Bmask = 0x000000ff;
-				break;
-			    default:
-				Rmask = 0x00000000;
-				Gmask = 0x00000000;
-				Bmask = 0x00000000;
-				break;
-			}
-			video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp,
-			                             Rmask, Gmask, Bmask, 0);
-			if ( video == NULL ) {
-				SDL_OutOfMemory();
-				return(NULL);
-			}
-		}
+        /* Recalculate the bitmasks if necessary */
+        if (bpp == current->format->BitsPerPixel) {
+            video = current;
+        } else {
+            switch (bpp) {
+            case 15:
+            case 16:
+                if (0 /*DIB_SussScreenDepth() == 15 */ ) {
+                    /* 5-5-5 */
+                    Rmask = 0x00007c00;
+                    Gmask = 0x000003e0;
+                    Bmask = 0x0000001f;
+                } else {
+                    /* 5-6-5 */
+                    Rmask = 0x0000f800;
+                    Gmask = 0x000007e0;
+                    Bmask = 0x0000001f;
+                }
+                break;
+            case 24:
+            case 32:
+                /* GDI defined as 8-8-8 */
+                Rmask = 0x00ff0000;
+                Gmask = 0x0000ff00;
+                Bmask = 0x000000ff;
+                break;
+            default:
+                Rmask = 0x00000000;
+                Gmask = 0x00000000;
+                Bmask = 0x00000000;
+                break;
+            }
+            video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp,
+                                         Rmask, Gmask, Bmask, 0);
+            if (video == NULL) {
+                SDL_OutOfMemory();
+                return (NULL);
+            }
+        }
 
-		/* Fill in part of the video surface */
-		video->flags = 0;	/* Clear flags */
-		video->w = width;
-		video->h = height;
-		video->pitch = SDL_CalculatePitch(video);
+        /* Fill in part of the video surface */
+        video->flags = 0;       /* Clear flags */
+        video->w = width;
+        video->h = height;
+        video->pitch = SDL_CalculatePitch(video);
 
 #ifndef NO_CHANGEDISPLAYSETTINGS
-		/* Set fullscreen mode if appropriate.
-		   Ugh, since our list of valid video modes comes from
-		   the DirectX driver, we may not actually be able to
-		   change to the desired resolution here.
-		   FIXME: Should we do a closest match?
-		 */
-		if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-			DEVMODE settings;
-			BOOL changed;
+        /* Set fullscreen mode if appropriate.
+           Ugh, since our list of valid video modes comes from
+           the DirectX driver, we may not actually be able to
+           change to the desired resolution here.
+           FIXME: Should we do a closest match?
+         */
+        if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+            DEVMODE settings;
+            BOOL changed;
 
-			SDL_memset(&settings, 0, sizeof(DEVMODE));
-			settings.dmSize = sizeof(DEVMODE);
-			settings.dmBitsPerPel = video->format->BitsPerPixel;
-			settings.dmPelsWidth = width;
-			settings.dmPelsHeight = height;
-			settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
-			if ( width <= (int)SDL_desktop_mode.dmPelsWidth &&
-			     height <= (int)SDL_desktop_mode.dmPelsHeight ) {
-				settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency;
-				settings.dmFields |= DM_DISPLAYFREQUENCY;
-			}
-			changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
-			if ( ! changed && (settings.dmFields & DM_DISPLAYFREQUENCY) ) {
-				settings.dmFields &= ~DM_DISPLAYFREQUENCY;
-				changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
-			}
-			if ( changed ) {
-				video->flags |= SDL_FULLSCREEN;
-				SDL_fullscreen_mode = settings;
-			}
-		}
+            SDL_memset(&settings, 0, sizeof(DEVMODE));
+            settings.dmSize = sizeof(DEVMODE);
+            settings.dmBitsPerPel = video->format->BitsPerPixel;
+            settings.dmPelsWidth = width;
+            settings.dmPelsHeight = height;
+            settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
+            if (width <= (int) SDL_desktop_mode.dmPelsWidth
+                && height <= (int) SDL_desktop_mode.dmPelsHeight) {
+                settings.dmDisplayFrequency =
+                    SDL_desktop_mode.dmDisplayFrequency;
+                settings.dmFields |= DM_DISPLAYFREQUENCY;
+            }
+            changed =
+                (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) ==
+                 DISP_CHANGE_SUCCESSFUL);
+            if (!changed && (settings.dmFields & DM_DISPLAYFREQUENCY)) {
+                settings.dmFields &= ~DM_DISPLAYFREQUENCY;
+                changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN)
+                           == DISP_CHANGE_SUCCESSFUL);
+            }
+            if (changed) {
+                video->flags |= SDL_FULLSCREEN;
+                SDL_fullscreen_mode = settings;
+            }
+        }
 #endif /* !NO_CHANGEDISPLAYSETTINGS */
 
-		style = GetWindowLong(SDL_Window, GWL_STYLE);
-		style &= ~(resizestyle|WS_MAXIMIZE);
-		if ( video->flags & SDL_FULLSCREEN ) {
-			style &= ~windowstyle;
-			style |= directstyle;
-		} else {
-			if ( flags & SDL_NOFRAME ) {
-				style &= ~windowstyle;
-				style |= directstyle;
-				video->flags |= SDL_NOFRAME;
-			} else {
-				style &= ~directstyle;
-				style |= windowstyle;
-				if ( flags & SDL_RESIZABLE ) {
-					style |= resizestyle;
-					video->flags |= SDL_RESIZABLE;
-				}
-			}
+        style = GetWindowLong(SDL_Window, GWL_STYLE);
+        style &= ~(resizestyle | WS_MAXIMIZE);
+        if (video->flags & SDL_FULLSCREEN) {
+            style &= ~windowstyle;
+            style |= directstyle;
+        } else {
+            if (flags & SDL_NOFRAME) {
+                style &= ~windowstyle;
+                style |= directstyle;
+                video->flags |= SDL_NOFRAME;
+            } else {
+                style &= ~directstyle;
+                style |= windowstyle;
+                if (flags & SDL_RESIZABLE) {
+                    style |= resizestyle;
+                    video->flags |= SDL_RESIZABLE;
+                }
+            }
 #if WS_MAXIMIZE
-			if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE;
+            if (IsZoomed(SDL_Window))
+                style |= WS_MAXIMIZE;
 #endif
-		}
+        }
 
-		/* DJM: Don't piss of anyone who has setup his own window */
-		if ( !SDL_windowid )
-			SetWindowLong(SDL_Window, GWL_STYLE, style);
+        /* DJM: Don't piss of anyone who has setup his own window */
+        if (!SDL_windowid)
+            SetWindowLong(SDL_Window, GWL_STYLE, style);
 
-		/* Resize the window (copied from SDL WinDIB driver) */
-		if ( !SDL_windowid && !IsZoomed(SDL_Window) ) {
-			RECT bounds;
-			int x, y;
-			HWND top;
-			UINT swp_flags;
-			const char *window = NULL;
-			const char *center = NULL;
+        /* Resize the window (copied from SDL WinDIB driver) */
+        if (!SDL_windowid && !IsZoomed(SDL_Window)) {
+            RECT bounds;
+            int x, y;
+            HWND top;
+            UINT swp_flags;
+            const char *window = NULL;
+            const char *center = NULL;
 
-			if ( !SDL_windowX && !SDL_windowY ) {
-				window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
-				center = SDL_getenv("SDL_VIDEO_CENTERED");
-				if ( window ) {
-					if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) {
-						SDL_windowX = x;
-						SDL_windowY = y;
-					}
-					if ( SDL_strcmp(window, "center") == 0 ) {
-						center = window;
-					}
-				}
-			}
-			swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
+            if (!SDL_windowX && !SDL_windowY) {
+                window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
+                center = SDL_getenv("SDL_VIDEO_CENTERED");
+                if (window) {
+                    if (SDL_sscanf(window, "%d,%d", &x, &y) == 2) {
+                        SDL_windowX = x;
+                        SDL_windowY = y;
+                    }
+                    if (SDL_strcmp(window, "center") == 0) {
+                        center = window;
+                    }
+                }
+            }
+            swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
 
-			bounds.left = SDL_windowX;
-			bounds.top = SDL_windowY;
-			bounds.right = SDL_windowX+video->w;
-			bounds.bottom = SDL_windowY+video->h;
-			AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), (GetMenu(SDL_Window) != NULL), 0);
-			width = bounds.right-bounds.left;
-			height = bounds.bottom-bounds.top;
-			if ( (flags & SDL_FULLSCREEN) ) {
-				x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
-				y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
-			} else if ( center ) {
-				x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
-				y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
-			} else if ( SDL_windowX || SDL_windowY || window ) {
-				x = bounds.left;
-				y = bounds.top;
-			} else {
-				x = y = -1;
-				swp_flags |= SWP_NOMOVE;
-			}
-			if ( flags & SDL_FULLSCREEN ) {
-				top = HWND_TOPMOST;
-			} else {
-				top = HWND_NOTOPMOST;
-			}
-			SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags);
-			if ( !(flags & SDL_FULLSCREEN) ) {
-				SDL_windowX = SDL_bounds.left;
-				SDL_windowY = SDL_bounds.top;
-			}
-			SetForegroundWindow(SDL_Window);
-		}
-		SDL_resizing = 0;
+            bounds.left = SDL_windowX;
+            bounds.top = SDL_windowY;
+            bounds.right = SDL_windowX + video->w;
+            bounds.bottom = SDL_windowY + video->h;
+            AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE),
+                               (GetMenu(SDL_Window) != NULL), 0);
+            width = bounds.right - bounds.left;
+            height = bounds.bottom - bounds.top;
+            if ((flags & SDL_FULLSCREEN)) {
+                x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
+                y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
+            } else if (center) {
+                x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
+                y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
+            } else if (SDL_windowX || SDL_windowY || window) {
+                x = bounds.left;
+                y = bounds.top;
+            } else {
+                x = y = -1;
+                swp_flags |= SWP_NOMOVE;
+            }
+            if (flags & SDL_FULLSCREEN) {
+                top = HWND_TOPMOST;
+            } else {
+                top = HWND_NOTOPMOST;
+            }
+            SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags);
+            if (!(flags & SDL_FULLSCREEN)) {
+                SDL_windowX = SDL_bounds.left;
+                SDL_windowY = SDL_bounds.top;
+            }
+            SetForegroundWindow(SDL_Window);
+        }
+        SDL_resizing = 0;
 
-		/* Set up for OpenGL */
-		if ( WIN_GL_SetupWindow(this) < 0 ) {
-			return(NULL);
-		}
-		video->flags |= SDL_OPENGL;
-		return(video);
-	}
+        /* Set up for OpenGL */
+        if (WIN_GL_SetupWindow(this) < 0) {
+            return (NULL);
+        }
+        video->flags |= SDL_INTERNALOPENGL;
+        return (video);
+    }
 
-	/* Set the appropriate window style */
-	style = GetWindowLong(SDL_Window, GWL_STYLE);
-	style &= ~(resizestyle|WS_MAXIMIZE);
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		style &= ~windowstyle;
-		style |= directstyle;
-	} else {
-		if ( flags & SDL_NOFRAME ) {
-			style &= ~windowstyle;
-			style |= directstyle;
-		} else {
-			style &= ~directstyle;
-			style |= windowstyle;
-			if ( flags & SDL_RESIZABLE ) {
-				style |= resizestyle;
-			}
-		}
+    /* Set the appropriate window style */
+    style = GetWindowLong(SDL_Window, GWL_STYLE);
+    style &= ~(resizestyle | WS_MAXIMIZE);
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        style &= ~windowstyle;
+        style |= directstyle;
+    } else {
+        if (flags & SDL_NOFRAME) {
+            style &= ~windowstyle;
+            style |= directstyle;
+        } else {
+            style &= ~directstyle;
+            style |= windowstyle;
+            if (flags & SDL_RESIZABLE) {
+                style |= resizestyle;
+            }
+        }
 #if WS_MAXIMIZE
-		if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE;
+        if (IsZoomed(SDL_Window))
+            style |= WS_MAXIMIZE;
 #endif
-	}
-	/* DJM: Don't piss of anyone who has setup his own window */
-	if ( !SDL_windowid )
-		SetWindowLong(SDL_Window, GWL_STYLE, style);
+    }
+    /* DJM: Don't piss of anyone who has setup his own window */
+    if (!SDL_windowid)
+        SetWindowLong(SDL_Window, GWL_STYLE, style);
 
-	/* Set DirectDraw sharing mode.. exclusive when fullscreen */
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		sharemode = DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE|DDSCL_ALLOWREBOOT;
-	} else {
-		sharemode = DDSCL_NORMAL;
-	}
-	result = IDirectDraw2_SetCooperativeLevel(ddraw2,SDL_Window,sharemode);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDraw2::SetCooperativeLevel", result);
-		return(NULL);
-	}
+    /* Set DirectDraw sharing mode.. exclusive when fullscreen */
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        sharemode = DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT;
+    } else {
+        sharemode = DDSCL_NORMAL;
+    }
+    result = IDirectDraw2_SetCooperativeLevel(ddraw2, SDL_Window, sharemode);
+    if (result != DD_OK) {
+        SetDDerror("DirectDraw2::SetCooperativeLevel", result);
+        return (NULL);
+    }
 
-	/* Set the display mode, if we are in fullscreen mode */
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		RECT bounds;
-		struct DX5EnumRect *rect;
-		int maxRefreshRate;
+    /* Set the display mode, if we are in fullscreen mode */
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        RECT bounds;
+        struct DX5EnumRect *rect;
+        int maxRefreshRate;
 
-		/* Cover up desktop during mode change */
-		bounds.left = 0;
-		bounds.top = 0;
-		bounds.right = GetSystemMetrics(SM_CXSCREEN);
-		bounds.bottom = GetSystemMetrics(SM_CYSCREEN);
-		AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), (GetMenu(SDL_Window) != NULL), 0);
-		SetWindowPos(SDL_Window, HWND_TOPMOST,
-			bounds.left, bounds.top, 
-			bounds.right - bounds.left,
-			bounds.bottom - bounds.top, SWP_NOCOPYBITS);
-		ShowWindow(SDL_Window, SW_SHOW);
-		while ( GetForegroundWindow() != SDL_Window ) {
-			SetForegroundWindow(SDL_Window);
-			SDL_Delay(100);
-		}
+        /* Cover up desktop during mode change */
+        bounds.left = 0;
+        bounds.top = 0;
+        bounds.right = GetSystemMetrics(SM_CXSCREEN);
+        bounds.bottom = GetSystemMetrics(SM_CYSCREEN);
+        AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE),
+                           (GetMenu(SDL_Window) != NULL), 0);
+        SetWindowPos(SDL_Window, HWND_TOPMOST, bounds.left, bounds.top,
+                     bounds.right - bounds.left, bounds.bottom - bounds.top,
+                     SWP_NOCOPYBITS);
+        ShowWindow(SDL_Window, SW_SHOW);
+        while (GetForegroundWindow() != SDL_Window) {
+            SetForegroundWindow(SDL_Window);
+            SDL_Delay(100);
+        }
 
-		/* find maximum monitor refresh rate for this resolution */
-		/* Dmitry Yakimov ftech@tula.net */
-		maxRefreshRate = 0; /* system default */
-		for ( rect = enumlists[bpp / 8 - 1]; rect; rect = rect->next ) {
-			if ( (width == rect->r.w) && (height == rect->r.h) ) {
-				maxRefreshRate = rect->refreshRate;
-				break;
-			}
-		}
+        /* find maximum monitor refresh rate for this resolution */
+        /* Dmitry Yakimov ftech@tula.net */
+        maxRefreshRate = 0;     /* system default */
+        for (rect = enumlists[bpp / 8 - 1]; rect; rect = rect->next) {
+            if ((width == rect->r.w) && (height == rect->r.h)) {
+                maxRefreshRate = rect->refreshRate;
+                break;
+            }
+        }
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "refresh rate = %d Hz\n", maxRefreshRate);
+        fprintf(stderr, "refresh rate = %d Hz\n", maxRefreshRate);
 #endif
 
-		result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, maxRefreshRate, 0);
-		if ( result != DD_OK ) {
-			result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, 0, 0);
-			if ( result != DD_OK ) {
-				/* We couldn't set fullscreen mode, try window */
-				return(DX5_SetVideoMode(this, current, width, height, bpp, flags & ~SDL_FULLSCREEN)); 
-			}
-		}
-		DX5_DInputReset(this, 1);
-	} else {
-		DX5_DInputReset(this, 0);
-	}
-	DX5_UpdateVideoInfo(this);
+        result =
+            IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp,
+                                        maxRefreshRate, 0);
+        if (result != DD_OK) {
+            result =
+                IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, 0, 0);
+            if (result != DD_OK) {
+                /* We couldn't set fullscreen mode, try window */
+                return (DX5_SetVideoMode
+                        (this, current, width, height, bpp,
+                         flags & ~SDL_FULLSCREEN));
+            }
+        }
+        DX5_DInputReset(this, 1);
+    } else {
+        DX5_DInputReset(this, 0);
+    }
+    DX5_UpdateVideoInfo(this);
 
-	/* Create a primary DirectDraw surface */
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	ddsd.dwFlags = DDSD_CAPS;
-	ddsd.ddsCaps.dwCaps = (DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY);
-	if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) {
-		/* There's no windowed double-buffering */
-		flags &= ~SDL_DOUBLEBUF;
-	}
-	if ( (flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
-		ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
-		ddsd.ddsCaps.dwCaps |= (DDSCAPS_COMPLEX|DDSCAPS_FLIP);
-		ddsd.dwBackBufferCount = 1;
-	}
-	result = IDirectDraw2_CreateSurface(ddraw2, &ddsd, &dd_surface1, NULL); 
-	if ( (result != DD_OK) && ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) ) {
-		ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
-		ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX|DDSCAPS_FLIP);
-		ddsd.dwBackBufferCount = 0;
-		result = IDirectDraw2_CreateSurface(ddraw2,
-						&ddsd, &dd_surface1, NULL); 
-	}
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDraw2::CreateSurface(PRIMARY)", result);
-		return(NULL);
-	}
-	result = IDirectDrawSurface_QueryInterface(dd_surface1,
-			&IID_IDirectDrawSurface3, (LPVOID *)&SDL_primary);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface::QueryInterface", result);
-		return(NULL);
-	}
-	IDirectDrawSurface_Release(dd_surface1);
+    /* Create a primary DirectDraw surface */
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = DDSD_CAPS;
+    ddsd.ddsCaps.dwCaps = (DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY);
+    if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
+        /* There's no windowed double-buffering */
+        flags &= ~SDL_DOUBLEBUF;
+    }
+    if ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
+        ddsd.ddsCaps.dwCaps |= (DDSCAPS_COMPLEX | DDSCAPS_FLIP);
+        ddsd.dwBackBufferCount = 1;
+    }
+    result = IDirectDraw2_CreateSurface(ddraw2, &ddsd, &dd_surface1, NULL);
+    if ((result != DD_OK) && ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)) {
+        ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
+        ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX | DDSCAPS_FLIP);
+        ddsd.dwBackBufferCount = 0;
+        result = IDirectDraw2_CreateSurface(ddraw2,
+                                            &ddsd, &dd_surface1, NULL);
+    }
+    if (result != DD_OK) {
+        SetDDerror("DirectDraw2::CreateSurface(PRIMARY)", result);
+        return (NULL);
+    }
+    result = IDirectDrawSurface_QueryInterface(dd_surface1,
+                                               &IID_IDirectDrawSurface3,
+                                               (LPVOID *) & SDL_primary);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface::QueryInterface", result);
+        return (NULL);
+    }
+    IDirectDrawSurface_Release(dd_surface1);
 
-	/* Get the format of the primary DirectDraw surface */
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	ddsd.dwFlags = DDSD_PIXELFORMAT|DDSD_CAPS;
-	result = IDirectDrawSurface3_GetSurfaceDesc(SDL_primary, &ddsd);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface::GetSurfaceDesc", result);
-		return(NULL);
-	}
-	if ( ! (ddsd.ddpfPixelFormat.dwFlags&DDPF_RGB) ) {
-		SDL_SetError("Primary DDRAW surface is not RGB format");
-		return(NULL);
-	}
-
-	/* Free old palette and create a new one if we're in 8-bit mode */
-	if ( SDL_palette != NULL ) {
-		IDirectDrawPalette_Release(SDL_palette);
-		SDL_palette = NULL;
-	}
-#if defined(NONAMELESSUNION)
-	if ( ddsd.ddpfPixelFormat.u1.dwRGBBitCount == 8 ) {
-#else
-	if ( ddsd.ddpfPixelFormat.dwRGBBitCount == 8 ) {
-#endif
-		int i;
+    /* Get the format of the primary DirectDraw surface */
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
+    result = IDirectDrawSurface3_GetSurfaceDesc(SDL_primary, &ddsd);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface::GetSurfaceDesc", result);
+        return (NULL);
+    }
+    if (!(ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB)) {
+        SDL_SetError("Primary DDRAW surface is not RGB format");
+        return (NULL);
+    }
 
-		if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-			/* We have access to the entire palette */
-			for ( i=0; i<256; ++i ) {
-				SDL_colors[i].peFlags =
-						(PC_NOCOLLAPSE|PC_RESERVED);
-				SDL_colors[i].peRed = 0;
-				SDL_colors[i].peGreen = 0;
-				SDL_colors[i].peBlue = 0;
-			}
-		} else {
-			/* First 10 colors are reserved by Windows */
-			for ( i=0; i<10; ++i ) {
-				SDL_colors[i].peFlags = PC_EXPLICIT;
-				SDL_colors[i].peRed = i;
-				SDL_colors[i].peGreen = 0;
-				SDL_colors[i].peBlue = 0;
-			}
-			for ( i=10; i<(10+236); ++i ) {
-				SDL_colors[i].peFlags = PC_NOCOLLAPSE;
-				SDL_colors[i].peRed = 0;
-				SDL_colors[i].peGreen = 0;
-				SDL_colors[i].peBlue = 0;
-			}
-			/* Last 10 colors are reserved by Windows */
-			for ( i=246; i<256; ++i ) {
-				SDL_colors[i].peFlags = PC_EXPLICIT;
-				SDL_colors[i].peRed = i;
-				SDL_colors[i].peGreen = 0;
-				SDL_colors[i].peBlue = 0;
-			}
-		}
-		result = IDirectDraw2_CreatePalette(ddraw2,
-		     			(DDPCAPS_8BIT|DDPCAPS_ALLOW256),
-						SDL_colors, &SDL_palette, NULL);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDraw2::CreatePalette", result);
-			return(NULL);
-		}
-		result = IDirectDrawSurface3_SetPalette(SDL_primary,
-								SDL_palette);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDrawSurface3::SetPalette", result);
-			return(NULL);
-		}
-	}
+    /* Free old palette and create a new one if we're in 8-bit mode */
+    if (SDL_palette != NULL) {
+        IDirectDrawPalette_Release(SDL_palette);
+        SDL_palette = NULL;
+    }
+#if defined(NONAMELESSUNION)
+    if (ddsd.ddpfPixelFormat.u1.dwRGBBitCount == 8) {
+#else
+    if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8) {
+#endif
+        int i;
 
-	/* Create our video surface using the same pixel format */
-	video = current;
-	if ( (width != video->w) || (height != video->h)
-			|| (video->format->BitsPerPixel != 
-#if defined(NONAMELESSUNION)
-				ddsd.ddpfPixelFormat.u1.dwRGBBitCount) ) {
-#else
-				ddsd.ddpfPixelFormat.dwRGBBitCount) ) {
-#endif
-		SDL_FreeSurface(video);
-		video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0,
+        if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+            /* We have access to the entire palette */
+            for (i = 0; i < 256; ++i) {
+                SDL_colors[i].peFlags = (PC_NOCOLLAPSE | PC_RESERVED);
+                SDL_colors[i].peRed = 0;
+                SDL_colors[i].peGreen = 0;
+                SDL_colors[i].peBlue = 0;
+            }
+        } else {
+            /* First 10 colors are reserved by Windows */
+            for (i = 0; i < 10; ++i) {
+                SDL_colors[i].peFlags = PC_EXPLICIT;
+                SDL_colors[i].peRed = i;
+                SDL_colors[i].peGreen = 0;
+                SDL_colors[i].peBlue = 0;
+            }
+            for (i = 10; i < (10 + 236); ++i) {
+                SDL_colors[i].peFlags = PC_NOCOLLAPSE;
+                SDL_colors[i].peRed = 0;
+                SDL_colors[i].peGreen = 0;
+                SDL_colors[i].peBlue = 0;
+            }
+            /* Last 10 colors are reserved by Windows */
+            for (i = 246; i < 256; ++i) {
+                SDL_colors[i].peFlags = PC_EXPLICIT;
+                SDL_colors[i].peRed = i;
+                SDL_colors[i].peGreen = 0;
+                SDL_colors[i].peBlue = 0;
+            }
+        }
+        result = IDirectDraw2_CreatePalette(ddraw2,
+                                            (DDPCAPS_8BIT |
+                                             DDPCAPS_ALLOW256), SDL_colors,
+                                            &SDL_palette, NULL);
+        if (result != DD_OK) {
+            SetDDerror("DirectDraw2::CreatePalette", result);
+            return (NULL);
+        }
+        result = IDirectDrawSurface3_SetPalette(SDL_primary, SDL_palette);
+        if (result != DD_OK) {
+            SetDDerror("DirectDrawSurface3::SetPalette", result);
+            return (NULL);
+        }
+    }
+
+    /* Create our video surface using the same pixel format */
+    video = current;
+    if ((width != video->w) || (height != video->h)
+        || (video->format->BitsPerPixel !=
 #if defined(NONAMELESSUNION)
-				ddsd.ddpfPixelFormat.u1.dwRGBBitCount,
-					ddsd.ddpfPixelFormat.u2.dwRBitMask,
-					ddsd.ddpfPixelFormat.u3.dwGBitMask,
-					ddsd.ddpfPixelFormat.u4.dwBBitMask,
+            ddsd.ddpfPixelFormat.u1.dwRGBBitCount)) {
 #else
-				ddsd.ddpfPixelFormat.dwRGBBitCount,
-					ddsd.ddpfPixelFormat.dwRBitMask,
-					ddsd.ddpfPixelFormat.dwGBitMask,
-					ddsd.ddpfPixelFormat.dwBBitMask,
+            ddsd.ddpfPixelFormat.dwRGBBitCount)) {
 #endif
-								0);
-		if ( video == NULL ) {
-			SDL_OutOfMemory();
-			return(NULL);
-		}
-		video->w = width;
-		video->h = height;
-		video->pitch = 0;
-	}
-	video->flags = 0;	/* Clear flags */
+        SDL_FreeSurface(video);
+        video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0,
+#if defined(NONAMELESSUNION)
+                                     ddsd.ddpfPixelFormat.u1.dwRGBBitCount,
+                                     ddsd.ddpfPixelFormat.u2.dwRBitMask,
+                                     ddsd.ddpfPixelFormat.u3.dwGBitMask,
+                                     ddsd.ddpfPixelFormat.u4.dwBBitMask,
+#else
+                                     ddsd.ddpfPixelFormat.dwRGBBitCount,
+                                     ddsd.ddpfPixelFormat.dwRBitMask,
+                                     ddsd.ddpfPixelFormat.dwGBitMask,
+                                     ddsd.ddpfPixelFormat.dwBBitMask,
+#endif
+                                     0);
+        if (video == NULL) {
+            SDL_OutOfMemory();
+            return (NULL);
+        }
+        video->w = width;
+        video->h = height;
+        video->pitch = 0;
+    }
+    video->flags = 0;           /* Clear flags */
 
-	/* If not fullscreen, locking is possible, but it doesn't do what 
-	   the caller really expects -- if the locked surface is written to,
-	   the appropriate portion of the entire screen is modified, not 
-	   the application window, as we would like.
-	   Note that it is still possible to write directly to display
-	   memory, but the application must respect the clip list of
-	   the surface.  There might be some odd timing interactions
-	   involving clip list updates and background refreshing as
-	   Windows moves other windows across our window.
-	   We currently don't support this, even though it might be a
-	   good idea since BeOS has an implementation of BDirectWindow
-	   that does the same thing.  This would be most useful for
-	   applications that do complete screen updates every frame.
-	    -- Fixme?
-	*/
-	if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) {
-		/* Necessary if we're going from fullscreen to window */
-		if ( video->pixels == NULL ) {
-			video->pitch = (width*video->format->BytesPerPixel);
-			/* Pitch needs to be QWORD (8-byte) aligned */
-			video->pitch = (video->pitch + 7) & ~7;
-			video->pixels = (void *)SDL_malloc(video->h*video->pitch);
-			if ( video->pixels == NULL ) {
-				if ( video != current ) {
-					SDL_FreeSurface(video);
-				}
-				SDL_OutOfMemory();
-				return(NULL);
-			}
-		}
-		dd_surface3 = NULL;
-#if 0 /* FIXME: enable this when SDL consistently reports lost surfaces */
-		if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-			video->flags |= SDL_HWSURFACE;
-		} else {
-			video->flags |= SDL_SWSURFACE;
-		}
+    /* If not fullscreen, locking is possible, but it doesn't do what 
+       the caller really expects -- if the locked surface is written to,
+       the appropriate portion of the entire screen is modified, not 
+       the application window, as we would like.
+       Note that it is still possible to write directly to display
+       memory, but the application must respect the clip list of
+       the surface.  There might be some odd timing interactions
+       involving clip list updates and background refreshing as
+       Windows moves other windows across our window.
+       We currently don't support this, even though it might be a
+       good idea since BeOS has an implementation of BDirectWindow
+       that does the same thing.  This would be most useful for
+       applications that do complete screen updates every frame.
+       -- Fixme?
+     */
+    if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
+        /* Necessary if we're going from fullscreen to window */
+        if (video->pixels == NULL) {
+            video->pitch = (width * video->format->BytesPerPixel);
+            /* Pitch needs to be QWORD (8-byte) aligned */
+            video->pitch = (video->pitch + 7) & ~7;
+            video->pixels = (void *) SDL_malloc(video->h * video->pitch);
+            if (video->pixels == NULL) {
+                if (video != current) {
+                    SDL_FreeSurface(video);
+                }
+                SDL_OutOfMemory();
+                return (NULL);
+            }
+        }
+        dd_surface3 = NULL;
+#if 0                           /* FIXME: enable this when SDL consistently reports lost surfaces */
+        if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+            video->flags |= SDL_HWSURFACE;
+        } else {
+            video->flags |= SDL_SWSURFACE;
+        }
 #else
-		video->flags |= SDL_SWSURFACE;
+        video->flags |= SDL_SWSURFACE;
 #endif
-		if ( (flags & SDL_RESIZABLE) && !(flags & SDL_NOFRAME) ) {
-			video->flags |= SDL_RESIZABLE;
-		}
-		if ( flags & SDL_NOFRAME ) {
-			video->flags |= SDL_NOFRAME;
-		}
-	} else {
-		/* Necessary if we're going from window to fullscreen */
-		if ( video->pixels != NULL ) {
-			SDL_free(video->pixels);
-			video->pixels = NULL;
-		}
-		dd_surface3 = SDL_primary;
-		video->flags |= SDL_HWSURFACE;
-	}
+        if ((flags & SDL_RESIZABLE) && !(flags & SDL_NOFRAME)) {
+            video->flags |= SDL_RESIZABLE;
+        }
+        if (flags & SDL_NOFRAME) {
+            video->flags |= SDL_NOFRAME;
+        }
+    } else {
+        /* Necessary if we're going from window to fullscreen */
+        if (video->pixels != NULL) {
+            SDL_free(video->pixels);
+            video->pixels = NULL;
+        }
+        dd_surface3 = SDL_primary;
+        video->flags |= SDL_HWSURFACE;
+    }
 
-	/* See if the primary surface has double-buffering enabled */
-	if ( (ddsd.ddsCaps.dwCaps & DDSCAPS_FLIP) == DDSCAPS_FLIP ) {
-		video->flags |= SDL_DOUBLEBUF;
-	}
+    /* See if the primary surface has double-buffering enabled */
+    if ((ddsd.ddsCaps.dwCaps & DDSCAPS_FLIP) == DDSCAPS_FLIP) {
+        video->flags |= SDL_DOUBLEBUF;
+    }
 
-	/* Allocate the SDL surface associated with the primary surface */
-	if ( DX5_AllocDDSurface(this, video, dd_surface3,
-	                        video->flags&SDL_HWSURFACE) < 0 ) {
-		if ( video != current ) {
-			SDL_FreeSurface(video);
-		}
-		return(NULL);
-	}
+    /* Allocate the SDL surface associated with the primary surface */
+    if (DX5_AllocDDSurface(this, video, dd_surface3,
+                           video->flags & SDL_HWSURFACE) < 0) {
+        if (video != current) {
+            SDL_FreeSurface(video);
+        }
+        return (NULL);
+    }
 
-	/* Use the appropriate blitting function */
-	if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-		video->flags |= SDL_FULLSCREEN;
-		if ( video->format->palette != NULL ) {
-			video->flags |= SDL_HWPALETTE;
-		}
-		this->UpdateRects = DX5_DirectUpdate;
-	} else {
-		this->UpdateRects = DX5_WindowUpdate;
-	}
+    /* Use the appropriate blitting function */
+    if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+        video->flags |= SDL_FULLSCREEN;
+        if (video->format->palette != NULL) {
+            video->flags |= SDL_HWPALETTE;
+        }
+        this->UpdateRects = DX5_DirectUpdate;
+    } else {
+        this->UpdateRects = DX5_WindowUpdate;
+    }
 
-	/* Make our window the proper size, set the clipper, then show it */
-	if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) {
-		/* Create and set a clipper on our primary surface */
-		if ( SDL_clipper == NULL ) {
-			result = IDirectDraw2_CreateClipper(ddraw2,
-							0, &SDL_clipper, NULL);
-			if ( result != DD_OK ) {
-				if ( video != current ) {
-					SDL_FreeSurface(video);
-				}
-				SetDDerror("DirectDraw2::CreateClipper",result);
-				return(NULL);
-			}
-		}
-		result = IDirectDrawClipper_SetHWnd(SDL_clipper, 0, SDL_Window);
-		if ( result != DD_OK ) {
-			if ( video != current ) {
-				SDL_FreeSurface(video);
-			}
-			SetDDerror("DirectDrawClipper::SetHWnd", result);
-			return(NULL);
-		}
-		result = IDirectDrawSurface3_SetClipper(SDL_primary,
-								SDL_clipper);
-		if ( result != DD_OK ) {
-			if ( video != current ) {
-				SDL_FreeSurface(video);
-			}
-			SetDDerror("DirectDrawSurface3::SetClipper", result);
-			return(NULL);
-		}
+    /* Make our window the proper size, set the clipper, then show it */
+    if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
+        /* Create and set a clipper on our primary surface */
+        if (SDL_clipper == NULL) {
+            result = IDirectDraw2_CreateClipper(ddraw2,
+                                                0, &SDL_clipper, NULL);
+            if (result != DD_OK) {
+                if (video != current) {
+                    SDL_FreeSurface(video);
+                }
+                SetDDerror("DirectDraw2::CreateClipper", result);
+                return (NULL);
+            }
+        }
+        result = IDirectDrawClipper_SetHWnd(SDL_clipper, 0, SDL_Window);
+        if (result != DD_OK) {
+            if (video != current) {
+                SDL_FreeSurface(video);
+            }
+            SetDDerror("DirectDrawClipper::SetHWnd", result);
+            return (NULL);
+        }
+        result = IDirectDrawSurface3_SetClipper(SDL_primary, SDL_clipper);
+        if (result != DD_OK) {
+            if (video != current) {
+                SDL_FreeSurface(video);
+            }
+            SetDDerror("DirectDrawSurface3::SetClipper", result);
+            return (NULL);
+        }
 
-		/* Resize the window (copied from SDL WinDIB driver) */
-		if ( !SDL_windowid && !IsZoomed(SDL_Window) ) {
-			RECT bounds;
-			int  x, y;
-			UINT swp_flags;
-			const char *window = NULL;
-			const char *center = NULL;
+        /* Resize the window (copied from SDL WinDIB driver) */
+        if (!SDL_windowid && !IsZoomed(SDL_Window)) {
+            RECT bounds;
+            int x, y;
+            UINT swp_flags;
+            const char *window = NULL;
+            const char *center = NULL;
 
-			if ( !SDL_windowX && !SDL_windowY ) {
-				window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
-				center = SDL_getenv("SDL_VIDEO_CENTERED");
-				if ( window ) {
-					if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) {
-						SDL_windowX = x;
-						SDL_windowY = y;
-					}
-					if ( SDL_strcmp(window, "center") == 0 ) {
-						center = window;
-					}
-				}
-			}
-			swp_flags = SWP_NOCOPYBITS;
+            if (!SDL_windowX && !SDL_windowY) {
+                window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
+                center = SDL_getenv("SDL_VIDEO_CENTERED");
+                if (window) {
+                    if (SDL_sscanf(window, "%d,%d", &x, &y) == 2) {
+                        SDL_windowX = x;
+                        SDL_windowY = y;
+                    }
+                    if (SDL_strcmp(window, "center") == 0) {
+                        center = window;
+                    }
+                }
+            }
+            swp_flags = SWP_NOCOPYBITS;
 
-			bounds.left = SDL_windowX;
-			bounds.top = SDL_windowY;
-			bounds.right = SDL_windowX+video->w;
-			bounds.bottom = SDL_windowY+video->h;
-			AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), (GetMenu(SDL_Window) != NULL), 0);
-			width = bounds.right-bounds.left;
-			height = bounds.bottom-bounds.top;
-			if ( center ) {
-				x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
-				y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
-			} else if ( SDL_windowX || SDL_windowY || window ) {
-				x = bounds.left;
-				y = bounds.top;
-			} else {
-				x = y = -1;
-				swp_flags |= SWP_NOMOVE;
-			}
-			SetWindowPos(SDL_Window, HWND_NOTOPMOST, x, y, width, height, swp_flags);
-			SDL_windowX = SDL_bounds.left;
-			SDL_windowY = SDL_bounds.top;
-		}
+            bounds.left = SDL_windowX;
+            bounds.top = SDL_windowY;
+            bounds.right = SDL_windowX + video->w;
+            bounds.bottom = SDL_windowY + video->h;
+            AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE),
+                               (GetMenu(SDL_Window) != NULL), 0);
+            width = bounds.right - bounds.left;
+            height = bounds.bottom - bounds.top;
+            if (center) {
+                x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
+                y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
+            } else if (SDL_windowX || SDL_windowY || window) {
+                x = bounds.left;
+                y = bounds.top;
+            } else {
+                x = y = -1;
+                swp_flags |= SWP_NOMOVE;
+            }
+            SetWindowPos(SDL_Window, HWND_NOTOPMOST, x, y, width, height,
+                         swp_flags);
+            SDL_windowX = SDL_bounds.left;
+            SDL_windowY = SDL_bounds.top;
+        }
 
-	}
-	ShowWindow(SDL_Window, SW_SHOW);
-	SetForegroundWindow(SDL_Window);
-	SDL_resizing = 0;
+    }
+    ShowWindow(SDL_Window, SW_SHOW);
+    SetForegroundWindow(SDL_Window);
+    SDL_resizing = 0;
 
-	/* JC 14 Mar 2006
-		Flush the message loop or this can cause big problems later
-		Especially if the user decides to use dialog boxes or assert()!
-	*/
-	WIN_FlushMessageQueue();
+    /* JC 14 Mar 2006
+       Flush the message loop or this can cause big problems later
+       Especially if the user decides to use dialog boxes or assert()!
+     */
+    WIN_FlushMessageQueue();
 
-	/* We're live! */
-	return(video);
+    /* We're live! */
+    return (video);
 }
 
-struct private_hwdata {
-	LPDIRECTDRAWSURFACE3 dd_surface;
-	LPDIRECTDRAWSURFACE3 dd_writebuf;
+struct private_hwdata
+{
+    LPDIRECTDRAWSURFACE3 dd_surface;
+    LPDIRECTDRAWSURFACE3 dd_writebuf;
 };
 
-static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, 
-				LPDIRECTDRAWSURFACE3 requested, Uint32 flag)
+static int
+DX5_AllocDDSurface(_THIS, SDL_Surface * surface,
+                   LPDIRECTDRAWSURFACE3 requested, Uint32 flag)
 {
-	LPDIRECTDRAWSURFACE  dd_surface1;
-	LPDIRECTDRAWSURFACE3 dd_surface3;
-	DDSURFACEDESC ddsd;
-	HRESULT result;
+    LPDIRECTDRAWSURFACE dd_surface1;
+    LPDIRECTDRAWSURFACE3 dd_surface3;
+    DDSURFACEDESC ddsd;
+    HRESULT result;
 
-	/* Clear the hardware flag, in case we fail */
-	surface->flags &= ~flag;
+    /* Clear the hardware flag, in case we fail */
+    surface->flags &= ~flag;
 
-	/* Allocate the hardware acceleration data */
-	surface->hwdata = (struct private_hwdata *)
-					SDL_malloc(sizeof(*surface->hwdata));
-	if ( surface->hwdata == NULL ) {
-		SDL_OutOfMemory();
-		return(-1);
-	}
-	dd_surface3 = NULL;
+    /* Allocate the hardware acceleration data */
+    surface->hwdata = (struct private_hwdata *)
+        SDL_malloc(sizeof(*surface->hwdata));
+    if (surface->hwdata == NULL) {
+        SDL_OutOfMemory();
+        return (-1);
+    }
+    dd_surface3 = NULL;
 
-	/* Set up the surface description */
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	ddsd.dwFlags = (DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS|
-					DDSD_PITCH|DDSD_PIXELFORMAT);
-	ddsd.dwWidth = surface->w;
-	ddsd.dwHeight= surface->h;
+    /* Set up the surface description */
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = (DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS |
+                    DDSD_PITCH | DDSD_PIXELFORMAT);
+    ddsd.dwWidth = surface->w;
+    ddsd.dwHeight = surface->h;
 #if defined(NONAMELESSUNION)
-	ddsd.u1.lPitch = surface->pitch;
+    ddsd.u1.lPitch = surface->pitch;
 #else
-	ddsd.lPitch = surface->pitch;
+    ddsd.lPitch = surface->pitch;
 #endif
-	if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-		ddsd.ddsCaps.dwCaps =
-				(DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY);
-	} else {
-		ddsd.ddsCaps.dwCaps =
-				(DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY);
-	}
-	ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
-	ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
-	if ( surface->format->palette ) {
-		ddsd.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
-	}
+    if ((flag & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY);
+    } else {
+        ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY);
+    }
+    ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
+    ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
+    if (surface->format->palette) {
+        ddsd.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
+    }
 #if defined(NONAMELESSUNION)
-	ddsd.ddpfPixelFormat.u1.dwRGBBitCount = surface->format->BitsPerPixel;
-	ddsd.ddpfPixelFormat.u2.dwRBitMask = surface->format->Rmask;
-	ddsd.ddpfPixelFormat.u3.dwGBitMask = surface->format->Gmask;
-	ddsd.ddpfPixelFormat.u4.dwBBitMask = surface->format->Bmask;
+    ddsd.ddpfPixelFormat.u1.dwRGBBitCount = surface->format->BitsPerPixel;
+    ddsd.ddpfPixelFormat.u2.dwRBitMask = surface->format->Rmask;
+    ddsd.ddpfPixelFormat.u3.dwGBitMask = surface->format->Gmask;
+    ddsd.ddpfPixelFormat.u4.dwBBitMask = surface->format->Bmask;
 #else
-	ddsd.ddpfPixelFormat.dwRGBBitCount = surface->format->BitsPerPixel;
-	ddsd.ddpfPixelFormat.dwRBitMask = surface->format->Rmask;
-	ddsd.ddpfPixelFormat.dwGBitMask = surface->format->Gmask;
-	ddsd.ddpfPixelFormat.dwBBitMask = surface->format->Bmask;
+    ddsd.ddpfPixelFormat.dwRGBBitCount = surface->format->BitsPerPixel;
+    ddsd.ddpfPixelFormat.dwRBitMask = surface->format->Rmask;
+    ddsd.ddpfPixelFormat.dwGBitMask = surface->format->Gmask;
+    ddsd.ddpfPixelFormat.dwBBitMask = surface->format->Bmask;
 #endif
 
-	/* Create the DirectDraw video surface */
-	if ( requested != NULL ) {
-		dd_surface3 = requested;
-	} else {
-		result = IDirectDraw2_CreateSurface(ddraw2,
-						&ddsd, &dd_surface1, NULL); 
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDraw2::CreateSurface", result);
-			goto error_end;
-		}
-		result = IDirectDrawSurface_QueryInterface(dd_surface1,
-			&IID_IDirectDrawSurface3, (LPVOID *)&dd_surface3);
-		IDirectDrawSurface_Release(dd_surface1);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDrawSurface::QueryInterface", result);
-			goto error_end;
-		}
-	}
+    /* Create the DirectDraw video surface */
+    if (requested != NULL) {
+        dd_surface3 = requested;
+    } else {
+        result = IDirectDraw2_CreateSurface(ddraw2,
+                                            &ddsd, &dd_surface1, NULL);
+        if (result != DD_OK) {
+            SetDDerror("DirectDraw2::CreateSurface", result);
+            goto error_end;
+        }
+        result = IDirectDrawSurface_QueryInterface(dd_surface1,
+                                                   &IID_IDirectDrawSurface3,
+                                                   (LPVOID *) & dd_surface3);
+        IDirectDrawSurface_Release(dd_surface1);
+        if (result != DD_OK) {
+            SetDDerror("DirectDrawSurface::QueryInterface", result);
+            goto error_end;
+        }
+    }
 
-	if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-		/* Check to see whether the surface actually ended up
-		   in video memory, and fail if not.  We expect the
-		   surfaces we create here to actually be in hardware!
-		*/
-		result = IDirectDrawSurface3_GetCaps(dd_surface3,&ddsd.ddsCaps);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDrawSurface3::GetCaps", result);
-			goto error_end;
-		}
-		if ( (ddsd.ddsCaps.dwCaps&DDSCAPS_VIDEOMEMORY) !=
-							DDSCAPS_VIDEOMEMORY ) {
-			SDL_SetError("No room in video memory");
-			goto error_end;
-		}
-	} else {
-		/* Try to hook our surface memory */
-		ddsd.dwFlags = DDSD_LPSURFACE;
-		ddsd.lpSurface = surface->pixels;
-		result = IDirectDrawSurface3_SetSurfaceDesc(dd_surface3,
-								&ddsd, 0);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDraw2::SetSurfaceDesc", result);
-			goto error_end;
-		}
-	
-	}
+    if ((flag & SDL_HWSURFACE) == SDL_HWSURFACE) {
+        /* Check to see whether the surface actually ended up
+           in video memory, and fail if not.  We expect the
+           surfaces we create here to actually be in hardware!
+         */
+        result = IDirectDrawSurface3_GetCaps(dd_surface3, &ddsd.ddsCaps);
+        if (result != DD_OK) {
+            SetDDerror("DirectDrawSurface3::GetCaps", result);
+            goto error_end;
+        }
+        if ((ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) !=
+            DDSCAPS_VIDEOMEMORY) {
+            SDL_SetError("No room in video memory");
+            goto error_end;
+        }
+    } else {
+        /* Try to hook our surface memory */
+        ddsd.dwFlags = DDSD_LPSURFACE;
+        ddsd.lpSurface = surface->pixels;
+        result = IDirectDrawSurface3_SetSurfaceDesc(dd_surface3, &ddsd, 0);
+        if (result != DD_OK) {
+            SetDDerror("DirectDraw2::SetSurfaceDesc", result);
+            goto error_end;
+        }
 
-	/* Make sure the surface format was set properly */
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	result = IDirectDrawSurface3_Lock(dd_surface3, NULL,
-		&ddsd, (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface3::Lock", result);
-		goto error_end;
-	}
-	IDirectDrawSurface3_Unlock(dd_surface3, NULL);
+    }
 
-	if ( (flag & SDL_HWSURFACE) == SDL_SWSURFACE ) {
-		if ( ddsd.lpSurface != surface->pixels ) {
-			SDL_SetError("DDraw didn't use SDL surface memory");
-			goto error_end;
-		}
-		if (
+    /* Make sure the surface format was set properly */
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    result = IDirectDrawSurface3_Lock(dd_surface3, NULL,
+                                      &ddsd,
+                                      (DDLOCK_NOSYSLOCK | DDLOCK_WAIT), NULL);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface3::Lock", result);
+        goto error_end;
+    }
+    IDirectDrawSurface3_Unlock(dd_surface3, NULL);
+
+    if ((flag & SDL_HWSURFACE) == SDL_SWSURFACE) {
+        if (ddsd.lpSurface != surface->pixels) {
+            SDL_SetError("DDraw didn't use SDL surface memory");
+            goto error_end;
+        }
+        if (
 #if defined(NONAMELESSUNION)
-			ddsd.u1.lPitch
+               ddsd.u1.lPitch
 #else
-			ddsd.lPitch
+               ddsd.lPitch
 #endif
-				 != (LONG)surface->pitch ) {
-			SDL_SetError("DDraw created surface with wrong pitch");
-			goto error_end;
-		}
-	} else {
+               != (LONG) surface->pitch) {
+            SDL_SetError("DDraw created surface with wrong pitch");
+            goto error_end;
+        }
+    } else {
 #if defined(NONAMELESSUNION)
-		surface->pitch = (Uint16)ddsd.u1.lPitch;
+        surface->pitch = (Uint16) ddsd.u1.lPitch;
 #else
-		surface->pitch = (Uint16)ddsd.lPitch;
+        surface->pitch = (Uint16) ddsd.lPitch;
 #endif
-	}
+    }
 #if defined(NONAMELESSUNION)
-	if ( (ddsd.ddpfPixelFormat.u1.dwRGBBitCount != 
-					surface->format->BitsPerPixel) ||
-	     (ddsd.ddpfPixelFormat.u2.dwRBitMask != surface->format->Rmask) ||
-	     (ddsd.ddpfPixelFormat.u3.dwGBitMask != surface->format->Gmask) ||
-	     (ddsd.ddpfPixelFormat.u4.dwBBitMask != surface->format->Bmask) ){
+    if ((ddsd.ddpfPixelFormat.u1.dwRGBBitCount !=
+         surface->format->BitsPerPixel) ||
+        (ddsd.ddpfPixelFormat.u2.dwRBitMask != surface->format->Rmask) ||
+        (ddsd.ddpfPixelFormat.u3.dwGBitMask != surface->format->Gmask) ||
+        (ddsd.ddpfPixelFormat.u4.dwBBitMask != surface->format->Bmask)) {
 #else
-	if ( (ddsd.ddpfPixelFormat.dwRGBBitCount != 
-					surface->format->BitsPerPixel) ||
-	     (ddsd.ddpfPixelFormat.dwRBitMask != surface->format->Rmask) ||
-	     (ddsd.ddpfPixelFormat.dwGBitMask != surface->format->Gmask) ||
-	     (ddsd.ddpfPixelFormat.dwBBitMask != surface->format->Bmask) ){
+    if ((ddsd.ddpfPixelFormat.dwRGBBitCount !=
+         surface->format->BitsPerPixel) ||
+        (ddsd.ddpfPixelFormat.dwRBitMask != surface->format->Rmask) ||
+        (ddsd.ddpfPixelFormat.dwGBitMask != surface->format->Gmask) ||
+        (ddsd.ddpfPixelFormat.dwBBitMask != surface->format->Bmask)) {
 #endif
-		SDL_SetError("DDraw didn't use SDL surface description");
-		goto error_end;
-	}
-	if ( (ddsd.dwWidth != (DWORD)surface->w) ||
-		(ddsd.dwHeight != (DWORD)surface->h) ) {
-		SDL_SetError("DDraw created surface with wrong size");
-		goto error_end;
-	}
+        SDL_SetError("DDraw didn't use SDL surface description");
+        goto error_end;
+    }
+    if ((ddsd.dwWidth != (DWORD) surface->w) ||
+        (ddsd.dwHeight != (DWORD) surface->h)) {
+        SDL_SetError("DDraw created surface with wrong size");
+        goto error_end;
+    }
 
-	/* Set the surface private data */
-	surface->flags |= flag;
-	surface->hwdata->dd_surface = dd_surface3;
-	if ( (surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
-		LPDIRECTDRAWSURFACE3 dd_writebuf;
+    /* Set the surface private data */
+    surface->flags |= flag;
+    surface->hwdata->dd_surface = dd_surface3;
+    if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
+        LPDIRECTDRAWSURFACE3 dd_writebuf;
 
-		ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
-		result = IDirectDrawSurface3_GetAttachedSurface(dd_surface3,
-						&ddsd.ddsCaps, &dd_writebuf);
-		if ( result != DD_OK ) {
-			SetDDerror("DirectDrawSurface3::GetAttachedSurface",
-								result);
-		} else {
-			dd_surface3 = dd_writebuf;
-		}
-	}
-	surface->hwdata->dd_writebuf = dd_surface3;
+        ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
+        result = IDirectDrawSurface3_GetAttachedSurface(dd_surface3,
+                                                        &ddsd.ddsCaps,
+                                                        &dd_writebuf);
+        if (result != DD_OK) {
+            SetDDerror("DirectDrawSurface3::GetAttachedSurface", result);
+        } else {
+            dd_surface3 = dd_writebuf;
+        }
+    }
+    surface->hwdata->dd_writebuf = dd_surface3;
 
-	/* We're ready to go! */
-	return(0);
+    /* We're ready to go! */
+    return (0);
 
-	/* Okay, so goto's are cheesy, but there are so many possible
-	   errors in this function, and the cleanup is the same in 
-	   every single case.  Is there a better way, other than deeply
-	   nesting the code?
-	*/
-error_end:
-	if ( (dd_surface3 != NULL) && (dd_surface3 != requested) ) {
-		IDirectDrawSurface_Release(dd_surface3);
-	}
-	SDL_free(surface->hwdata);
-	surface->hwdata = NULL;
-	return(-1);
+    /* Okay, so goto's are cheesy, but there are so many possible
+       errors in this function, and the cleanup is the same in 
+       every single case.  Is there a better way, other than deeply
+       nesting the code?
+     */
+  error_end:
+    if ((dd_surface3 != NULL) && (dd_surface3 != requested)) {
+        IDirectDrawSurface_Release(dd_surface3);
+    }
+    SDL_free(surface->hwdata);
+    surface->hwdata = NULL;
+    return (-1);
 }
 
-static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface)
+static int
+DX5_AllocHWSurface(_THIS, SDL_Surface * surface)
 {
-	/* DDraw limitation -- you need to set cooperative level first */
-	if ( SDL_primary == NULL ) {
-		SDL_SetError("You must set a non-GL video mode first");
-		return(-1);
-	}
-	return(DX5_AllocDDSurface(this, surface, NULL, SDL_HWSURFACE));
+    /* DDraw limitation -- you need to set cooperative level first */
+    if (SDL_primary == NULL) {
+        SDL_SetError("You must set a non-GL video mode first");
+        return (-1);
+    }
+    return (DX5_AllocDDSurface(this, surface, NULL, SDL_HWSURFACE));
 }
 
 #ifdef DDRAW_DEBUG
-void PrintSurface(char *title, LPDIRECTDRAWSURFACE3 surface, Uint32 flags)
+void
+PrintSurface(char *title, LPDIRECTDRAWSURFACE3 surface, Uint32 flags)
 {
-	DDSURFACEDESC ddsd;
+    DDSURFACEDESC ddsd;
+
+    /* Lock and load! */
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    if (IDirectDrawSurface3_Lock(surface, NULL, &ddsd,
+                                 (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
+                                 NULL) != DD_OK) {
+        return;
+    }
+    IDirectDrawSurface3_Unlock(surface, NULL);
 
-	/* Lock and load! */
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	if ( IDirectDrawSurface3_Lock(surface, NULL, &ddsd,
-			(DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL) != DD_OK ) {
-		return;
-	}
-	IDirectDrawSurface3_Unlock(surface, NULL);
-	
-	fprintf(stderr, "%s:\n", title);
-	fprintf(stderr, "\tSize: %dx%d in %s at %ld bpp (pitch = %ld)\n",
-		ddsd.dwWidth, ddsd.dwHeight,
-		(flags & SDL_HWSURFACE) ? "hardware" : "software",
+    fprintf(stderr, "%s:\n", title);
+    fprintf(stderr, "\tSize: %dx%d in %s at %ld bpp (pitch = %ld)\n",
+            ddsd.dwWidth, ddsd.dwHeight,
+            (flags & SDL_HWSURFACE) ? "hardware" : "software",
 #if defined(NONAMELESSUNION)
-		ddsd.ddpfPixelFormat.u1.dwRGBBitCount, ddsd.u1.lPitch);
+            ddsd.ddpfPixelFormat.u1.dwRGBBitCount, ddsd.u1.lPitch);
 #else
-		ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.lPitch);
+            ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.lPitch);
 #endif
-	fprintf(stderr, "\tR = 0x%X, G = 0x%X, B = 0x%X\n", 
+    fprintf(stderr, "\tR = 0x%X, G = 0x%X, B = 0x%X\n",
 #if defined(NONAMELESSUNION)
-	     		ddsd.ddpfPixelFormat.u2.dwRBitMask,
-	     		ddsd.ddpfPixelFormat.u3.dwGBitMask,
-	     		ddsd.ddpfPixelFormat.u4.dwBBitMask);
+            ddsd.ddpfPixelFormat.u2.dwRBitMask,
+            ddsd.ddpfPixelFormat.u3.dwGBitMask,
+            ddsd.ddpfPixelFormat.u4.dwBBitMask);
 #else
-	     		ddsd.ddpfPixelFormat.dwRBitMask,
-	     		ddsd.ddpfPixelFormat.dwGBitMask,
-	     		ddsd.ddpfPixelFormat.dwBBitMask);
+            ddsd.ddpfPixelFormat.dwRBitMask,
+            ddsd.ddpfPixelFormat.dwGBitMask, ddsd.ddpfPixelFormat.dwBBitMask);
 #endif
 }
 #endif /* DDRAW_DEBUG */
 
-static int DX5_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
-					SDL_Surface *dst, SDL_Rect *dstrect)
+static int
+DX5_HWAccelBlit(SDL_Surface * src, SDL_Rect * srcrect,
+                SDL_Surface * dst, SDL_Rect * dstrect)
 {
-	LPDIRECTDRAWSURFACE3 src_surface;
-	LPDIRECTDRAWSURFACE3 dst_surface;
-	DWORD flags;
-	RECT rect;
-	HRESULT result;
+    LPDIRECTDRAWSURFACE3 src_surface;
+    LPDIRECTDRAWSURFACE3 dst_surface;
+    DWORD flags;
+    RECT rect;
+    HRESULT result;
 
-	/* Set it up.. the desination must have a DDRAW surface */
-	src_surface = src->hwdata->dd_writebuf;
-	dst_surface = dst->hwdata->dd_writebuf;
-	rect.top    = (LONG)srcrect->y;
-	rect.bottom = (LONG)srcrect->y+srcrect->h;
-	rect.left   = (LONG)srcrect->x;
-	rect.right  = (LONG)srcrect->x+srcrect->w;
-	if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY )
-		flags = DDBLTFAST_SRCCOLORKEY;
-	else
-		flags = DDBLTFAST_NOCOLORKEY;
-	/* FIXME:  We can remove this flag for _really_ fast blit queuing,
-	           but it will affect the return values of locks and flips.
-	 */
-	flags |= DDBLTFAST_WAIT;
+    /* Set it up.. the desination must have a DDRAW surface */
+    src_surface = src->hwdata->dd_writebuf;
+    dst_surface = dst->hwdata->dd_writebuf;
+    rect.top = (LONG) srcrect->y;
+    rect.bottom = (LONG) srcrect->y + srcrect->h;
+    rect.left = (LONG) srcrect->x;
+    rect.right = (LONG) srcrect->x + srcrect->w;
+    if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)
+        flags = DDBLTFAST_SRCCOLORKEY;
+    else
+        flags = DDBLTFAST_NOCOLORKEY;
+    /* FIXME:  We can remove this flag for _really_ fast blit queuing,
+       but it will affect the return values of locks and flips.
+     */
+    flags |= DDBLTFAST_WAIT;
 
-	/* Do the blit! */
-	result = IDirectDrawSurface3_BltFast(dst_surface,
-			dstrect->x, dstrect->y, src_surface, &rect, flags);
-	if ( result != DD_OK ) {
-		if ( result == DDERR_SURFACELOST ) {
-			result = IDirectDrawSurface3_Restore(src_surface);
-			result = IDirectDrawSurface3_Restore(dst_surface);
-			/* The surfaces need to be reloaded with artwork */
-			SDL_SetError("Blit surfaces were lost, reload them");
-			return(-2);
-		}
-		SetDDerror("IDirectDrawSurface3::BltFast", result);
+    /* Do the blit! */
+    result = IDirectDrawSurface3_BltFast(dst_surface,
+                                         dstrect->x, dstrect->y, src_surface,
+                                         &rect, flags);
+    if (result != DD_OK) {
+        if (result == DDERR_SURFACELOST) {
+            result = IDirectDrawSurface3_Restore(src_surface);
+            result = IDirectDrawSurface3_Restore(dst_surface);
+            /* The surfaces need to be reloaded with artwork */
+            SDL_SetError("Blit surfaces were lost, reload them");
+            return (-2);
+        }
+        SetDDerror("IDirectDrawSurface3::BltFast", result);
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "Original dest rect: %dx%d at %d,%d\n", dstrect->w, dstrect->h, dstrect->x, dstrect->y);
- fprintf(stderr, "HW accelerated %sblit to from 0x%p to 0x%p at (%d,%d)\n",
-		(src->flags & SDL_SRCCOLORKEY) ? "colorkey " : "", src, dst,
-					dstrect->x, dstrect->y);
-  PrintSurface("SRC", src_surface, src->flags);
-  PrintSurface("DST", dst_surface, dst->flags);
- fprintf(stderr, "Source rectangle: (%d,%d) - (%d,%d)\n",
-		rect.left, rect.top, rect.right, rect.bottom);
+        fprintf(stderr, "Original dest rect: %dx%d at %d,%d\n", dstrect->w,
+                dstrect->h, dstrect->x, dstrect->y);
+        fprintf(stderr,
+                "HW accelerated %sblit to from 0x%p to 0x%p at (%d,%d)\n",
+                (src->flags & SDL_SRCCOLORKEY) ? "colorkey " : "", src,
+                dst, dstrect->x, dstrect->y);
+        PrintSurface("SRC", src_surface, src->flags);
+        PrintSurface("DST", dst_surface, dst->flags);
+        fprintf(stderr, "Source rectangle: (%d,%d) - (%d,%d)\n",
+                rect.left, rect.top, rect.right, rect.bottom);
 #endif
-		/* Unexpected error, fall back to software blit */
-		return(src->map->sw_blit(src, srcrect, dst, dstrect));
-	}
-	return(0);
+        /* Unexpected error, fall back to software blit */
+        return (src->map->sw_blit(src, srcrect, dst, dstrect));
+    }
+    return (0);
 }
 
-static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
+static int
+DX5_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dst)
 {
-	int accelerated;
+    int accelerated;
 
-	/* We need to have a DDraw surface for HW blits */
-	if ( (src->flags & SDL_HWSURFACE) == SDL_SWSURFACE ) {
-		/* Allocate a DDraw surface for the blit */
-		if ( src->hwdata == NULL ) {
-			DX5_AllocDDSurface(this, src, NULL, SDL_SWSURFACE);
-		}
-	}
-	if ( src->hwdata == NULL ) {
-		return(0);
-	}
+    /* We need to have a DDraw surface for HW blits */
+    if ((src->flags & SDL_HWSURFACE) == SDL_SWSURFACE) {
+        /* Allocate a DDraw surface for the blit */
+        if (src->hwdata == NULL) {
+            DX5_AllocDDSurface(this, src, NULL, SDL_SWSURFACE);
+        }
+    }
+    if (src->hwdata == NULL) {
+        return (0);
+    }
 
-	/* Set initial acceleration on */
-	src->flags |= SDL_HWACCEL;
+    /* Set initial acceleration on */
+    src->flags |= SDL_HWACCEL;
 
-	/* Set the surface attributes */
-	if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
-		if ( DX5_SetHWColorKey(this, src, src->format->colorkey) < 0 ) {
-			src->flags &= ~SDL_HWACCEL;
-		}
-	}
-	if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
-		if ( DX5_SetHWAlpha(this, src, src->format->alpha) < 0 ) {
-			src->flags &= ~SDL_HWACCEL;
-		}
-	}
+    /* Set the surface attributes */
+    if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
+        if (DX5_SetHWColorKey(this, src, src->format->colorkey) < 0) {
+            src->flags &= ~SDL_HWACCEL;
+        }
+    }
+    if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
+        if (DX5_SetHWAlpha(this, src, src->format->alpha) < 0) {
+            src->flags &= ~SDL_HWACCEL;
+        }
+    }
 
-	/* Check to see if final surface blit is accelerated */
-	accelerated = !!(src->flags & SDL_HWACCEL);
-	if ( accelerated ) {
+    /* Check to see if final surface blit is accelerated */
+    accelerated = !!(src->flags & SDL_HWACCEL);
+    if (accelerated) {
 #ifdef DDRAW_DEBUG
-  fprintf(stderr, "Setting accelerated blit on 0x%p\n", src);
+        fprintf(stderr, "Setting accelerated blit on 0x%p\n", src);
 #endif
-		src->map->hw_blit = DX5_HWAccelBlit;
-	}
-	return(accelerated);
+        src->map->hw_blit = DX5_HWAccelBlit;
+    }
+    return (accelerated);
 }
 
-static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
+static int
+DX5_FillHWRect(_THIS, SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
 {
-	LPDIRECTDRAWSURFACE3 dst_surface;
-	RECT area;
-	DDBLTFX bltfx;
-	HRESULT result;
+    LPDIRECTDRAWSURFACE3 dst_surface;
+    RECT area;
+    DDBLTFX bltfx;
+    HRESULT result;
 
 #ifdef DDRAW_DEBUG
- fprintf(stderr, "HW accelerated fill at (%d,%d)\n", dstrect->x, dstrect->y);
+    fprintf(stderr, "HW accelerated fill at (%d,%d)\n", dstrect->x,
+            dstrect->y);
 #endif
-	dst_surface = dst->hwdata->dd_writebuf;
-	area.top    = (LONG)dstrect->y;
-	area.bottom = (LONG)dstrect->y+dstrect->h;
-	area.left   = (LONG)dstrect->x;
-	area.right  = (LONG)dstrect->x+dstrect->w;
-	bltfx.dwSize = sizeof(bltfx);
+    dst_surface = dst->hwdata->dd_writebuf;
+    area.top = (LONG) dstrect->y;
+    area.bottom = (LONG) dstrect->y + dstrect->h;
+    area.left = (LONG) dstrect->x;
+    area.right = (LONG) dstrect->x + dstrect->w;
+    bltfx.dwSize = sizeof(bltfx);
 #if defined(NONAMELESSUNION)
-	bltfx.u5.dwFillColor = color;
+    bltfx.u5.dwFillColor = color;
 #else
-	bltfx.dwFillColor = color;
+    bltfx.dwFillColor = color;
 #endif
-	result = IDirectDrawSurface3_Blt(dst_surface,
-			&area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx);
-	if ( result == DDERR_SURFACELOST ) {
-		IDirectDrawSurface3_Restore(dst_surface);
-		result = IDirectDrawSurface3_Blt(dst_surface,
-			&area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx);
-	}
-	if ( result != DD_OK ) {
-		SetDDerror("IDirectDrawSurface3::Blt", result);
-		return(-1);
-	}
-	return(0);
+    result = IDirectDrawSurface3_Blt(dst_surface,
+                                     &area, NULL, NULL,
+                                     DDBLT_COLORFILL | DDBLT_WAIT, &bltfx);
+    if (result == DDERR_SURFACELOST) {
+        IDirectDrawSurface3_Restore(dst_surface);
+        result = IDirectDrawSurface3_Blt(dst_surface,
+                                         &area, NULL, NULL,
+                                         DDBLT_COLORFILL | DDBLT_WAIT,
+                                         &bltfx);
+    }
+    if (result != DD_OK) {
+        SetDDerror("IDirectDrawSurface3::Blt", result);
+        return (-1);
+    }
+    return (0);
 }
 
-static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)
+static int
+DX5_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key)
 {
-	DDCOLORKEY colorkey;
-	HRESULT result;
+    DDCOLORKEY colorkey;
+    HRESULT result;
 
-	/* Set the surface colorkey */
-	colorkey.dwColorSpaceLowValue = key;
-	colorkey.dwColorSpaceHighValue = key;
-	result = IDirectDrawSurface3_SetColorKey(
-			surface->hwdata->dd_surface, DDCKEY_SRCBLT, &colorkey);
-	if ( result != DD_OK ) {
-		SetDDerror("IDirectDrawSurface3::SetColorKey", result);
-		return(-1);
-	}
-	return(0);
+    /* Set the surface colorkey */
+    colorkey.dwColorSpaceLowValue = key;
+    colorkey.dwColorSpaceHighValue = key;
+    result =
+        IDirectDrawSurface3_SetColorKey(surface->hwdata->dd_surface,
+                                        DDCKEY_SRCBLT, &colorkey);
+    if (result != DD_OK) {
+        SetDDerror("IDirectDrawSurface3::SetColorKey", result);
+        return (-1);
+    }
+    return (0);
 }
-static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha)
+static int
+DX5_SetHWAlpha(_THIS, SDL_Surface * surface, Uint8 alpha)
 {
-	return(-1);
+    return (-1);
 }
 
-static int DX5_LockHWSurface(_THIS, SDL_Surface *surface)
+static int
+DX5_LockHWSurface(_THIS, SDL_Surface * surface)
 {
-	HRESULT result;
-	LPDIRECTDRAWSURFACE3 dd_surface;
-	DDSURFACEDESC ddsd;
+    HRESULT result;
+    LPDIRECTDRAWSURFACE3 dd_surface;
+    DDSURFACEDESC ddsd;
 
-	/* Lock and load! */
-	dd_surface = surface->hwdata->dd_writebuf;
-	SDL_memset(&ddsd, 0, sizeof(ddsd));
-	ddsd.dwSize = sizeof(ddsd);
-	result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd,
-					(DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL);
-	if ( result == DDERR_SURFACELOST ) {
-		result = IDirectDrawSurface3_Restore(
-						surface->hwdata->dd_surface);
-		result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd, 
-					(DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL);
-	}
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface3::Lock", result);
-		return(-1);
-	}
-	/* Pitch might have changed -- recalculate pitch and offset */
+    /* Lock and load! */
+    dd_surface = surface->hwdata->dd_writebuf;
+    SDL_memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd,
+                                      (DDLOCK_NOSYSLOCK | DDLOCK_WAIT), NULL);
+    if (result == DDERR_SURFACELOST) {
+        result = IDirectDrawSurface3_Restore(surface->hwdata->dd_surface);
+        result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd,
+                                          (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
+                                          NULL);
+    }
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface3::Lock", result);
+        return (-1);
+    }
+    /* Pitch might have changed -- recalculate pitch and offset */
 #if defined(NONAMELESSUNION)
-	if ( surface->pitch != ddsd.u1.lPitch ) {
-		surface->pitch = ddsd.u1.lPitch;
+    if (surface->pitch != ddsd.u1.lPitch) {
+        surface->pitch = ddsd.u1.lPitch;
 #else
-	if ( surface->pitch != ddsd.lPitch ) {
-		surface->pitch = (Uint16)ddsd.lPitch;
+    if (surface->pitch != ddsd.lPitch) {
+        surface->pitch = (Uint16) ddsd.lPitch;
 #endif
-		surface->offset =
-			((ddsd.dwHeight-surface->h)/2)*surface->pitch +
-			((ddsd.dwWidth-surface->w)/2)*
-					surface->format->BytesPerPixel;
-	}
-	surface->pixels = ddsd.lpSurface;
-	return(0);
+        surface->offset =
+            ((ddsd.dwHeight - surface->h) / 2) * surface->pitch +
+            ((ddsd.dwWidth - surface->w) / 2) *
+            surface->format->BytesPerPixel;
+    }
+    surface->pixels = ddsd.lpSurface;
+    return (0);
 }
 
-static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface)
+static void
+DX5_UnlockHWSurface(_THIS, SDL_Surface * surface)
 {
-	IDirectDrawSurface3_Unlock(surface->hwdata->dd_writebuf, NULL);
-	surface->pixels = NULL;
+    IDirectDrawSurface3_Unlock(surface->hwdata->dd_writebuf, NULL);
+    surface->pixels = NULL;
 }
 
-static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface)
+static int
+DX5_FlipHWSurface(_THIS, SDL_Surface * surface)
 {
-	HRESULT result;
-	LPDIRECTDRAWSURFACE3 dd_surface;
+    HRESULT result;
+    LPDIRECTDRAWSURFACE3 dd_surface;
 
-	dd_surface = surface->hwdata->dd_surface;
+    dd_surface = surface->hwdata->dd_surface;
 
-	/* to prevent big slowdown on fast computers, wait here instead of driver ring 0 code */
-	/* Dmitry Yakimov (ftech@tula.net) */
-	while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING);
+    /* to prevent big slowdown on fast computers, wait here instead of driver ring 0 code */
+    /* Dmitry Yakimov (ftech@tula.net) */
+    while (IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) ==
+           DDERR_WASSTILLDRAWING);
 
-	result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT);
-	if ( result == DDERR_SURFACELOST ) {
-		result = IDirectDrawSurface3_Restore(
-						surface->hwdata->dd_surface);
-		while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING);
-		result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT);
-	}
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface3::Flip", result);
-		return(-1);
-	}
-	return(0);
+    result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT);
+    if (result == DDERR_SURFACELOST) {
+        result = IDirectDrawSurface3_Restore(surface->hwdata->dd_surface);
+        while (IDirectDrawSurface3_GetFlipStatus
+               (dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING);
+        result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT);
+    }
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface3::Flip", result);
+        return (-1);
+    }
+    return (0);
 }
 
-static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface)
+static void
+DX5_FreeHWSurface(_THIS, SDL_Surface * surface)
 {
-	if ( surface->hwdata ) {
-		if ( surface->hwdata->dd_surface != SDL_primary ) {
-			IDirectDrawSurface3_Release(surface->hwdata->dd_surface);
-		}
-		SDL_free(surface->hwdata);
-		surface->hwdata = NULL;
-	}
+    if (surface->hwdata) {
+        if (surface->hwdata->dd_surface != SDL_primary) {
+            IDirectDrawSurface3_Release(surface->hwdata->dd_surface);
+        }
+        SDL_free(surface->hwdata);
+        surface->hwdata = NULL;
+    }
 }
 
-void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects)
+void
+DX5_WindowUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
-	HRESULT result;
-	int i;
-	RECT src, dst;
+    HRESULT result;
+    int i;
+    RECT src, dst;
 
-	for ( i=0; i<numrects; ++i ) {
-		src.top    = (LONG)rects[i].y;
-		src.bottom = (LONG)rects[i].y+rects[i].h;
-		src.left   = (LONG)rects[i].x;
-		src.right  = (LONG)rects[i].x+rects[i].w;
-		dst.top    = SDL_bounds.top+src.top;
-		dst.left   = SDL_bounds.left+src.left;
-		dst.bottom = SDL_bounds.top+src.bottom;
-		dst.right  = SDL_bounds.left+src.right;
-		result = IDirectDrawSurface3_Blt(SDL_primary, &dst, 
-					this->screen->hwdata->dd_surface, &src,
-							DDBLT_WAIT, NULL);
-		/* Doh!  Check for lost surface and restore it */
-		if ( result == DDERR_SURFACELOST ) {
-			IDirectDrawSurface3_Restore(SDL_primary);
-			IDirectDrawSurface3_Blt(SDL_primary, &dst, 
-					this->screen->hwdata->dd_surface, &src,
-							DDBLT_WAIT, NULL);
-		}
-	}
+    for (i = 0; i < numrects; ++i) {
+        src.top = (LONG) rects[i].y;
+        src.bottom = (LONG) rects[i].y + rects[i].h;
+        src.left = (LONG) rects[i].x;
+        src.right = (LONG) rects[i].x + rects[i].w;
+        dst.top = SDL_bounds.top + src.top;
+        dst.left = SDL_bounds.left + src.left;
+        dst.bottom = SDL_bounds.top + src.bottom;
+        dst.right = SDL_bounds.left + src.right;
+        result = IDirectDrawSurface3_Blt(SDL_primary, &dst,
+                                         this->screen->hwdata->dd_surface,
+                                         &src, DDBLT_WAIT, NULL);
+        /* Doh!  Check for lost surface and restore it */
+        if (result == DDERR_SURFACELOST) {
+            IDirectDrawSurface3_Restore(SDL_primary);
+            IDirectDrawSurface3_Blt(SDL_primary, &dst,
+                                    this->screen->hwdata->dd_surface,
+                                    &src, DDBLT_WAIT, NULL);
+        }
+    }
 }
 
-void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
+void
+DX5_DirectUpdate(_THIS, int numrects, SDL_Rect * rects)
 {
 }
 
@@ -2164,345 +2225,355 @@
 	int b = (A.b - B.b);						\
 	(r*r + g*g + b*b);						\
 })
-static void DX5_CompressPalette(_THIS, SDL_Color *colors, int ncolors, int maxcolors)
+static void
+DX5_CompressPalette(_THIS, SDL_Color * colors, int ncolors, int maxcolors)
 {
 #ifdef SIMPLE_COMPRESSION
-	int i, j;
+    int i, j;
 #else
-	static SDL_Color zero = { 0, 0, 0, 0 };
-	int i, j;
-	int max, dist;
-	int prev, next;
-	int *pool;
-	int *seen, *order;
+    static SDL_Color zero = { 0, 0, 0, 0 };
+    int i, j;
+    int max, dist;
+    int prev, next;
+    int *pool;
+    int *seen, *order;
 #endif
 
-	/* Does this happen? */
-	if ( maxcolors > ncolors ) {
-		maxcolors = ncolors;
-	}
-
+    /* Does this happen? */
+    if (maxcolors > ncolors) {
+        maxcolors = ncolors;
+    }
 #ifdef SIMPLE_COMPRESSION
-	/* Just copy the first "maxcolors" colors */
-	for ( j=10, i=0; i<maxcolors; ++i, ++j ) {
-		SDL_colors[j].peRed = colors[i].r;
-		SDL_colors[j].peGreen = colors[i].g;
-		SDL_colors[j].peBlue = colors[i].b;
-	}
+    /* Just copy the first "maxcolors" colors */
+    for (j = 10, i = 0; i < maxcolors; ++i, ++j) {
+        SDL_colors[j].peRed = colors[i].r;
+        SDL_colors[j].peGreen = colors[i].g;
+        SDL_colors[j].peBlue = colors[i].b;
+    }
 #else
-	/* Allocate memory for the arrays we use */
-	pool = SDL_stack_alloc(int, 2*ncolors);
-	if ( pool == NULL ) {
-		/* No worries, just return */;
-		return;
-	}
-	seen = pool;
-	SDL_memset(seen, 0, ncolors*sizeof(int));
-	order = pool+ncolors;
+    /* Allocate memory for the arrays we use */
+    pool = SDL_stack_alloc(int, 2 * ncolors);
+    if (pool == NULL) {
+        /* No worries, just return */ ;
+        return;
+    }
+    seen = pool;
+    SDL_memset(seen, 0, ncolors * sizeof(int));
+    order = pool + ncolors;
 
-	/* Start with the brightest color */
-	max = 0;
-	for ( i=0; i<ncolors; ++i ) {
-		dist = CS_CS_DIST(zero, colors[i]);
-		if ( dist >= max ) {
-			max = dist;
-			next = i;
-		}
-	}
-	j = 0;
-	order[j++] = next;
-	seen[next] = 1;
-	prev = next;
+    /* Start with the brightest color */
+    max = 0;
+    for (i = 0; i < ncolors; ++i) {
+        dist = CS_CS_DIST(zero, colors[i]);
+        if (dist >= max) {
+            max = dist;
+            next = i;
+        }
+    }
+    j = 0;
+    order[j++] = next;
+    seen[next] = 1;
+    prev = next;
 
-	/* Keep going through all the colors */
-	while ( j < maxcolors ) {
-		max = 0;
-		for ( i=0; i<ncolors; ++i ) {
-			if ( seen[i] ) {
-				continue;
-			}
-			dist = CS_CS_DIST(colors[i], colors[prev]);
-			if ( dist >= max ) {
-				max = dist;
-				next = i;
-			}
-		}
-		order[j++] = next;
-		seen[next] = 1;
-		prev = next;
-	}
+    /* Keep going through all the colors */
+    while (j < maxcolors) {
+        max = 0;
+        for (i = 0; i < ncolors; ++i) {
+            if (seen[i]) {
+                continue;
+            }
+            dist = CS_CS_DIST(colors[i], colors[prev]);
+            if (dist >= max) {
+                max = dist;
+                next = i;
+            }
+        }
+        order[j++] = next;
+        seen[next] = 1;
+        prev = next;
+    }
 
-	/* Compress the colors to the palette */
-	for ( j=10, i=0; i<maxcolors; ++i, ++j ) {
-		SDL_colors[j].peRed = colors[order[i]].r;
-		SDL_colors[j].peGreen = colors[order[i]].g;
-		SDL_colors[j].peBlue = colors[order[i]].b;
-	}
-	SDL_stack_free(pool);
+    /* Compress the colors to the palette */
+    for (j = 10, i = 0; i < maxcolors; ++i, ++j) {
+        SDL_colors[j].peRed = colors[order[i]].r;
+        SDL_colors[j].peGreen = colors[order[i]].g;
+        SDL_colors[j].peBlue = colors[order[i]].b;
+    }
+    SDL_stack_free(pool);
 #endif /* SIMPLE_COMPRESSION */
 }
 
 /* Set the system colormap in both fullscreen and windowed modes */
-int DX5_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+int
+DX5_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
 {
-	int i;
-	int alloct_all;
+    int i;
+    int alloct_all;
 
-	/* Copy palette colors into display palette */
-	alloct_all = 0;
-	if ( SDL_palette != NULL ) {
-		if ( (this->screen->flags&SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
-			/* We can set all entries explicitly */
-			for ( i=0; i< ncolors; ++i ) {
-			        int j = firstcolor + i;
-				SDL_colors[j].peRed = colors[i].r;
-				SDL_colors[j].peGreen = colors[i].g;
-				SDL_colors[j].peBlue = colors[i].b;
-			}
-			IDirectDrawPalette_SetEntries(SDL_palette, 0,
-				firstcolor, ncolors, &SDL_colors[firstcolor]);
-			alloct_all = 1;
-		} else {
-			/* Grab the 236 most diverse colors in the palette */
-			DX5_CompressPalette(this, colors, ncolors, 236);
-			/* This sends an WM_PALETTECHANGED message to us */
-			colorchange_expected = 1;
-			IDirectDrawPalette_SetEntries(SDL_palette, 0,
-							0, 256, SDL_colors);
-		}
-	}
-	return(alloct_all);
+    /* Copy palette colors into display palette */
+    alloct_all = 0;
+    if (SDL_palette != NULL) {
+        if ((this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
+            /* We can set all entries explicitly */
+            for (i = 0; i < ncolors; ++i) {
+                int j = firstcolor + i;
+                SDL_colors[j].peRed = colors[i].r;
+                SDL_colors[j].peGreen = colors[i].g;
+                SDL_colors[j].peBlue = colors[i].b;
+            }
+            IDirectDrawPalette_SetEntries(SDL_palette, 0,
+                                          firstcolor, ncolors,
+                                          &SDL_colors[firstcolor]);
+            alloct_all = 1;
+        } else {
+            /* Grab the 236 most diverse colors in the palette */
+            DX5_CompressPalette(this, colors, ncolors, 236);
+            /* This sends an WM_PALETTECHANGED message to us */
+            colorchange_expected = 1;
+            IDirectDrawPalette_SetEntries(SDL_palette, 0, 0, 256, SDL_colors);
+        }
+    }
+    return (alloct_all);
 }
 
 /* Gamma code is only available on DirectX 7 and newer */
-static int DX5_SetGammaRamp(_THIS, Uint16 *ramp)
+static int
+DX5_SetGammaRamp(_THIS, Uint16 * ramp)
 {
 #ifdef IDirectDrawGammaControl_SetGammaRamp
-	LPDIRECTDRAWGAMMACONTROL gamma;
-	DDGAMMARAMP gamma_ramp;
-	HRESULT result;
+    LPDIRECTDRAWGAMMACONTROL gamma;
+    DDGAMMARAMP gamma_ramp;
+    HRESULT result;
 #endif
 
-	/* In windowed or OpenGL mode, use windib gamma code */
-	if ( ! DDRAW_FULLSCREEN() ) {
-		return DIB_SetGammaRamp(this, ramp);
-	}
-
+    /* In windowed or OpenGL mode, use windib gamma code */
+    if (!DDRAW_FULLSCREEN()) {
+        return DIB_SetGammaRamp(this, ramp);
+    }
 #ifndef IDirectDrawGammaControl_SetGammaRamp
-	SDL_SetError("SDL compiled without DirectX gamma ramp support");
-	return -1;
+    SDL_SetError("SDL compiled without DirectX gamma ramp support");
+    return -1;
 #else
-	/* Check for a video mode! */
-	if ( ! SDL_primary ) {
-		SDL_SetError("A video mode must be set for gamma correction");
-		return(-1);
-	}
+    /* Check for a video mode! */
+    if (!SDL_primary) {
+        SDL_SetError("A video mode must be set for gamma correction");
+        return (-1);
+    }
 
-	/* Get the gamma control object */
-	result = IDirectDrawSurface3_QueryInterface(SDL_primary,
-			&IID_IDirectDrawGammaControl, (LPVOID *)&gamma);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result);
-		return(-1);
-	}
+    /* Get the gamma control object */
+    result = IDirectDrawSurface3_QueryInterface(SDL_primary,
+                                                &IID_IDirectDrawGammaControl,
+                                                (LPVOID *) & gamma);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result);
+        return (-1);
+    }
 
-	/* Set up the gamma ramp */
-	SDL_memcpy(gamma_ramp.red, &ramp[0*256], 256*sizeof(*ramp));
-	SDL_memcpy(gamma_ramp.green, &ramp[1*256], 256*sizeof(*ramp));
-	SDL_memcpy(gamma_ramp.blue, &ramp[2*256], 256*sizeof(*ramp));
-	result = IDirectDrawGammaControl_SetGammaRamp(gamma, 0, &gamma_ramp);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawGammaControl::SetGammaRamp()", result);
-	}
+    /* Set up the gamma ramp */
+    SDL_memcpy(gamma_ramp.red, &ramp[0 * 256], 256 * sizeof(*ramp));
+    SDL_memcpy(gamma_ramp.green, &ramp[1 * 256], 256 * sizeof(*ramp));
+    SDL_memcpy(gamma_ramp.blue, &ramp[2 * 256], 256 * sizeof(*ramp));
+    result = IDirectDrawGammaControl_SetGammaRamp(gamma, 0, &gamma_ramp);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawGammaControl::SetGammaRamp()", result);
+    }
 
-	/* Release the interface and return */
-	IDirectDrawGammaControl_Release(gamma);
-	return (result == DD_OK) ? 0 : -1;
+    /* Release the interface and return */
+    IDirectDrawGammaControl_Release(gamma);
+    return (result == DD_OK) ? 0 : -1;
 #endif /* !IDirectDrawGammaControl_SetGammaRamp */
 }
 
-static int DX5_GetGammaRamp(_THIS, Uint16 *ramp)
+static int
+DX5_GetGammaRamp(_THIS, Uint16 * ramp)
 {
 #ifdef IDirectDrawGammaControl_SetGammaRamp
-	LPDIRECTDRAWGAMMACONTROL gamma;
-	DDGAMMARAMP gamma_ramp;
-	HRESULT result;
+    LPDIRECTDRAWGAMMACONTROL gamma;
+    DDGAMMARAMP gamma_ramp;
+    HRESULT result;
 #endif
 
-	/* In windowed or OpenGL mode, use windib gamma code */
-	if ( ! DDRAW_FULLSCREEN() ) {
-		return DIB_GetGammaRamp(this, ramp);
-	}
-
+    /* In windowed or OpenGL mode, use windib gamma code */
+    if (!DDRAW_FULLSCREEN()) {
+        return DIB_GetGammaRamp(this, ramp);
+    }
 #ifndef IDirectDrawGammaControl_SetGammaRamp
-	SDL_SetError("SDL compiled without DirectX gamma ramp support");
-	return -1;
+    SDL_SetError("SDL compiled without DirectX gamma ramp support");
+    return -1;
 #else
-	/* Check for a video mode! */
-	if ( ! SDL_primary ) {
-		SDL_SetError("A video mode must be set for gamma correction");
-		return(-1);
-	}
+    /* Check for a video mode! */
+    if (!SDL_primary) {
+        SDL_SetError("A video mode must be set for gamma correction");
+        return (-1);
+    }
 
-	/* Get the gamma control object */
-	result = IDirectDrawSurface3_QueryInterface(SDL_primary,
-			&IID_IDirectDrawGammaControl, (LPVOID *)&gamma);
-	if ( result != DD_OK ) {
-		SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result);
-		return(-1);
-	}
+    /* Get the gamma control object */
+    result = IDirectDrawSurface3_QueryInterface(SDL_primary,
+                                                &IID_IDirectDrawGammaControl,
+                                                (LPVOID *) & gamma);
+    if (result != DD_OK) {
+        SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result);
+        return (-1);
+    }
 
-	/* Set up the gamma ramp */
-	result = IDirectDrawGammaControl_GetGammaRamp(gamma, 0, &gamma_ramp);
-	if ( result == DD_OK ) {
-		SDL_memcpy(&ramp[0*256], gamma_ramp.red, 256*sizeof(*ramp));
-		SDL_memcpy(&ramp[1*256], gamma_ramp.green, 256*sizeof(*ramp));
-		SDL_memcpy(&ramp[2*256], gamma_ramp.blue, 256*sizeof(*ramp));
-	} else {
-		SetDDerror("DirectDrawGammaControl::GetGammaRamp()", result);
-	}
+    /* Set up the gamma ramp */
+    result = IDirectDrawGammaControl_GetGammaRamp(gamma, 0, &gamma_ramp);
+    if (result == DD_OK) {
+        SDL_memcpy(&ramp[0 * 256], gamma_ramp.red, 256 * sizeof(*ramp));
+        SDL_memcpy(&ramp[1 * 256], gamma_ramp.green, 256 * sizeof(*ramp));
+        SDL_memcpy(&ramp[2 * 256], gamma_ramp.blue, 256 * sizeof(*ramp));
+    } else {
+        SetDDerror("DirectDrawGammaControl::GetGammaRamp()", result);
+    }
 
-	/* Release the interface and return */
-	IDirectDrawGammaControl_Release(gamma);
-	return (result == DD_OK) ? 0 : -1;
+    /* Release the interface and return */
+    IDirectDrawGammaControl_Release(gamma);
+    return (result == DD_OK) ? 0 : -1;
 #endif /* !IDirectDrawGammaControl_SetGammaRamp */
 }
 
-void DX5_VideoQuit(_THIS)
+void
+DX5_VideoQuit(_THIS)
 {
-	int i, j;
+    int i, j;
 
-	/* If we're fullscreen GL, we need to reset the display */
-	if ( this->screen != NULL ) {
+    /* If we're fullscreen GL, we need to reset the display */
+    if (this->screen != NULL) {
 #ifndef NO_CHANGEDISPLAYSETTINGS
-		if ( (this->screen->flags & (SDL_OPENGL|SDL_FULLSCREEN)) ==
-		                            (SDL_OPENGL|SDL_FULLSCREEN) ) {
-			ChangeDisplaySettings(NULL, 0);
-			ShowWindow(SDL_Window, SW_HIDE);
-		}
+        if ((this->screen->flags & (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) ==
+            (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) {
+            ChangeDisplaySettings(NULL, 0);
+            ShowWindow(SDL_Window, SW_HIDE);
+        }
 #endif
-		if ( this->screen->flags & SDL_OPENGL ) {
-			WIN_GL_ShutDown(this);
-		}
-	}
+        if (this->screen->flags & SDL_INTERNALOPENGL) {
+            WIN_GL_ShutDown(this);
+        }
+    }
 
-	/* Free any palettes we used */
-	if ( SDL_palette != NULL ) {
-		IDirectDrawPalette_Release(SDL_palette);
-		SDL_palette = NULL;
-	}
+    /* Free any palettes we used */
+    if (SDL_palette != NULL) {
+        IDirectDrawPalette_Release(SDL_palette);
+        SDL_palette = NULL;
+    }
 
-	/* Allow the primary surface to be freed */
-	if ( SDL_primary != NULL ) {
-		SDL_primary = NULL;
-	}
+    /* Allow the primary surface to be freed */
+    if (SDL_primary != NULL) {
+        SDL_primary = NULL;
+    }
 
-	/* Free video mode lists */
-	for ( i=0; i<NUM_MODELISTS; ++i ) {
-		if ( SDL_modelist[i] != NULL ) {
-			for ( j=0; SDL_modelist[i][j]; ++j )
-				SDL_free(SDL_modelist[i][j]);
-			SDL_free(SDL_modelist[i]);
-			SDL_modelist[i] = NULL;
-		}
-	}
+    /* Free video mode lists */
+    for (i = 0; i < NUM_MODELISTS; ++i) {
+        if (SDL_modelist[i] != NULL) {
+            for (j = 0; SDL_modelist[i][j]; ++j)
+                SDL_free(SDL_modelist[i][j]);
+            SDL_free(SDL_modelist[i]);
+            SDL_modelist[i] = NULL;
+        }
+    }
 
-	/* Free the window */
-	DIB_QuitGamma(this);
-	if ( SDL_Window ) {
-		DX5_DestroyWindow(this);
-	}
+    /* Free the window */
+    DIB_QuitGamma(this);
+    if (SDL_Window) {
+        DX5_DestroyWindow(this);
+    }
 
-	/* Free our window icon */
-	if ( screen_icn ) {
-		DestroyIcon(screen_icn);
-		screen_icn = NULL;
-	}
+    /* Free our window icon */
+    if (screen_icn) {
+        DestroyIcon(screen_icn);
+        screen_icn = NULL;
+    }
 }
 
 /* Exported for the windows message loop only */
-void DX5_RealizePalette(_THIS)
+void
+DX5_RealizePalette(_THIS)
 {
-	if ( SDL_palette ) {
-		IDirectDrawSurface3_SetPalette(SDL_primary, SDL_palette);
-	}
+    if (SDL_palette) {
+        IDirectDrawSurface3_SetPalette(SDL_primary, SDL_palette);
+    }
 }
-static void DX5_Recolor8Bit(_THIS, SDL_Surface *surface, Uint8 *mapping)
+static void
+DX5_Recolor8Bit(_THIS, SDL_Surface * surface, Uint8 * mapping)
 {
-	int row, col;
-	Uint8 *pixels;
+    int row, col;
+    Uint8 *pixels;
 
-	if ( surface->w && surface->h ) {
-		if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-			if ( this->LockHWSurface(this, surface) < 0 ) {
-				return;
-			}
-		}
-		for ( row=0; row<surface->h; ++row ) {
-			pixels = (Uint8 *)surface->pixels+row*surface->pitch;
-			for ( col=0; col<surface->w; ++col, ++pixels ) {
-				*pixels = mapping[*pixels];
-			}
-		}
-		if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
-			this->UnlockHWSurface(this, surface);
-		}
-		SDL_UpdateRect(surface, 0, 0, 0, 0);
-	}
+    if (surface->w && surface->h) {
+        if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+            if (this->LockHWSurface(this, surface) < 0) {
+                return;
+            }
+        }
+        for (row = 0; row < surface->h; ++row) {
+            pixels = (Uint8 *) surface->pixels + row * surface->pitch;
+            for (col = 0; col < surface->w; ++col, ++pixels) {
+                *pixels = mapping[*pixels];
+            }
+        }
+        if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
+            this->UnlockHWSurface(this, surface);
+        }
+        SDL_UpdateRect(surface, 0, 0, 0, 0);
+    }
 }
-void DX5_PaletteChanged(_THIS, HWND window)
+void
+DX5_PaletteChanged(_THIS, HWND window)
 {
-	SDL_Palette *palette;
-	SDL_Color *saved = NULL;
-	HDC hdc;
-	int i;
-	PALETTEENTRY *entries;
+    SDL_Palette *palette;
+    SDL_Color *saved = NULL;
+    HDC hdc;
+    int i;
+    PALETTEENTRY *entries;
 
-	/* This is true when the window is closing */
-	if ( (SDL_primary == NULL) || (SDL_VideoSurface == NULL) )
-		return;
+    /* This is true when the window is closing */
+    if ((SDL_primary == NULL) || (SDL_VideoSurface == NULL))
+        return;
 
-	/* We need to get the colors as they were set */
-	palette = this->physpal;
-	if(!palette)
-	        palette = SDL_VideoSurface->format->palette;
-	if ( palette == NULL ) { /* Sometimes we don't have a palette */
-		return;
-	}
-	entries = SDL_stack_alloc(PALETTEENTRY, palette->ncolors);
-	hdc = GetDC(window);
-	GetSystemPaletteEntries(hdc, 0, palette->ncolors, entries);
-	ReleaseDC(window, hdc);
-	if ( ! colorchange_expected ) {
-		saved = SDL_stack_alloc(SDL_Color, palette->ncolors);
-		SDL_memcpy(saved, palette->colors, 
-					palette->ncolors*sizeof(SDL_Color));
-	}
-	for ( i=0; i<palette->ncolors; ++i ) {
-		palette->colors[i].r = entries[i].peRed;
-		palette->colors[i].g = entries[i].peGreen;
-		palette->colors[i].b = entries[i].peBlue;
-	}
-	SDL_stack_free(entries);
-	if ( ! colorchange_expected ) {
-		Uint8 mapping[256];
+    /* We need to get the colors as they were set */
+    palette = this->physpal;
+    if (!palette)
+        palette = SDL_VideoSurface->format->palette;
+    if (palette == NULL) {      /* Sometimes we don't have a palette */
+        return;
+    }
+    entries = SDL_stack_alloc(PALETTEENTRY, palette->ncolors);
+    hdc = GetDC(window);
+    GetSystemPaletteEntries(hdc, 0, palette->ncolors, entries);
+    ReleaseDC(window, hdc);
+    if (!colorchange_expected) {
+        saved = SDL_stack_alloc(SDL_Color, palette->ncolors);
+        SDL_memcpy(saved, palette->colors,
+                   palette->ncolors * sizeof(SDL_Color));
+    }
+    for (i = 0; i < palette->ncolors; ++i) {
+        palette->colors[i].r = entries[i].peRed;
+        palette->colors[i].g = entries[i].peGreen;
+        palette->colors[i].b = entries[i].peBlue;
+    }
+    SDL_stack_free(entries);
+    if (!colorchange_expected) {
+        Uint8 mapping[256];
 
-		SDL_memset(mapping, 0, sizeof(mapping));
-		for ( i=0; i<palette->ncolors; ++i ) {
-			mapping[i] = SDL_FindColor(palette,
-					saved[i].r, saved[i].g, saved[i].b);
-		}
-		DX5_Recolor8Bit(this, SDL_VideoSurface, mapping);
-		SDL_stack_free(saved);
-	}
-	colorchange_expected = 0;
+        SDL_memset(mapping, 0, sizeof(mapping));
+        for (i = 0; i < palette->ncolors; ++i) {
+            mapping[i] = SDL_FindColor(palette,
+                                       saved[i].r, saved[i].g, saved[i].b);
+        }
+        DX5_Recolor8Bit(this, SDL_VideoSurface, mapping);
+        SDL_stack_free(saved);
+    }
+    colorchange_expected = 0;
 
-	/* Notify all mapped surfaces of the change */
-	SDL_FormatChanged(SDL_VideoSurface);
+    /* Notify all mapped surfaces of the change */
+    SDL_FormatChanged(SDL_VideoSurface);
 }
 
 /* Exported for the windows message loop only */
-void DX5_WinPAINT(_THIS, HDC hdc)
+void
+DX5_WinPAINT(_THIS, HDC hdc)
 {
-	SDL_UpdateRect(SDL_PublicSurface, 0, 0, 0, 0);
+    SDL_UpdateRect(SDL_PublicSurface, 0, 0, 0, 0);
 }
+
+/* vi: set ts=4 sw=4 expandtab: */