Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 766 insertions, 862 deletions

diff --git a/xorg-server/hw/xwin/winshadgdi.c b/xorg-server/hw/xwin/winshadgdi.c
index a11ca43bd..c4d1da8d0 100644
--- a/xorg-server/hw/xwin/winshadgdi.c
+++ b/xorg-server/hw/xwin/winshadgdi.c
@@ -33,410 +33,382 @@
 #endif
 #include "win.h"
 
-
 /*
  * Local function prototypes
  */
 
 #ifdef XWIN_MULTIWINDOW
-static wBOOL CALLBACK
-winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam);
+static wBOOL CALLBACK winRedrawAllProcShadowGDI(HWND hwnd, LPARAM lParam);
 
-static wBOOL CALLBACK
-winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam);
+static wBOOL CALLBACK winRedrawDamagedWindowShadowGDI(HWND hwnd, LPARAM lParam);
 #endif
 
 static Bool
-winAllocateFBShadowGDI (ScreenPtr pScreen);
+ winAllocateFBShadowGDI(ScreenPtr pScreen);
 
 static void
-winShadowUpdateGDI (ScreenPtr pScreen, 
-		    shadowBufPtr pBuf);
+ winShadowUpdateGDI(ScreenPtr pScreen, shadowBufPtr pBuf);
 
 static Bool
-winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen);
+ winCloseScreenShadowGDI(int nIndex, ScreenPtr pScreen);
 
 static Bool
-winInitVisualsShadowGDI (ScreenPtr pScreen);
+ winInitVisualsShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winAdjustVideoModeShadowGDI (ScreenPtr pScreen);
+ winAdjustVideoModeShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winBltExposedRegionsShadowGDI (ScreenPtr pScreen);
+ winBltExposedRegionsShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winActivateAppShadowGDI (ScreenPtr pScreen);
+ winActivateAppShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winRedrawScreenShadowGDI (ScreenPtr pScreen);
+ winRedrawScreenShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen);
+ winRealizeInstalledPaletteShadowGDI(ScreenPtr pScreen);
 
 static Bool
-winInstallColormapShadowGDI (ColormapPtr pColormap);
+ winInstallColormapShadowGDI(ColormapPtr pColormap);
 
 static Bool
-winStoreColorsShadowGDI (ColormapPtr pmap, 
-			 int ndef,
-			 xColorItem *pdefs);
+ winStoreColorsShadowGDI(ColormapPtr pmap, int ndef, xColorItem * pdefs);
 
 static Bool
-winCreateColormapShadowGDI (ColormapPtr pColormap);
+ winCreateColormapShadowGDI(ColormapPtr pColormap);
 
 static Bool
-winDestroyColormapShadowGDI (ColormapPtr pColormap);
-
+ winDestroyColormapShadowGDI(ColormapPtr pColormap);
 
 /*
  * Internal function to get the DIB format that is compatible with the screen
  */
 
 static
-Bool
-winQueryScreenDIBFormat (ScreenPtr pScreen, BITMAPINFOHEADER *pbmih)
+    Bool
+winQueryScreenDIBFormat(ScreenPtr pScreen, BITMAPINFOHEADER * pbmih)
 {
-  winScreenPriv(pScreen);
-  HBITMAP		hbmp;
+    winScreenPriv(pScreen);
+    HBITMAP hbmp;
 #ifdef WINDBG
-  LPDWORD		pdw = NULL;
+    LPDWORD pdw = NULL;
 #endif
-  
-  /* Create a memory bitmap compatible with the screen */
-  hbmp = CreateCompatibleBitmap (pScreenPriv->hdcScreen, 1, 1);
-  if (hbmp == NULL)
-    {
-      ErrorF ("winQueryScreenDIBFormat - CreateCompatibleBitmap failed\n");
-      return FALSE;
+
+    /* Create a memory bitmap compatible with the screen */
+    hbmp = CreateCompatibleBitmap(pScreenPriv->hdcScreen, 1, 1);
+    if (hbmp == NULL) {
+        ErrorF("winQueryScreenDIBFormat - CreateCompatibleBitmap failed\n");
+        return FALSE;
     }
-  
-  /* Initialize our bitmap info header */
-  ZeroMemory (pbmih, sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));
-  pbmih->biSize = sizeof (BITMAPINFOHEADER);
-
-  /* Get the biBitCount */
-  if (!GetDIBits (pScreenPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*) pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winQueryScreenDIBFormat - First call to GetDIBits failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
+
+    /* Initialize our bitmap info header */
+    ZeroMemory(pbmih, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+    pbmih->biSize = sizeof(BITMAPINFOHEADER);
+
+    /* Get the biBitCount */
+    if (!GetDIBits(pScreenPriv->hdcScreen,
+                   hbmp, 0, 1, NULL, (BITMAPINFO *) pbmih, DIB_RGB_COLORS)) {
+        ErrorF("winQueryScreenDIBFormat - First call to GetDIBits failed\n");
+        DeleteObject(hbmp);
+        return FALSE;
     }
 
 #ifdef WINDBG
-  /* Get a pointer to bitfields */
-  pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));
+    /* Get a pointer to bitfields */
+    pdw = (DWORD *) ((CARD8 *) pbmih + sizeof(BITMAPINFOHEADER));
 
-  winDebug ("winQueryScreenDIBFormat - First call masks: %08x %08x %08x\n",
-	  pdw[0], pdw[1], pdw[2]);
+    winDebug("winQueryScreenDIBFormat - First call masks: %08x %08x %08x\n",
+             pdw[0], pdw[1], pdw[2]);
 #endif
 
-  /* Get optimal color table, or the optimal bitfields */
-  if (!GetDIBits (pScreenPriv->hdcScreen,
-		  hbmp,
-		  0, 1,
-		  NULL,
-		  (BITMAPINFO*)pbmih,
-		  DIB_RGB_COLORS))
-    {
-      ErrorF ("winQueryScreenDIBFormat - Second call to GetDIBits "
-	      "failed\n");
-      DeleteObject (hbmp);
-      return FALSE;
+    /* Get optimal color table, or the optimal bitfields */
+    if (!GetDIBits(pScreenPriv->hdcScreen,
+                   hbmp, 0, 1, NULL, (BITMAPINFO *) pbmih, DIB_RGB_COLORS)) {
+        ErrorF("winQueryScreenDIBFormat - Second call to GetDIBits "
+               "failed\n");
+        DeleteObject(hbmp);
+        return FALSE;
     }
 
-  /* Free memory */
-  DeleteObject (hbmp);
-  
-  return TRUE;
-}
+    /* Free memory */
+    DeleteObject(hbmp);
 
+    return TRUE;
+}
 
 /*
  * Internal function to determine the GDI bits per rgb and bit masks
  */
 
 static
-Bool
-winQueryRGBBitsAndMasks (ScreenPtr pScreen)
+    Bool
+winQueryRGBBitsAndMasks(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  BITMAPINFOHEADER	*pbmih = NULL;
-  Bool			fReturn = TRUE;
-  LPDWORD		pdw = NULL;
-  DWORD			dwRedBits, dwGreenBits, dwBlueBits;
-
-  /* Color masks for 8 bpp are standardized */
-  if (GetDeviceCaps (pScreenPriv->hdcScreen, RASTERCAPS) & RC_PALETTE)
-    {
-      /* 
-       * RGB BPP for 8 bit palletes is always 8
-       * and the color masks are always 0.
-       */
-      pScreenPriv->dwBitsPerRGB = 8;
-      pScreenPriv->dwRedMask = 0x0L;
-      pScreenPriv->dwGreenMask = 0x0L;
-      pScreenPriv->dwBlueMask = 0x0L;
-      return TRUE;
+    winScreenPriv(pScreen);
+    BITMAPINFOHEADER *pbmih = NULL;
+    Bool fReturn = TRUE;
+    LPDWORD pdw = NULL;
+    DWORD dwRedBits, dwGreenBits, dwBlueBits;
+
+    /* Color masks for 8 bpp are standardized */
+    if (GetDeviceCaps(pScreenPriv->hdcScreen, RASTERCAPS) & RC_PALETTE) {
+        /* 
+         * RGB BPP for 8 bit palletes is always 8
+         * and the color masks are always 0.
+         */
+        pScreenPriv->dwBitsPerRGB = 8;
+        pScreenPriv->dwRedMask = 0x0L;
+        pScreenPriv->dwGreenMask = 0x0L;
+        pScreenPriv->dwBlueMask = 0x0L;
+        return TRUE;
     }
 
-  /* Color masks for 24 bpp are standardized */
-  if (GetDeviceCaps (pScreenPriv->hdcScreen, PLANES)
-      * GetDeviceCaps (pScreenPriv->hdcScreen, BITSPIXEL) == 24)
-    {
-      winDebug ("winQueryRGBBitsAndMasks - GetDeviceCaps (BITSPIXEL) "
-	      "returned 24 for the screen.  Using default 24bpp masks.\n");
-
-      /* 8 bits per primary color */
-      pScreenPriv->dwBitsPerRGB = 8;
-
-      /* Set screen privates masks */
-      pScreenPriv->dwRedMask = WIN_24BPP_MASK_RED;
-      pScreenPriv->dwGreenMask = WIN_24BPP_MASK_GREEN;
-      pScreenPriv->dwBlueMask = WIN_24BPP_MASK_BLUE;
-      
-      return TRUE;
+    /* Color masks for 24 bpp are standardized */
+    if (GetDeviceCaps(pScreenPriv->hdcScreen, PLANES)
+        * GetDeviceCaps(pScreenPriv->hdcScreen, BITSPIXEL) == 24) {
+        winDebug ("winQueryRGBBitsAndMasks - GetDeviceCaps (BITSPIXEL) "
+                  "returned 24 for the screen.  Using default 24bpp masks.\n");
+
+        /* 8 bits per primary color */
+        pScreenPriv->dwBitsPerRGB = 8;
+
+        /* Set screen privates masks */
+        pScreenPriv->dwRedMask = WIN_24BPP_MASK_RED;
+        pScreenPriv->dwGreenMask = WIN_24BPP_MASK_GREEN;
+        pScreenPriv->dwBlueMask = WIN_24BPP_MASK_BLUE;
+
+        return TRUE;
     }
 
-  /* Allocate a bitmap header and color table */
-  pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)
-				      + 256  * sizeof (RGBQUAD));
-  if (pbmih == NULL)
-    {
-      ErrorF ("winQueryRGBBitsAndMasks - malloc failed\n");
-      return FALSE;
+    /* Allocate a bitmap header and color table */
+    pbmih = (BITMAPINFOHEADER *) malloc(sizeof(BITMAPINFOHEADER)
+                                        + 256 * sizeof(RGBQUAD));
+    if (pbmih == NULL) {
+        ErrorF("winQueryRGBBitsAndMasks - malloc failed\n");
+        return FALSE;
     }
 
-  /* Get screen description */
-  if (winQueryScreenDIBFormat (pScreen, pbmih))
-    {
-      /* Get a pointer to bitfields */
-      pdw = (DWORD*) ((CARD8*)pbmih + sizeof (BITMAPINFOHEADER));
-      
+    /* Get screen description */
+    if (winQueryScreenDIBFormat(pScreen, pbmih)) {
+        /* Get a pointer to bitfields */
+        pdw = (DWORD *) ((CARD8 *) pbmih + sizeof(BITMAPINFOHEADER));
+
 #ifdef WINDBG
-      winDebug ("%s - Masks: %08x %08x %08x\n", __FUNCTION__,
-	      pdw[0], pdw[1], pdw[2]);
-      winDebug ("%s - Bitmap: %dx%d %d bpp %d planes\n", __FUNCTION__,
-              pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount, pbmih->biPlanes);
-      winDebug ("%s - Compression: %d %s\n", __FUNCTION__,
-              pbmih->biCompression,
-              (pbmih->biCompression == BI_RGB?"(BI_RGB)":
-               (pbmih->biCompression == BI_RLE8?"(BI_RLE8)":
-                (pbmih->biCompression == BI_RLE4?"(BI_RLE4)":
-                 (pbmih->biCompression == BI_BITFIELDS?"(BI_BITFIELDS)":""
-                 )))));
+        winDebug("%s - Masks: %08x %08x %08x\n", __FUNCTION__,
+                 pdw[0], pdw[1], pdw[2]);
+        winDebug("%s - Bitmap: %dx%d %d bpp %d planes\n", __FUNCTION__,
+                 pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount,
+                 pbmih->biPlanes);
+        winDebug("%s - Compression: %d %s\n", __FUNCTION__,
+                 pbmih->biCompression,
+                 (pbmih->biCompression ==
+                  BI_RGB ? "(BI_RGB)" : (pbmih->biCompression ==
+                                         BI_RLE8 ? "(BI_RLE8)" : (pbmih->
+                                                                  biCompression
+                                                                  ==
+                                                                  BI_RLE4 ?
+                                                                  "(BI_RLE4)"
+                                                                  : (pbmih->
+                                                                     biCompression
+                                                                     ==
+                                                                     BI_BITFIELDS
+                                                                     ?
+                                                                     "(BI_BITFIELDS)"
+                                                                     : "")))));
 #endif
 
-      /* Handle BI_RGB case, which is returned by Wine */
-      if (pbmih->biCompression == BI_RGB)
-        {
-	  dwRedBits = 5;
-	  dwGreenBits = 5;
-	  dwBlueBits = 5;
-	  
-	  pScreenPriv->dwBitsPerRGB = 5;
-	  
-	  /* Set screen privates masks */
-	  pScreenPriv->dwRedMask = 0x7c00;
-	  pScreenPriv->dwGreenMask = 0x03e0;
-	  pScreenPriv->dwBlueMask = 0x001f;
+        /* Handle BI_RGB case, which is returned by Wine */
+        if (pbmih->biCompression == BI_RGB) {
+            dwRedBits = 5;
+            dwGreenBits = 5;
+            dwBlueBits = 5;
+
+            pScreenPriv->dwBitsPerRGB = 5;
+
+            /* Set screen privates masks */
+            pScreenPriv->dwRedMask = 0x7c00;
+            pScreenPriv->dwGreenMask = 0x03e0;
+            pScreenPriv->dwBlueMask = 0x001f;
+        }
+        else {
+            /* Count the number of bits in each mask */
+            dwRedBits = winCountBits(pdw[0]);
+            dwGreenBits = winCountBits(pdw[1]);
+            dwBlueBits = winCountBits(pdw[2]);
+
+            /* Find maximum bits per red, green, blue */
+            if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)
+                pScreenPriv->dwBitsPerRGB = dwRedBits;
+            else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)
+                pScreenPriv->dwBitsPerRGB = dwGreenBits;
+            else
+                pScreenPriv->dwBitsPerRGB = dwBlueBits;
+
+            /* Set screen privates masks */
+            pScreenPriv->dwRedMask = pdw[0];
+            pScreenPriv->dwGreenMask = pdw[1];
+            pScreenPriv->dwBlueMask = pdw[2];
         }
-      else 
-        {
-          /* Count the number of bits in each mask */
-          dwRedBits = winCountBits (pdw[0]);
-          dwGreenBits = winCountBits (pdw[1]);
-          dwBlueBits = winCountBits (pdw[2]);
-
-	  /* Find maximum bits per red, green, blue */
-	  if (dwRedBits > dwGreenBits && dwRedBits > dwBlueBits)
-	    pScreenPriv->dwBitsPerRGB = dwRedBits;
-	  else if (dwGreenBits > dwRedBits && dwGreenBits > dwBlueBits)
-	    pScreenPriv->dwBitsPerRGB = dwGreenBits;
-	  else
-	    pScreenPriv->dwBitsPerRGB = dwBlueBits;
-
-	  /* Set screen privates masks */
-	  pScreenPriv->dwRedMask = pdw[0];
-	  pScreenPriv->dwGreenMask = pdw[1];
-	  pScreenPriv->dwBlueMask = pdw[2];
-	}
     }
-  else
-    {
-      ErrorF ("winQueryRGBBitsAndMasks - winQueryScreenDIBFormat failed\n");
-      fReturn = FALSE;
+    else {
+        ErrorF("winQueryRGBBitsAndMasks - winQueryScreenDIBFormat failed\n");
+        fReturn = FALSE;
     }
 
-  /* Free memory */
-  free (pbmih);
+    /* Free memory */
+    free(pbmih);
 
-  return fReturn;
+    return fReturn;
 }
 
-
 #ifdef XWIN_MULTIWINDOW
 /*
  * Redraw all ---?
  */
 
 static wBOOL CALLBACK
-winRedrawAllProcShadowGDI (HWND hwnd, LPARAM lParam)
+winRedrawAllProcShadowGDI(HWND hwnd, LPARAM lParam)
 {
-  if (hwnd == (HWND)lParam)
-    return TRUE;  
-  InvalidateRect (hwnd, NULL, FALSE);
-  UpdateWindow (hwnd);
-  return TRUE;
+    if (hwnd == (HWND) lParam)
+        return TRUE;
+    InvalidateRect(hwnd, NULL, FALSE);
+    UpdateWindow(hwnd);
+    return TRUE;
 }
 
 static wBOOL CALLBACK
-winRedrawDamagedWindowShadowGDI (HWND hwnd, LPARAM lParam)
+winRedrawDamagedWindowShadowGDI(HWND hwnd, LPARAM lParam)
 {
-  BoxPtr pDamage = (BoxPtr)lParam;
-  RECT rcClient, rcDamage, rcRedraw;
-  POINT topLeft, bottomRight;
-  
-  if (IsIconic (hwnd))
-    return TRUE; /* Don't care minimized windows */
-  
-  /* Convert the damaged area from Screen coords to Client coords */
-  topLeft.x = pDamage->x1; topLeft.y = pDamage->y1;
-  bottomRight.x = pDamage->x2; bottomRight.y = pDamage->y2;
-  topLeft.x += GetSystemMetrics (SM_XVIRTUALSCREEN);
-  bottomRight.x += GetSystemMetrics (SM_XVIRTUALSCREEN);
-  topLeft.y += GetSystemMetrics (SM_YVIRTUALSCREEN);
-  bottomRight.y += GetSystemMetrics (SM_YVIRTUALSCREEN);
-  ScreenToClient (hwnd, &topLeft);
-  ScreenToClient (hwnd, &bottomRight);
-  SetRect (&rcDamage, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
-
-  GetClientRect (hwnd, &rcClient);
-
-  if (IntersectRect (&rcRedraw, &rcClient, &rcDamage))
-    {
-      InvalidateRect (hwnd, &rcRedraw, FALSE);
-      UpdateWindow (hwnd);
+    BoxPtr pDamage = (BoxPtr) lParam;
+    RECT rcClient, rcDamage, rcRedraw;
+    POINT topLeft, bottomRight;
+
+    if (IsIconic(hwnd))
+        return TRUE;            /* Don't care minimized windows */
+
+    /* Convert the damaged area from Screen coords to Client coords */
+    topLeft.x = pDamage->x1;
+    topLeft.y = pDamage->y1;
+    bottomRight.x = pDamage->x2;
+    bottomRight.y = pDamage->y2;
+    topLeft.x += GetSystemMetrics(SM_XVIRTUALSCREEN);
+    bottomRight.x += GetSystemMetrics(SM_XVIRTUALSCREEN);
+    topLeft.y += GetSystemMetrics(SM_YVIRTUALSCREEN);
+    bottomRight.y += GetSystemMetrics(SM_YVIRTUALSCREEN);
+    ScreenToClient(hwnd, &topLeft);
+    ScreenToClient(hwnd, &bottomRight);
+    SetRect(&rcDamage, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
+
+    GetClientRect(hwnd, &rcClient);
+
+    if (IntersectRect(&rcRedraw, &rcClient, &rcDamage)) {
+        InvalidateRect(hwnd, &rcRedraw, FALSE);
+        UpdateWindow(hwnd);
     }
-  return TRUE;
+    return TRUE;
 }
 #endif
 
-
 /*
  * Allocate a DIB for the shadow framebuffer GDI server
  */
 
 static Bool
-winAllocateFBShadowGDI (ScreenPtr pScreen)
+winAllocateFBShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  DIBSECTION		dibsection;
-  Bool			fReturn = TRUE;
-
-  /* Describe shadow bitmap to be created */
-  pScreenPriv->pbmih->biWidth = pScreenInfo->dwWidth;
-  pScreenPriv->pbmih->biHeight = -pScreenInfo->dwHeight;
-
-  winDebug ("winAllocateFBShadowGDI - Creating DIB with width: %d height: %d "
-	  "depth: %d\n",
-	  (int) pScreenPriv->pbmih->biWidth, (int) -pScreenPriv->pbmih->biHeight, pScreenPriv->pbmih->biBitCount);
-
-  /* Create a DI shadow bitmap with a bit pointer */
-  pScreenPriv->hbmpShadow = CreateDIBSection (pScreenPriv->hdcScreen,
-					      (BITMAPINFO *) pScreenPriv->pbmih,
-					      DIB_RGB_COLORS,
-					      (VOID**) &pScreenInfo->pfb,
-					      NULL,
-					      0);
-  if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL)
-    {
-      winW32Error ("winAllocateFBShadowGDI - CreateDIBSection failed:");
-      return FALSE;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    DIBSECTION dibsection;
+    Bool fReturn = TRUE;
+
+    /* Describe shadow bitmap to be created */
+    pScreenPriv->pbmih->biWidth = pScreenInfo->dwWidth;
+    pScreenPriv->pbmih->biHeight = -pScreenInfo->dwHeight;
+
+    winDebug ("winAllocateFBShadowGDI - Creating DIB with width: %d height: %d "
+              "depth: %d\n",
+              (int) pScreenPriv->pbmih->biWidth,
+              (int) -pScreenPriv->pbmih->biHeight, pScreenPriv->pbmih->biBitCount);
+
+    /* Create a DI shadow bitmap with a bit pointer */
+    pScreenPriv->hbmpShadow = CreateDIBSection(pScreenPriv->hdcScreen,
+                                               (BITMAPINFO *) pScreenPriv->
+                                               pbmih, DIB_RGB_COLORS,
+                                               (VOID **) & pScreenInfo->pfb,
+                                               NULL, 0);
+    if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL) {
+        winW32Error ("winAllocateFBShadowGDI - CreateDIBSection failed:");
+        return FALSE;
     }
-  else
-    {
-      winDebug ("winAllocateFBShadowGDI - Shadow buffer allocated\n");
+    else {
+        winDebug("winAllocateFBShadowGDI - Shadow buffer allocated\n");
     }
 
-  /* Get information about the bitmap that was allocated */
-  GetObject (pScreenPriv->hbmpShadow,
-	     sizeof (dibsection),
-	     &dibsection);
-
-  /* Print information about bitmap allocated */
-  winDebug ("winAllocateFBShadowGDI - Dibsection width: %d height: %d "
-	  "depth: %d size image: %d\n",
-	  (int) dibsection.dsBmih.biWidth, (int) dibsection.dsBmih.biHeight,
-	  dibsection.dsBmih.biBitCount,
-	  (int) dibsection.dsBmih.biSizeImage);
-
-  /* Select the shadow bitmap into the shadow DC */
-  SelectObject (pScreenPriv->hdcShadow,
-		pScreenPriv->hbmpShadow);
-
-  winDebug ("winAllocateFBShadowGDI - Attempting a shadow blit\n");
-
-  /* Do a test blit from the shadow to the screen, I think */
-  fReturn = BitBlt (pScreenPriv->hdcScreen,
-		    0, 0,
-		    pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-		    pScreenPriv->hdcShadow,
-		    0, 0,
-		    SRCCOPY);
-  if (fReturn)
-    {
-      winDebug ("winAllocateFBShadowGDI - Shadow blit success\n");
+    /* Get information about the bitmap that was allocated */
+    GetObject(pScreenPriv->hbmpShadow, sizeof(dibsection), &dibsection);
+
+    /* Print information about bitmap allocated */
+    winDebug("winAllocateFBShadowGDI - Dibsection width: %d height: %d "
+             "depth: %d size image: %d\n",
+             (int) dibsection.dsBmih.biWidth, (int) dibsection.dsBmih.biHeight,
+             dibsection.dsBmih.biBitCount, (int) dibsection.dsBmih.biSizeImage);
+
+    /* Select the shadow bitmap into the shadow DC */
+    SelectObject(pScreenPriv->hdcShadow, pScreenPriv->hbmpShadow);
+
+    winDebug("winAllocateFBShadowGDI - Attempting a shadow blit\n");
+
+    /* Do a test blit from the shadow to the screen, I think */
+    fReturn = BitBlt(pScreenPriv->hdcScreen,
+                     0, 0,
+                     pScreenInfo->dwWidth, pScreenInfo->dwHeight,
+                     pScreenPriv->hdcShadow, 0, 0, SRCCOPY);
+    if (fReturn) {
+        winDebug("winAllocateFBShadowGDI - Shadow blit success\n");
     }
-  else
-    {
-      winW32Error ("winAllocateFBShadowGDI - Shadow blit failure\n");
-      /* ago: ignore this error. The blit fails with wine, but does not 
-       * cause any problems later. */
+    else {
+        winW32Error ("winAllocateFBShadowGDI - Shadow blit failure\n");
+        /* ago: ignore this error. The blit fails with wine, but does not 
+         * cause any problems later. */
 
-      fReturn = TRUE;
+        fReturn = TRUE;
     }
 
-  /* Look for height weirdness */
-  if (dibsection.dsBmih.biHeight < 0)
-    {
-      dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;
+    /* Look for height weirdness */
+    if (dibsection.dsBmih.biHeight < 0) {
+        dibsection.dsBmih.biHeight = -dibsection.dsBmih.biHeight;
     }
 
-  /* Set screeninfo stride */
-  pScreenInfo->dwStride = ((dibsection.dsBmih.biSizeImage
-			    / dibsection.dsBmih.biHeight)
-			   * 8) / pScreenInfo->dwBPP;
+    /* Set screeninfo stride */
+    pScreenInfo->dwStride = ((dibsection.dsBmih.biSizeImage
+                              / dibsection.dsBmih.biHeight)
+                             * 8) / pScreenInfo->dwBPP;
 
-  winDebug ("winAllocateFBShadowGDI - Created shadow stride: %d\n",
-	  (int) pScreenInfo->dwStride);
+    winDebug("winAllocateFBShadowGDI - Created shadow stride: %d\n",
+             (int) pScreenInfo->dwStride);
 
 #ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
+    /* Redraw all windows */
+    if (pScreenInfo->fMultiWindow)
+        EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
 #endif
 
-  return fReturn;
+    return fReturn;
 }
 
 static void
-winFreeFBShadowGDI (ScreenPtr pScreen)
+winFreeFBShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
 
-  /* Free the shadow bitmap */
-  DeleteObject (pScreenPriv->hbmpShadow);
+    /* Free the shadow bitmap */
+    DeleteObject(pScreenPriv->hbmpShadow);
 
-  /* Invalidate the ScreenInfo's fb pointer */
-  pScreenInfo->pfb = NULL;
+    /* Invalidate the ScreenInfo's fb pointer */
+    pScreenInfo->pfb = NULL;
 }
 
 /*
@@ -444,160 +416,146 @@ winFreeFBShadowGDI (ScreenPtr pScreen)
  */
 
 static void
-winShadowUpdateGDI (ScreenPtr pScreen, 
-		    shadowBufPtr pBuf)
+winShadowUpdateGDI(ScreenPtr pScreen, shadowBufPtr pBuf)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  RegionPtr		damage = shadowDamage(pBuf);
-  DWORD			dwBox = RegionNumRects (damage);
-  BoxPtr		pBox = RegionRects (damage);
-  int			x, y, w, h;
-  HRGN			hrgnTemp = NULL, hrgnCombined = NULL;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    RegionPtr damage = shadowDamage(pBuf);
+    DWORD dwBox = RegionNumRects(damage);
+    BoxPtr pBox = RegionRects(damage);
+    int x, y, w, h;
+    HRGN hrgnTemp = NULL, hrgnCombined = NULL;
+
 #ifdef XWIN_UPDATESTATS
-  static DWORD		s_dwNonUnitRegions = 0;
-  static DWORD		s_dwTotalUpdates = 0;
-  static DWORD		s_dwTotalBoxes = 0;
+    static DWORD s_dwNonUnitRegions = 0;
+    static DWORD s_dwTotalUpdates = 0;
+    static DWORD s_dwTotalBoxes = 0;
 #endif
-  BoxPtr		pBoxExtents = RegionExtents(damage);
+    BoxPtr pBoxExtents = RegionExtents(damage);
 
-  /*
-   * Return immediately if the app is not active
-   * and we are fullscreen, or if we have a bad display depth
-   */
-  if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)
-      || pScreenPriv->fBadDepth) return;
+    /*
+     * Return immediately if the app is not active
+     * and we are fullscreen, or if we have a bad display depth
+     */
+    if ((!pScreenPriv->fActive && pScreenInfo->fFullScreen)
+        || pScreenPriv->fBadDepth)
+        return;
 
 #ifdef XWIN_UPDATESTATS
-  ++s_dwTotalUpdates;
-  s_dwTotalBoxes += dwBox;
+    ++s_dwTotalUpdates;
+    s_dwTotalBoxes += dwBox;
 
-  if (dwBox != 1)
-    {
-      ++s_dwNonUnitRegions;
-      winDebug ("winShadowUpdatGDI - dwBox: %d\n", dwBox);
+    if (dwBox != 1) {
+        ++s_dwNonUnitRegions;
+        winDebug ("winShadowUpdatGDI - dwBox: %d\n", dwBox);
     }
-  
-  if ((s_dwTotalUpdates % 100) == 0)
-  {
-    winDebug ("winShadowUpdateGDI - %d%% non-unity regions, avg boxes: %d "
-	    "nu: %d tu: %d\n",
-	    (s_dwNonUnitRegions * 100) / s_dwTotalUpdates,
-	    s_dwTotalBoxes / s_dwTotalUpdates,
-	    s_dwNonUnitRegions, s_dwTotalUpdates);
+
+    if ((s_dwTotalUpdates % 100) == 0)
+        winDebug ("winShadowUpdateGDI - %d%% non-unity regions, avg boxes: %d "
+                  "nu: %d tu: %d\n",
+                  (s_dwNonUnitRegions * 100) / s_dwTotalUpdates,
+                  s_dwTotalBoxes / s_dwTotalUpdates,
+                  s_dwNonUnitRegions, s_dwTotalUpdates);
   }
-#endif /* XWIN_UPDATESTATS */
-
-  /*
-   * Handle small regions with multiple blits,
-   * handle large regions by creating a clipping region and 
-   * doing a single blit constrained to that clipping region.
-   */
-  if (!pScreenInfo->fMultiWindow &&
-      (pScreenInfo->dwClipUpdatesNBoxes == 0 ||
-      dwBox < pScreenInfo->dwClipUpdatesNBoxes))
-    {
-      /* Loop through all boxes in the damaged region */
-      while (dwBox--)
-	{
-	  /*
-	   * Calculate x offset, y offset, width, and height for
-	   * current damage box
-	   */
-	  x = pBox->x1;
-	  y = pBox->y1;
-	  w = pBox->x2 - pBox->x1;
-	  h = pBox->y2 - pBox->y1;
-	  
-	  BitBlt (pScreenPriv->hdcScreen,
-		  x, y,
-		  w, h,
-		  pScreenPriv->hdcShadow,
-		  x, y,
-		  SRCCOPY);
-	  
-	  /* Get a pointer to the next box */
-	  ++pBox;
-	}
+#endif                          /* XWIN_UPDATESTATS */
+
+    /*
+     * Handle small regions with multiple blits,
+     * handle large regions by creating a clipping region and 
+     * doing a single blit constrained to that clipping region.
+     */
+    if (!pScreenInfo->fMultiWindow &&
+        (pScreenInfo->dwClipUpdatesNBoxes == 0 ||
+         dwBox < pScreenInfo->dwClipUpdatesNBoxes)) {
+        /* Loop through all boxes in the damaged region */
+        while (dwBox--) {
+            /*
+             * Calculate x offset, y offset, width, and height for
+             * current damage box
+             */
+            x = pBox->x1;
+            y = pBox->y1;
+            w = pBox->x2 - pBox->x1;
+            h = pBox->y2 - pBox->y1;
+
+            BitBlt(pScreenPriv->hdcScreen,
+                   x, y, w, h, pScreenPriv->hdcShadow, x, y, SRCCOPY);
+
+            /* Get a pointer to the next box */
+            ++pBox;
+        }
     }
-  else if (!pScreenInfo->fMultiWindow)
-    {
-      /* Compute a GDI region from the damaged region */
-      hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-      dwBox--;
-      pBox++;
-      while (dwBox--)
-	{
-	  hrgnTemp = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
-	  CombineRgn (hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);
-	  DeleteObject (hrgnTemp);
-	  pBox++;
-	}
-      
-      /* Install the GDI region as a clipping region */
-      SelectClipRgn (pScreenPriv->hdcScreen, hrgnCombined);
-      DeleteObject (hrgnCombined);
-      hrgnCombined = NULL;
-      
-      /*
-       * Blit the shadow buffer to the screen,
-       * constrained to the clipping region.
-       */
-      BitBlt (pScreenPriv->hdcScreen,
-	      pBoxExtents->x1, pBoxExtents->y1,
-	      pBoxExtents->x2 - pBoxExtents->x1,
-	      pBoxExtents->y2 - pBoxExtents->y1,
-	      pScreenPriv->hdcShadow,
-	      pBoxExtents->x1, pBoxExtents->y1,
-	      SRCCOPY);
-
-      /* Reset the clip region */
-      SelectClipRgn (pScreenPriv->hdcScreen, NULL);
+    else if (!pScreenInfo->fMultiWindow) {
+        /* Compute a GDI region from the damaged region */
+        hrgnCombined = CreateRectRgn(pBox->x1, pBox->y1, pBox->x2, pBox->y2);
+        dwBox--;
+        pBox++;
+        while (dwBox--) {
+            hrgnTemp = CreateRectRgn(pBox->x1, pBox->y1, pBox->x2, pBox->y2);
+            CombineRgn(hrgnCombined, hrgnCombined, hrgnTemp, RGN_OR);
+            DeleteObject(hrgnTemp);
+            pBox++;
+        }
+
+        /* Install the GDI region as a clipping region */
+        SelectClipRgn(pScreenPriv->hdcScreen, hrgnCombined);
+        DeleteObject(hrgnCombined);
+        hrgnCombined = NULL;
+
+        /*
+         * Blit the shadow buffer to the screen,
+         * constrained to the clipping region.
+         */
+        BitBlt(pScreenPriv->hdcScreen,
+               pBoxExtents->x1, pBoxExtents->y1,
+               pBoxExtents->x2 - pBoxExtents->x1,
+               pBoxExtents->y2 - pBoxExtents->y1,
+               pScreenPriv->hdcShadow,
+               pBoxExtents->x1, pBoxExtents->y1, SRCCOPY);
+
+        /* Reset the clip region */
+        SelectClipRgn(pScreenPriv->hdcScreen, NULL);
     }
 
 #ifdef XWIN_MULTIWINDOW
-  /* Redraw all multiwindow windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID,
-		       winRedrawDamagedWindowShadowGDI,
-		       (LPARAM)pBoxExtents);
+    /* Redraw all multiwindow windows */
+    if (pScreenInfo->fMultiWindow)
+        EnumThreadWindows(g_dwCurrentThreadID,
+                          winRedrawDamagedWindowShadowGDI,
+                          (LPARAM) pBoxExtents);
 #endif
 }
 
-
 static Bool
-winInitScreenShadowGDI (ScreenPtr pScreen)
+winInitScreenShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-
-  /* Get device contexts for the screen and shadow bitmap */
-  pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
-  pScreenPriv->hdcShadow = CreateCompatibleDC (pScreenPriv->hdcScreen);
-
-  /* Allocate bitmap info header */
-  pScreenPriv->pbmih = (BITMAPINFOHEADER*) malloc (sizeof (BITMAPINFOHEADER)
-                                                   + 256 * sizeof (RGBQUAD));
-  if (pScreenPriv->pbmih == NULL)
-    {
-      ErrorF ("winInitScreenShadowGDI - malloc () failed\n");
-      return FALSE;
+    winScreenPriv(pScreen);
+
+    /* Get device contexts for the screen and shadow bitmap */
+    pScreenPriv->hdcScreen = GetDC(pScreenPriv->hwndScreen);
+    pScreenPriv->hdcShadow = CreateCompatibleDC(pScreenPriv->hdcScreen);
+
+    /* Allocate bitmap info header */
+    pScreenPriv->pbmih = (BITMAPINFOHEADER *) malloc(sizeof(BITMAPINFOHEADER)
+                                                     + 256 * sizeof(RGBQUAD));
+    if (pScreenPriv->pbmih == NULL) {
+        ErrorF("winInitScreenShadowGDI - malloc () failed\n");
+        return FALSE;
     }
 
-  /* Query the screen format */
-  if (!winQueryScreenDIBFormat (pScreen, pScreenPriv->pbmih))
-    {
-      ErrorF ("winInitScreenShadowGDI - winQueryScreenDIBFormat failed\n");
-      return FALSE;
+    /* Query the screen format */
+    if (!winQueryScreenDIBFormat(pScreen, pScreenPriv->pbmih)) {
+        ErrorF("winInitScreenShadowGDI - winQueryScreenDIBFormat failed\n");
+        return FALSE;
     }
 
-  /* Determine our color masks */
-  if (!winQueryRGBBitsAndMasks (pScreen))
-    {
-      ErrorF ("winInitScreenShadowGDI - winQueryRGBBitsAndMasks failed\n");
-      return FALSE;
+    /* Determine our color masks */
+    if (!winQueryRGBBitsAndMasks(pScreen)) {
+        ErrorF("winInitScreenShadowGDI - winQueryRGBBitsAndMasks failed\n");
+        return FALSE;
     }
 
-  return winAllocateFBShadowGDI(pScreen);
+    return winAllocateFBShadowGDI(pScreen);
 }
 
 /* See Porting Layer Definition - p. 33 */
@@ -607,67 +565,64 @@ winInitScreenShadowGDI (ScreenPtr pScreen)
  */
 
 static Bool
-winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen)
+winCloseScreenShadowGDI(int nIndex, ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  Bool			fReturn;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    Bool fReturn;
 
-  winDebug ("winCloseScreenShadowGDI - Freeing screen resources\n");
+    winDebug("winCloseScreenShadowGDI - Freeing screen resources\n");
 
-  /* Flag that the screen is closed */
-  pScreenPriv->fClosed = TRUE;
-  pScreenPriv->fActive = FALSE;
+    /* Flag that the screen is closed */
+    pScreenPriv->fClosed = TRUE;
+    pScreenPriv->fActive = FALSE;
 
-  /* Call the wrapped CloseScreen procedure */
-  WIN_UNWRAP(CloseScreen);
-  if (pScreen->CloseScreen)
-    fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
+    /* Call the wrapped CloseScreen procedure */
+    WIN_UNWRAP(CloseScreen);
+    if (pScreen->CloseScreen)
+        fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
 
-  /* Delete the window property */
-  RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
+    /* Delete the window property */
+    RemoveProp(pScreenPriv->hwndScreen, WIN_SCR_PROP);
 
-  /* Free the shadow DC; which allows the bitmap to be freed */
-  DeleteDC (pScreenPriv->hdcShadow);
+    /* Free the shadow DC; which allows the bitmap to be freed */
+    DeleteDC(pScreenPriv->hdcShadow);
 
-  winFreeFBShadowGDI(pScreen);
+    winFreeFBShadowGDI(pScreen);
 
-  /* Free the screen DC */
-  ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
+    /* Free the screen DC */
+    ReleaseDC(pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
 
-  /* Delete tray icon, if we have one */
-  if (!pScreenInfo->fNoTrayIcon)
-    winDeleteNotifyIcon (pScreenPriv);
+    /* Delete tray icon, if we have one */
+    if (!pScreenInfo->fNoTrayIcon)
+        winDeleteNotifyIcon(pScreenPriv);
 
-  /* Free the exit confirmation dialog box, if it exists */
-  if (g_hDlgExit != NULL)
-    {
-      DestroyWindow (g_hDlgExit);
-      g_hDlgExit = NULL;
+    /* Free the exit confirmation dialog box, if it exists */
+    if (g_hDlgExit != NULL) {
+        DestroyWindow(g_hDlgExit);
+        g_hDlgExit = NULL;
     }
 
-  /* Kill our window */
-  if (pScreenPriv->hwndScreen)
-    {
-      DestroyWindow (pScreenPriv->hwndScreen);
-      pScreenPriv->hwndScreen = NULL;
+    /* Kill our window */
+    if (pScreenPriv->hwndScreen) {
+        DestroyWindow(pScreenPriv->hwndScreen);
+        pScreenPriv->hwndScreen = NULL;
     }
 
 #if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
-  /* Destroy the thread startup mutex */
-  if (pScreenPriv->pmServerStarted) pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
+    /* Destroy the thread startup mutex */
+    if (pScreenPriv->pmServerStarted) pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
 #endif
 
-  /* Invalidate our screeninfo's pointer to the screen */
-  pScreenInfo->pScreen = NULL;
+    /* Invalidate our screeninfo's pointer to the screen */
+    pScreenInfo->pScreen = NULL;
 
-  /* Free the screen privates for this screen */
-  free ((pointer) pScreenPriv);
+    /* Free the screen privates for this screen */
+    free((pointer) pScreenPriv);
 
-  return fReturn;
+    return fReturn;
 }
 
-
 /*
  * Tell mi what sort of visuals we need.
  * 
@@ -677,561 +632,510 @@ winCloseScreenShadowGDI (int nIndex, ScreenPtr pScreen)
  */
 
 static Bool
-winInitVisualsShadowGDI (ScreenPtr pScreen)
+winInitVisualsShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-
-  /* Display debugging information */
-  winDebug ("winInitVisualsShadowGDI - Masks %08x %08x %08x BPRGB %d d %d "
-	  "bpp %d\n",
-	  (unsigned int) pScreenPriv->dwRedMask,
-	  (unsigned int) pScreenPriv->dwGreenMask,
-	  (unsigned int) pScreenPriv->dwBlueMask,
-	  (int) pScreenPriv->dwBitsPerRGB,
-	  (int) pScreenInfo->dwDepth,
-	  (int) pScreenInfo->dwBPP);
-
-  /* Create a single visual according to the Windows screen depth */
-  switch (pScreenInfo->dwDepth)
-    {
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+
+    /* Display debugging information */
+    winDebug ("winInitVisualsShadowGDI - Masks %08x %08x %08x BPRGB %d d %d "
+              "bpp %d\n",
+              (unsigned int) pScreenPriv->dwRedMask,
+              (unsigned int) pScreenPriv->dwGreenMask,
+              (unsigned int) pScreenPriv->dwBlueMask,
+              (int) pScreenPriv->dwBitsPerRGB,
+              (int) pScreenInfo->dwDepth, (int) pScreenInfo->dwBPP);
+
+    /* Create a single visual according to the Windows screen depth */
+    switch (pScreenInfo->dwDepth) {
     case 24:
     case 16:
     case 15:
-      /* Setup the real visual */
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     TrueColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     -1,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
+        /* Setup the real visual */
+        if (!miSetVisualTypesAndMasks(pScreenInfo->dwDepth,
+                                      TrueColorMask,
+                                      pScreenPriv->dwBitsPerRGB,
+                                      -1,
+                                      pScreenPriv->dwRedMask,
+                                      pScreenPriv->dwGreenMask,
+                                      pScreenPriv->dwBlueMask)) {
+            ErrorF("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
+                   "failed\n");
+            return FALSE;
+        }
 
 #ifdef XWIN_EMULATEPSEUDO
-      if (!pScreenInfo->fEmulatePseudo)
-	break;
-
-      /* Setup a pseudocolor visual */
-      if (!miSetVisualTypesAndMasks (8,
-				     PseudoColorMask,
-				     8,
-				     -1,
-				     0,
-				     0,
-				     0))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed for PseudoColor\n");
-	  return FALSE;
-	}
+        if (!pScreenInfo->fEmulatePseudo)
+            break;
+
+        /* Setup a pseudocolor visual */
+        if (!miSetVisualTypesAndMasks(8, PseudoColorMask, 8, -1, 0, 0, 0)) {
+            ErrorF("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
+                   "failed for PseudoColor\n");
+            return FALSE;
+        }
 #endif
-      break;
+        break;
 
     case 8:
-      if (!miSetVisualTypesAndMasks (pScreenInfo->dwDepth,
-				     PseudoColorMask,
-				     pScreenPriv->dwBitsPerRGB,
-				     PseudoColor,
-				     pScreenPriv->dwRedMask,
-				     pScreenPriv->dwGreenMask,
-				     pScreenPriv->dwBlueMask))
-	{
-	  ErrorF ("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
-		  "failed\n");
-	  return FALSE;
-	}
-      break;
+        if (!miSetVisualTypesAndMasks(pScreenInfo->dwDepth,
+                                      PseudoColorMask,
+                                      pScreenPriv->dwBitsPerRGB,
+                                      PseudoColor,
+                                      pScreenPriv->dwRedMask,
+                                      pScreenPriv->dwGreenMask,
+                                      pScreenPriv->dwBlueMask)) {
+            ErrorF("winInitVisualsShadowGDI - miSetVisualTypesAndMasks "
+                   "failed\n");
+            return FALSE;
+        }
+        break;
 
     default:
-      ErrorF ("winInitVisualsShadowGDI - Unknown screen depth\n");
-      return FALSE;
+        ErrorF("winInitVisualsShadowGDI - Unknown screen depth\n");
+        return FALSE;
     }
 
-  winDebug ("winInitVisualsShadowGDI - Returning\n");
+    winDebug("winInitVisualsShadowGDI - Returning\n");
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Adjust the proposed video mode
  */
 
 static Bool
-winAdjustVideoModeShadowGDI (ScreenPtr pScreen)
+winAdjustVideoModeShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  HDC			hdc;
-  DWORD			dwBPP;
-  
-  hdc = GetDC (NULL);
-
-  /* We're in serious trouble if we can't get a DC */
-  if (hdc == NULL)
-    {
-      ErrorF ("winAdjustVideoModeShadowGDI - GetDC () failed\n");
-      return FALSE;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    HDC hdc;
+    DWORD dwBPP;
+
+    hdc = GetDC(NULL);
+
+    /* We're in serious trouble if we can't get a DC */
+    if (hdc == NULL) {
+        ErrorF("winAdjustVideoModeShadowGDI - GetDC () failed\n");
+        return FALSE;
     }
 
-  /* Query GDI for current display depth */
-  dwBPP = GetDeviceCaps (hdc, BITSPIXEL);
+    /* Query GDI for current display depth */
+    dwBPP = GetDeviceCaps(hdc, BITSPIXEL);
 
-  /* GDI cannot change the screen depth, so always use GDI's depth */
-  pScreenInfo->dwBPP = dwBPP;
+    /* GDI cannot change the screen depth, so always use GDI's depth */
+    pScreenInfo->dwBPP = dwBPP;
 
-  /* Release our DC */
-  ReleaseDC (NULL, hdc);
-  hdc = NULL;
+    /* Release our DC */
+    ReleaseDC(NULL, hdc);
+    hdc = NULL;
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Blt exposed regions to the screen
  */
 
 static Bool
-winBltExposedRegionsShadowGDI (ScreenPtr pScreen)
+winBltExposedRegionsShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  winPrivCmapPtr	pCmapPriv = NULL;
-  HDC			hdcUpdate;
-  PAINTSTRUCT		ps;
-
-  /* BeginPaint gives us an hdc that clips to the invalidated region */
-  hdcUpdate = BeginPaint (pScreenPriv->hwndScreen, &ps);
-
-  /* Realize the palette, if we have one */
-  if (pScreenPriv->pcmapInstalled != NULL)
-    {
-      pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);
-      
-      SelectPalette (hdcUpdate, pCmapPriv->hPalette, FALSE);
-      RealizePalette (hdcUpdate);
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+    winPrivCmapPtr pCmapPriv = NULL;
+    HDC hdcUpdate;
+    PAINTSTRUCT ps;
+
+    /* BeginPaint gives us an hdc that clips to the invalidated region */
+    hdcUpdate = BeginPaint(pScreenPriv->hwndScreen, &ps);
+
+    /* Realize the palette, if we have one */
+    if (pScreenPriv->pcmapInstalled != NULL) {
+        pCmapPriv = winGetCmapPriv(pScreenPriv->pcmapInstalled);
+
+        SelectPalette(hdcUpdate, pCmapPriv->hPalette, FALSE);
+        RealizePalette(hdcUpdate);
     }
 
-  /* Our BitBlt will be clipped to the invalidated region */
-  BitBlt (hdcUpdate,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
+    /* Our BitBlt will be clipped to the invalidated region */
+    BitBlt(hdcUpdate,
+           0, 0,
+           pScreenInfo->dwWidth, pScreenInfo->dwHeight,
+           pScreenPriv->hdcShadow, 0, 0, SRCCOPY);
 
-  /* EndPaint frees the DC */
-  EndPaint (pScreenPriv->hwndScreen, &ps);
+    /* EndPaint frees the DC */
+    EndPaint(pScreenPriv->hwndScreen, &ps);
 
 #ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 
-            (LPARAM)pScreenPriv->hwndScreen);
+    /* Redraw all windows */
+    if (pScreenInfo->fMultiWindow)
+        EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI,
+                          (LPARAM) pScreenPriv->hwndScreen);
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Do any engine-specific appliation-activation processing
  */
 
 static Bool
-winActivateAppShadowGDI (ScreenPtr pScreen)
+winActivateAppShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-
-  /*
-   * 2004/04/12 - Harold - We perform the restoring or minimizing
-   * manually for ShadowGDI in fullscreen modes so that this engine
-   * will perform just like ShadowDD and ShadowDDNL in fullscreen mode;
-   * if we do not do this then our fullscreen window will appear in the
-   * z-order when it is deactivated and it can be uncovered by resizing
-   * or minimizing another window that is on top of it, which is not how
-   * the DirectDraw engines work.  Therefore we keep this code here to
-   * make sure that all engines work the same in fullscreen mode.
-   */
-
-  /*
-   * Are we active?
-   * Are we fullscreen?
-   */
-  if (pScreenPriv->fActive
-      && pScreenInfo->fFullScreen)
-    {
-      /*
-       * Activating, attempt to bring our window 
-       * to the top of the display
-       */
-      ShowWindow (pScreenPriv->hwndScreen, SW_RESTORE);
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+
+    /*
+     * 2004/04/12 - Harold - We perform the restoring or minimizing
+     * manually for ShadowGDI in fullscreen modes so that this engine
+     * will perform just like ShadowDD and ShadowDDNL in fullscreen mode;
+     * if we do not do this then our fullscreen window will appear in the
+     * z-order when it is deactivated and it can be uncovered by resizing
+     * or minimizing another window that is on top of it, which is not how
+     * the DirectDraw engines work.  Therefore we keep this code here to
+     * make sure that all engines work the same in fullscreen mode.
+     */
+
+    /*
+     * Are we active?
+     * Are we fullscreen?
+     */
+    if (pScreenPriv->fActive && pScreenInfo->fFullScreen) {
+        /*
+         * Activating, attempt to bring our window 
+         * to the top of the display
+         */
+        ShowWindow(pScreenPriv->hwndScreen, SW_RESTORE);
     }
-  else if (!pScreenPriv->fActive
-	   && pScreenInfo->fFullScreen)
-    {
-      /*
-       * Deactivating, stuff our window onto the
-       * task bar.
-       */
-      ShowWindow (pScreenPriv->hwndScreen, SW_MINIMIZE);
+    else if (!pScreenPriv->fActive && pScreenInfo->fFullScreen) {
+        /*
+         * Deactivating, stuff our window onto the
+         * task bar.
+         */
+        ShowWindow(pScreenPriv->hwndScreen, SW_MINIMIZE);
     }
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Reblit the shadow framebuffer to the screen.
  */
 
 static Bool
-winRedrawScreenShadowGDI (ScreenPtr pScreen)
+winRedrawScreenShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
 
-  /* Redraw the whole window, to take account for the new colors */
-  BitBlt (pScreenPriv->hdcScreen,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
+    /* Redraw the whole window, to take account for the new colors */
+    BitBlt(pScreenPriv->hdcScreen,
+           0, 0,
+           pScreenInfo->dwWidth, pScreenInfo->dwHeight,
+           pScreenPriv->hdcShadow, 0, 0, SRCCOPY);
 
 #ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
+    /* Redraw all windows */
+    if (pScreenInfo->fMultiWindow)
+        EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
-
-
 /*
  * Realize the currently installed colormap
  */
 
 static Bool
-winRealizeInstalledPaletteShadowGDI (ScreenPtr pScreen)
+winRealizeInstalledPaletteShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winPrivCmapPtr	pCmapPriv = NULL;
+    winScreenPriv(pScreen);
+    winPrivCmapPtr pCmapPriv = NULL;
 
-  winDebug ("winRealizeInstalledPaletteShadowGDI\n");
+    winDebug("winRealizeInstalledPaletteShadowGDI\n");
 
-  /* Don't do anything if there is not a colormap */
-  if (pScreenPriv->pcmapInstalled == NULL)
-    {
-      winDebug ("winRealizeInstalledPaletteShadowGDI - No colormap "
-	      "installed\n");
-      return TRUE;
+    /* Don't do anything if there is not a colormap */
+    if (pScreenPriv->pcmapInstalled == NULL) {
+        winDebug("winRealizeInstalledPaletteShadowGDI - No colormap "
+                 "installed\n");
+        return TRUE;
     }
 
-  pCmapPriv = winGetCmapPriv (pScreenPriv->pcmapInstalled);
-  
-  /* Realize our palette for the screen */
-  if (RealizePalette (pScreenPriv->hdcScreen) == GDI_ERROR)
-    {
-      ErrorF ("winRealizeInstalledPaletteShadowGDI - RealizePalette () "
-	      "failed\n");
-      return FALSE;
+    pCmapPriv = winGetCmapPriv(pScreenPriv->pcmapInstalled);
+
+    /* Realize our palette for the screen */
+    if (RealizePalette(pScreenPriv->hdcScreen) == GDI_ERROR) {
+        ErrorF("winRealizeInstalledPaletteShadowGDI - RealizePalette () "
+               "failed\n");
+        return FALSE;
     }
-  
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			0,
-			WIN_NUM_PALETTE_ENTRIES,
-			pCmapPriv->rgbColors) == 0)
-    {
-      ErrorF ("winRealizeInstalledPaletteShadowGDI - SetDIBColorTable () "
-	      "failed\n");
-      return FALSE;
+
+    /* Set the DIB color table */
+    if (SetDIBColorTable(pScreenPriv->hdcShadow,
+                         0,
+                         WIN_NUM_PALETTE_ENTRIES, pCmapPriv->rgbColors) == 0) {
+        ErrorF("winRealizeInstalledPaletteShadowGDI - SetDIBColorTable () "
+               "failed\n");
+        return FALSE;
     }
-  
-  return TRUE;
-}
 
+    return TRUE;
+}
 
 /*
  * Install the specified colormap
  */
 
 static Bool
-winInstallColormapShadowGDI (ColormapPtr pColormap)
+winInstallColormapShadowGDI(ColormapPtr pColormap)
 {
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  winCmapPriv(pColormap);
-
-  /*
-   * Tell Windows to install the new colormap
-   */
-  if (SelectPalette (pScreenPriv->hdcScreen,
-		     pCmapPriv->hPalette,
-		     FALSE) == NULL)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SelectPalette () failed\n");
-      return FALSE;
+    ScreenPtr pScreen = pColormap->pScreen;
+
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+
+    winCmapPriv(pColormap);
+
+    /*
+     * Tell Windows to install the new colormap
+     */
+    if (SelectPalette(pScreenPriv->hdcScreen,
+                      pCmapPriv->hPalette, FALSE) == NULL) {
+        ErrorF("winInstallColormapShadowGDI - SelectPalette () failed\n");
+        return FALSE;
     }
-      
-  /* Realize the palette */
-  if (GDI_ERROR == RealizePalette (pScreenPriv->hdcScreen))
-    {
-      ErrorF ("winInstallColormapShadowGDI - RealizePalette () failed\n");
-      return FALSE;
+
+    /* Realize the palette */
+    if (GDI_ERROR == RealizePalette(pScreenPriv->hdcScreen)) {
+        ErrorF("winInstallColormapShadowGDI - RealizePalette () failed\n");
+        return FALSE;
     }
 
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			0,
-			WIN_NUM_PALETTE_ENTRIES,
-			pCmapPriv->rgbColors) == 0)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
-      return FALSE;
+    /* Set the DIB color table */
+    if (SetDIBColorTable(pScreenPriv->hdcShadow,
+                         0,
+                         WIN_NUM_PALETTE_ENTRIES, pCmapPriv->rgbColors) == 0) {
+        ErrorF("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
+        return FALSE;
     }
 
-  /* Redraw the whole window, to take account for the new colors */
-  BitBlt (pScreenPriv->hdcScreen,
-	  0, 0,
-	  pScreenInfo->dwWidth, pScreenInfo->dwHeight,
-	  pScreenPriv->hdcShadow,
-	  0, 0,
-	  SRCCOPY);
+    /* Redraw the whole window, to take account for the new colors */
+    BitBlt(pScreenPriv->hdcScreen,
+           0, 0,
+           pScreenInfo->dwWidth, pScreenInfo->dwHeight,
+           pScreenPriv->hdcShadow, 0, 0, SRCCOPY);
 
-  /* Save a pointer to the newly installed colormap */
-  pScreenPriv->pcmapInstalled = pColormap;
+    /* Save a pointer to the newly installed colormap */
+    pScreenPriv->pcmapInstalled = pColormap;
 
 #ifdef XWIN_MULTIWINDOW
-  /* Redraw all windows */
-  if (pScreenInfo->fMultiWindow)
-    EnumThreadWindows (g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
+    /* Redraw all windows */
+    if (pScreenInfo->fMultiWindow)
+        EnumThreadWindows(g_dwCurrentThreadID, winRedrawAllProcShadowGDI, 0);
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Store the specified colors in the specified colormap
  */
 
 static Bool
-winStoreColorsShadowGDI (ColormapPtr pColormap,
-			 int ndef,
-			 xColorItem *pdefs)
+winStoreColorsShadowGDI(ColormapPtr pColormap, int ndef, xColorItem * pdefs)
 {
-  ScreenPtr		pScreen = pColormap->pScreen;
-  winScreenPriv(pScreen);
-  winCmapPriv(pColormap);
-  ColormapPtr curpmap = pScreenPriv->pcmapInstalled;
-  
-  /* Put the X colormap entries into the Windows logical palette */
-  if (SetPaletteEntries (pCmapPriv->hPalette,
-			 pdefs[0].pixel,
-			 ndef,
-			 pCmapPriv->peColors + pdefs[0].pixel) == 0)
-    {
-      ErrorF ("winStoreColorsShadowGDI - SetPaletteEntries () failed\n");
-      return FALSE;
+    ScreenPtr pScreen = pColormap->pScreen;
+
+    winScreenPriv(pScreen);
+    winCmapPriv(pColormap);
+    ColormapPtr curpmap = pScreenPriv->pcmapInstalled;
+
+    /* Put the X colormap entries into the Windows logical palette */
+    if (SetPaletteEntries(pCmapPriv->hPalette,
+                          pdefs[0].pixel,
+                          ndef, pCmapPriv->peColors + pdefs[0].pixel) == 0) {
+        ErrorF("winStoreColorsShadowGDI - SetPaletteEntries () failed\n");
+        return FALSE;
     }
 
-  /* Don't install the Windows palette if the colormap is not installed */
-  if (pColormap != curpmap)
-    {
-      return TRUE;
+    /* Don't install the Windows palette if the colormap is not installed */
+    if (pColormap != curpmap) {
+        return TRUE;
     }
 
-  /* Try to install the newly modified colormap */
-  if (!winInstallColormapShadowGDI (pColormap))
-    {
-      ErrorF ("winInstallColormapShadowGDI - winInstallColormapShadowGDI "
-	      "failed\n");
-      return FALSE;
+    /* Try to install the newly modified colormap */
+    if (!winInstallColormapShadowGDI(pColormap)) {
+        ErrorF("winInstallColormapShadowGDI - winInstallColormapShadowGDI "
+               "failed\n");
+        return FALSE;
     }
 
 #if 0
-  /* Tell Windows that the palette has changed */
-  RealizePalette (pScreenPriv->hdcScreen);
-  
-  /* Set the DIB color table */
-  if (SetDIBColorTable (pScreenPriv->hdcShadow,
-			pdefs[0].pixel,
-			ndef,
-			pCmapPriv->rgbColors + pdefs[0].pixel) == 0)
-    {
-      ErrorF ("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
-      return FALSE;
+    /* Tell Windows that the palette has changed */
+    RealizePalette(pScreenPriv->hdcScreen);
+
+    /* Set the DIB color table */
+    if (SetDIBColorTable(pScreenPriv->hdcShadow,
+                         pdefs[0].pixel,
+                         ndef, pCmapPriv->rgbColors + pdefs[0].pixel) == 0) {
+        ErrorF("winInstallColormapShadowGDI - SetDIBColorTable () failed\n");
+        return FALSE;
     }
 
-  /* Save a pointer to the newly installed colormap */
-  pScreenPriv->pcmapInstalled = pColormap;
+    /* Save a pointer to the newly installed colormap */
+    pScreenPriv->pcmapInstalled = pColormap;
 #endif
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Colormap initialization procedure
  */
 
 static Bool
-winCreateColormapShadowGDI (ColormapPtr pColormap)
+winCreateColormapShadowGDI(ColormapPtr pColormap)
 {
-  LPLOGPALETTE		lpPaletteNew = NULL;
-  DWORD			dwEntriesMax;
-  VisualPtr		pVisual;
-  HPALETTE		hpalNew = NULL;
-  winCmapPriv(pColormap);
-
-  /* Get a pointer to the visual that the colormap belongs to */
-  pVisual = pColormap->pVisual;
-
-  /* Get the maximum number of palette entries for this visual */
-  dwEntriesMax = pVisual->ColormapEntries;
-
-  /* Allocate a Windows logical color palette with max entries */
-  lpPaletteNew = malloc (sizeof (LOGPALETTE)
-			 + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));
-  if (lpPaletteNew == NULL)
-    {
-      ErrorF ("winCreateColormapShadowGDI - Couldn't allocate palette "
-	      "with %d entries\n",
-	      (int) dwEntriesMax);
-      return FALSE;
+    LPLOGPALETTE lpPaletteNew = NULL;
+    DWORD dwEntriesMax;
+    VisualPtr pVisual;
+    HPALETTE hpalNew = NULL;
+
+    winCmapPriv(pColormap);
+
+    /* Get a pointer to the visual that the colormap belongs to */
+    pVisual = pColormap->pVisual;
+
+    /* Get the maximum number of palette entries for this visual */
+    dwEntriesMax = pVisual->ColormapEntries;
+
+    /* Allocate a Windows logical color palette with max entries */
+    lpPaletteNew = malloc(sizeof(LOGPALETTE)
+                          + (dwEntriesMax - 1) * sizeof(PALETTEENTRY));
+    if (lpPaletteNew == NULL) {
+        ErrorF("winCreateColormapShadowGDI - Couldn't allocate palette "
+               "with %d entries\n", (int) dwEntriesMax);
+        return FALSE;
     }
 
-  /* Zero out the colormap */
-  ZeroMemory (lpPaletteNew, sizeof (LOGPALETTE)
-	      + (dwEntriesMax - 1) * sizeof (PALETTEENTRY));
-  
-  /* Set the logical palette structure */
-  lpPaletteNew->palVersion = 0x0300;
-  lpPaletteNew->palNumEntries = dwEntriesMax;
-
-  /* Tell Windows to create the palette */
-  hpalNew = CreatePalette (lpPaletteNew);
-  if (hpalNew == NULL)
-    {
-      ErrorF ("winCreateColormapShadowGDI - CreatePalette () failed\n");
-      free (lpPaletteNew);
-      return FALSE;
+    /* Zero out the colormap */
+    ZeroMemory(lpPaletteNew, sizeof(LOGPALETTE)
+               + (dwEntriesMax - 1) * sizeof(PALETTEENTRY));
+
+    /* Set the logical palette structure */
+    lpPaletteNew->palVersion = 0x0300;
+    lpPaletteNew->palNumEntries = dwEntriesMax;
+
+    /* Tell Windows to create the palette */
+    hpalNew = CreatePalette(lpPaletteNew);
+    if (hpalNew == NULL) {
+        ErrorF("winCreateColormapShadowGDI - CreatePalette () failed\n");
+        free(lpPaletteNew);
+        return FALSE;
     }
 
-  /* Save the Windows logical palette handle in the X colormaps' privates */
-  pCmapPriv->hPalette = hpalNew;
+    /* Save the Windows logical palette handle in the X colormaps' privates */
+    pCmapPriv->hPalette = hpalNew;
 
-  /* Free the palette initialization memory */
-  free (lpPaletteNew);
+    /* Free the palette initialization memory */
+    free(lpPaletteNew);
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /*
  * Colormap destruction procedure
  */
 
 static Bool
-winDestroyColormapShadowGDI (ColormapPtr pColormap)
+winDestroyColormapShadowGDI(ColormapPtr pColormap)
 {
-  winScreenPriv(pColormap->pScreen);
-  winCmapPriv(pColormap);
-
-  /*
-   * Is colormap to be destroyed the default?
-   *
-   * Non-default colormaps should have had winUninstallColormap
-   * called on them before we get here.  The default colormap
-   * will not have had winUninstallColormap called on it.  Thus,
-   * we need to handle the default colormap in a special way.
-   */
-  if (pColormap->flags & IsDefault)
-    {
-      winDebug ("winDestroyColormapShadowGDI - Destroying default "
-	      "colormap\n");
-      
-      /*
-       * FIXME: Walk the list of all screens, popping the default
-       * palette out of each screen device context.
-       */
-      
-      /* Pop the palette out of the device context */
-      SelectPalette (pScreenPriv->hdcScreen,
-		     GetStockObject (DEFAULT_PALETTE),
-		     FALSE);
-
-      /* Clear our private installed colormap pointer */
-      pScreenPriv->pcmapInstalled = NULL;
+    winScreenPriv(pColormap->pScreen);
+    winCmapPriv(pColormap);
+
+    /*
+     * Is colormap to be destroyed the default?
+     *
+     * Non-default colormaps should have had winUninstallColormap
+     * called on them before we get here.  The default colormap
+     * will not have had winUninstallColormap called on it.  Thus,
+     * we need to handle the default colormap in a special way.
+     */
+    if (pColormap->flags & IsDefault) {
+        winDebug("winDestroyColormapShadowGDI - Destroying default "
+                 "colormap\n");
+
+        /*
+         * FIXME: Walk the list of all screens, popping the default
+         * palette out of each screen device context.
+         */
+
+        /* Pop the palette out of the device context */
+        SelectPalette(pScreenPriv->hdcScreen,
+                      GetStockObject(DEFAULT_PALETTE), FALSE);
+
+        /* Clear our private installed colormap pointer */
+        pScreenPriv->pcmapInstalled = NULL;
     }
-  
-  /* Try to delete the logical palette */
-  if (DeleteObject (pCmapPriv->hPalette) == 0)
-    {
-      ErrorF ("winDestroyColormap - DeleteObject () failed\n");
-      return FALSE;
+
+    /* Try to delete the logical palette */
+    if (DeleteObject(pCmapPriv->hPalette) == 0) {
+        ErrorF("winDestroyColormap - DeleteObject () failed\n");
+        return FALSE;
     }
-  
-  /* Invalidate the colormap privates */
-  pCmapPriv->hPalette = NULL;
 
-  return TRUE;
-}
+    /* Invalidate the colormap privates */
+    pCmapPriv->hPalette = NULL;
 
+    return TRUE;
+}
 
 /*
  * Set engine specific funtions
  */
 
 Bool
-winSetEngineFunctionsShadowGDI (ScreenPtr pScreen)
+winSetEngineFunctionsShadowGDI(ScreenPtr pScreen)
 {
-  winScreenPriv(pScreen);
-  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
-  
-  /* Set our pointers */
-  pScreenPriv->pwinAllocateFB = winAllocateFBShadowGDI;
-  pScreenPriv->pwinFreeFB = winFreeFBShadowGDI;
-  pScreenPriv->pwinShadowUpdate = winShadowUpdateGDI;
-  pScreenPriv->pwinInitScreen = winInitScreenShadowGDI;
-  pScreenPriv->pwinCloseScreen = winCloseScreenShadowGDI;
-  pScreenPriv->pwinInitVisuals = winInitVisualsShadowGDI;
-  pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowGDI;
-  if (pScreenInfo->fFullScreen)
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowFullScreen;
-  else
-    pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;
-  pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;
-  pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowGDI;
-  pScreenPriv->pwinActivateApp = winActivateAppShadowGDI;
-  pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowGDI;
-  pScreenPriv->pwinRealizeInstalledPalette = 
-    winRealizeInstalledPaletteShadowGDI;
-  pScreenPriv->pwinInstallColormap = winInstallColormapShadowGDI;
-  pScreenPriv->pwinStoreColors = winStoreColorsShadowGDI;
-  pScreenPriv->pwinCreateColormap = winCreateColormapShadowGDI;
-  pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowGDI;
-  pScreenPriv->pwinHotKeyAltTab = (winHotKeyAltTabProcPtr) (void (*)(void))NoopDDA;
-  pScreenPriv->pwinCreatePrimarySurface
-    = (winCreatePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;
-  pScreenPriv->pwinReleasePrimarySurface
-    = (winReleasePrimarySurfaceProcPtr) (void (*)(void))NoopDDA;
+    winScreenPriv(pScreen);
+    winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
+
+    /* Set our pointers */
+    pScreenPriv->pwinAllocateFB = winAllocateFBShadowGDI;
+    pScreenPriv->pwinFreeFB = winFreeFBShadowGDI;
+    pScreenPriv->pwinShadowUpdate = winShadowUpdateGDI;
+    pScreenPriv->pwinInitScreen = winInitScreenShadowGDI;
+    pScreenPriv->pwinCloseScreen = winCloseScreenShadowGDI;
+    pScreenPriv->pwinInitVisuals = winInitVisualsShadowGDI;
+    pScreenPriv->pwinAdjustVideoMode = winAdjustVideoModeShadowGDI;
+    if (pScreenInfo->fFullScreen)
+        pScreenPriv->pwinCreateBoundingWindow =
+            winCreateBoundingWindowFullScreen;
+    else
+        pScreenPriv->pwinCreateBoundingWindow = winCreateBoundingWindowWindowed;
+    pScreenPriv->pwinFinishScreenInit = winFinishScreenInitFB;
+    pScreenPriv->pwinBltExposedRegions = winBltExposedRegionsShadowGDI;
+    pScreenPriv->pwinActivateApp = winActivateAppShadowGDI;
+    pScreenPriv->pwinRedrawScreen = winRedrawScreenShadowGDI;
+    pScreenPriv->pwinRealizeInstalledPalette =
+        winRealizeInstalledPaletteShadowGDI;
+    pScreenPriv->pwinInstallColormap = winInstallColormapShadowGDI;
+    pScreenPriv->pwinStoreColors = winStoreColorsShadowGDI;
+    pScreenPriv->pwinCreateColormap = winCreateColormapShadowGDI;
+    pScreenPriv->pwinDestroyColormap = winDestroyColormapShadowGDI;
+    pScreenPriv->pwinHotKeyAltTab =
+        (winHotKeyAltTabProcPtr) (void (*)(void)) NoopDDA;
+    pScreenPriv->pwinCreatePrimarySurface =
+        (winCreatePrimarySurfaceProcPtr) (void (*)(void)) NoopDDA;
+    pScreenPriv->pwinReleasePrimarySurface =
+        (winReleasePrimarySurfaceProcPtr) (void (*)(void)) NoopDDA;
 #ifdef XWIN_MULTIWINDOW
-  pScreenPriv->pwinFinishCreateWindowsWindow =
-    (winFinishCreateWindowsWindowProcPtr) (void (*)(void))NoopDDA;
+    pScreenPriv->pwinFinishCreateWindowsWindow =
+        (winFinishCreateWindowsWindowProcPtr) (void (*)(void)) NoopDDA;
 #endif
 
-  return TRUE;
+    return TRUE;
 }