libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

15 files changed, 2961 insertions, 2968 deletions

diff --git a/xorg-server/hw/xnest/Args.c b/xorg-server/hw/xnest/Args.c
index cdc831133..21faf2e3a 100644
--- a/xorg-server/hw/xnest/Args.c
+++ b/xorg-server/hw/xnest/Args.c
@@ -29,162 +29,164 @@ is" without express or implied warranty.
 #include "Display.h"
 #include "Args.h"
 
-char *xnestDisplayName = NULL;        
+char *xnestDisplayName = NULL;
 Bool xnestSynchronize = False;
 Bool xnestFullGeneration = False;
-int xnestDefaultClass;                
+int xnestDefaultClass;
 Bool xnestUserDefaultClass = False;
 int xnestDefaultDepth;
 Bool xnestUserDefaultDepth = False;
 Bool xnestSoftwareScreenSaver = False;
-int xnestX;                    
-int xnestY;                    
+int xnestX;
+int xnestY;
 unsigned int xnestWidth;
 unsigned int xnestHeight;
 int xnestUserGeometry = 0;
-int xnestBorderWidth; 
+int xnestBorderWidth;
 Bool xnestUserBorderWidth = False;
-char *xnestWindowName = NULL;        
+char *xnestWindowName = NULL;
 int xnestNumScreens = 0;
 Bool xnestDoDirectColormaps = False;
 Window xnestParentWindow = 0;
 
 int
-ddxProcessArgument (int argc, char *argv[], int i)
+ddxProcessArgument(int argc, char *argv[], int i)
 {
-  if (!strcmp(argv[i], "-display")) {
-    if (++i < argc) {
-      xnestDisplayName = argv[i];
-      return 2;
+    if (!strcmp(argv[i], "-display")) {
+        if (++i < argc) {
+            xnestDisplayName = argv[i];
+            return 2;
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-sync")) {
-    xnestSynchronize = True;
-    return 1;
-  }
-  if (!strcmp(argv[i], "-full")) {
-    xnestFullGeneration = True;
-    return 1;
-  }
-  if (!strcmp(argv[i], "-class")) {
-    if (++i < argc) {
-      if (!strcmp(argv[i], "StaticGray")) {
-	xnestDefaultClass = StaticGray;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
-      else if (!strcmp(argv[i], "GrayScale")) {
-	xnestDefaultClass = GrayScale;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
-      else if (!strcmp(argv[i], "StaticColor")) {
-	xnestDefaultClass = StaticColor;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
-      else if (!strcmp(argv[i], "PseudoColor")) {
-	xnestDefaultClass = PseudoColor;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
-      else if (!strcmp(argv[i], "TrueColor")) {
-	xnestDefaultClass = TrueColor;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
-      else if (!strcmp(argv[i], "DirectColor")) {
-	xnestDefaultClass = DirectColor;
-	xnestUserDefaultClass = True;
-	return 2;
-      }
+    if (!strcmp(argv[i], "-sync")) {
+        xnestSynchronize = True;
+        return 1;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-cc")) {
-    if (++i < argc && sscanf(argv[i], "%i", &xnestDefaultClass) == 1) {
-      if (xnestDefaultClass >= 0 && xnestDefaultClass <= 5) {
-	xnestUserDefaultClass = True;
-	/* lex the OS layer process it as well, so return 0 */
-      }
+    if (!strcmp(argv[i], "-full")) {
+        xnestFullGeneration = True;
+        return 1;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-depth")) {
-    if (++i < argc && sscanf(argv[i], "%i", &xnestDefaultDepth) == 1) {
-      if (xnestDefaultDepth > 0) {
-	xnestUserDefaultDepth = True;
-	return 2;
-      }
+    if (!strcmp(argv[i], "-class")) {
+        if (++i < argc) {
+            if (!strcmp(argv[i], "StaticGray")) {
+                xnestDefaultClass = StaticGray;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+            else if (!strcmp(argv[i], "GrayScale")) {
+                xnestDefaultClass = GrayScale;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+            else if (!strcmp(argv[i], "StaticColor")) {
+                xnestDefaultClass = StaticColor;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+            else if (!strcmp(argv[i], "PseudoColor")) {
+                xnestDefaultClass = PseudoColor;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+            else if (!strcmp(argv[i], "TrueColor")) {
+                xnestDefaultClass = TrueColor;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+            else if (!strcmp(argv[i], "DirectColor")) {
+                xnestDefaultClass = DirectColor;
+                xnestUserDefaultClass = True;
+                return 2;
+            }
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-sss")) {
-    xnestSoftwareScreenSaver = True;
-    return 1;
-  }
-  if (!strcmp(argv[i], "-geometry")) {
-    if (++i < argc) {
-      xnestUserGeometry = XParseGeometry(argv[i],
-					 &xnestX, &xnestY,
-					 &xnestWidth, &xnestHeight);
-      if (xnestUserGeometry) return 2;
+    if (!strcmp(argv[i], "-cc")) {
+        if (++i < argc && sscanf(argv[i], "%i", &xnestDefaultClass) == 1) {
+            if (xnestDefaultClass >= 0 && xnestDefaultClass <= 5) {
+                xnestUserDefaultClass = True;
+                /* lex the OS layer process it as well, so return 0 */
+            }
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-bw")) {
-    if (++i < argc && sscanf(argv[i], "%i", &xnestBorderWidth) == 1) {
-      if (xnestBorderWidth >= 0) {
-	xnestUserBorderWidth = True;
-	return 2;
-      }
+    if (!strcmp(argv[i], "-depth")) {
+        if (++i < argc && sscanf(argv[i], "%i", &xnestDefaultDepth) == 1) {
+            if (xnestDefaultDepth > 0) {
+                xnestUserDefaultDepth = True;
+                return 2;
+            }
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-name")) {
-    if (++i < argc) {
-      xnestWindowName = argv[i];
-      return 2;
+    if (!strcmp(argv[i], "-sss")) {
+        xnestSoftwareScreenSaver = True;
+        return 1;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-scrns")) {
-    if (++i < argc && sscanf(argv[i], "%i", &xnestNumScreens) == 1) {
-      if (xnestNumScreens > 0) {
-	if (xnestNumScreens > MAXSCREENS) {
-	  ErrorF("Maximum number of screens is %d.\n", MAXSCREENS);
-	  xnestNumScreens = MAXSCREENS;
-	}
-	return 2;
-      }
+    if (!strcmp(argv[i], "-geometry")) {
+        if (++i < argc) {
+            xnestUserGeometry = XParseGeometry(argv[i],
+                                               &xnestX, &xnestY,
+                                               &xnestWidth, &xnestHeight);
+            if (xnestUserGeometry)
+                return 2;
+        }
+        return 0;
     }
-    return 0;
-  }
-  if (!strcmp(argv[i], "-install")) {
-    xnestDoDirectColormaps = True;
-    return 1;
-  }
-  if (!strcmp(argv[i], "-parent")) {
-    if (++i < argc) {
-      xnestParentWindow = (XID) strtol (argv[i], (char**)NULL, 0);
-      return 2;
+    if (!strcmp(argv[i], "-bw")) {
+        if (++i < argc && sscanf(argv[i], "%i", &xnestBorderWidth) == 1) {
+            if (xnestBorderWidth >= 0) {
+                xnestUserBorderWidth = True;
+                return 2;
+            }
+        }
+        return 0;
+    }
+    if (!strcmp(argv[i], "-name")) {
+        if (++i < argc) {
+            xnestWindowName = argv[i];
+            return 2;
+        }
+        return 0;
+    }
+    if (!strcmp(argv[i], "-scrns")) {
+        if (++i < argc && sscanf(argv[i], "%i", &xnestNumScreens) == 1) {
+            if (xnestNumScreens > 0) {
+                if (xnestNumScreens > MAXSCREENS) {
+                    ErrorF("Maximum number of screens is %d.\n", MAXSCREENS);
+                    xnestNumScreens = MAXSCREENS;
+                }
+                return 2;
+            }
+        }
+        return 0;
     }
-  }
-  return 0;
+    if (!strcmp(argv[i], "-install")) {
+        xnestDoDirectColormaps = True;
+        return 1;
+    }
+    if (!strcmp(argv[i], "-parent")) {
+        if (++i < argc) {
+            xnestParentWindow = (XID) strtol(argv[i], (char **) NULL, 0);
+            return 2;
+        }
+    }
+    return 0;
 }
 
-void ddxUseMsg(void)
+void
+ddxUseMsg(void)
 {
-  ErrorF("-display string        display name of the real server\n");
-  ErrorF("-sync                  sinchronize with the real server\n");
-  ErrorF("-full                  utilize full regeneration\n");
-  ErrorF("-class string          default visual class\n");
-  ErrorF("-depth int             default depth\n");
-  ErrorF("-sss                   use software screen saver\n");
-  ErrorF("-geometry WxH+X+Y      window size and position\n");
-  ErrorF("-bw int                window border width\n");
-  ErrorF("-name string           window name\n");
-  ErrorF("-scrns int             number of screens to generate\n");
-  ErrorF("-install               instal colormaps directly\n");
+    ErrorF("-display string        display name of the real server\n");
+    ErrorF("-sync                  sinchronize with the real server\n");
+    ErrorF("-full                  utilize full regeneration\n");
+    ErrorF("-class string          default visual class\n");
+    ErrorF("-depth int             default depth\n");
+    ErrorF("-sss                   use software screen saver\n");
+    ErrorF("-geometry WxH+X+Y      window size and position\n");
+    ErrorF("-bw int                window border width\n");
+    ErrorF("-name string           window name\n");
+    ErrorF("-scrns int             number of screens to generate\n");
+    ErrorF("-install               instal colormaps directly\n");
 }
diff --git a/xorg-server/hw/xnest/Color.c b/xorg-server/hw/xnest/Color.c
index 2548f9495..7ef137d59 100644
--- a/xorg-server/hw/xnest/Color.c
+++ b/xorg-server/hw/xnest/Color.c
@@ -1,495 +1,493 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "scrnintstr.h"

-#include "window.h"

-#include "windowstr.h"

-#include "colormapst.h"

-#include "resource.h"

-

-#include "Xnest.h"

-

-

-#include "Display.h"

-#include "Screen.h"

-#include "Color.h"

-#include "Visual.h"

-#include "XNWindow.h"

-#include "Args.h"

-

-DevPrivateKeyRec xnestColormapPrivateKeyRec;

-

-static DevPrivateKeyRec cmapScrPrivateKeyRec;

-#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)

-

-#define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))

-#define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))

-

-Bool

-xnestCreateColormap(ColormapPtr pCmap)

-{

-  VisualPtr pVisual;

-  XColor *colors;

-  int i, ncolors;

-  Pixel red, green, blue;

-  Pixel redInc, greenInc, blueInc;

-

-  pVisual = pCmap->pVisual;

-  ncolors = pVisual->ColormapEntries;

-

-  xnestColormapPriv(pCmap)->colormap = 

-    XCreateColormap(xnestDisplay,

-		    xnestDefaultWindows[pCmap->pScreen->myNum],

-		    xnestVisual(pVisual),

-		    (pVisual->class & DynamicClass) ? 

-		    AllocAll : AllocNone);

- 

-  

-  switch (pVisual->class) {

-  case StaticGray: /* read only */

-    colors = (XColor *)malloc(ncolors * sizeof(XColor));

-    for (i = 0; i < ncolors; i++)

-      colors[i].pixel = i;

-    XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);

-    for (i = 0; i < ncolors; i++) {

-      pCmap->red[i].co.local.red = colors[i].red;

-      pCmap->red[i].co.local.green = colors[i].red;

-      pCmap->red[i].co.local.blue = colors[i].red;

-    }

-    free(colors);

-    break;

-

-  case StaticColor: /* read only */

-    colors = (XColor *)malloc(ncolors * sizeof(XColor));

-    for (i = 0; i < ncolors; i++)

-      colors[i].pixel = i;

-    XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);

-    for (i = 0; i < ncolors; i++) {

-      pCmap->red[i].co.local.red = colors[i].red;

-      pCmap->red[i].co.local.green = colors[i].green;

-      pCmap->red[i].co.local.blue = colors[i].blue;

-    }

-    free(colors);

-    break;

-    

-  case TrueColor: /* read only */

-    colors = (XColor *)malloc(ncolors * sizeof(XColor));

-    red = green = blue = 0L;

-    redInc = lowbit(pVisual->redMask);

-    greenInc = lowbit(pVisual->greenMask);

-    blueInc = lowbit(pVisual->blueMask);

-    for (i = 0; i < ncolors; i++) {

-      colors[i].pixel = red | green | blue;

-      red += redInc;

-      if (red > pVisual->redMask) red = 0L;

-      green += greenInc;

-      if (green > pVisual->greenMask) green = 0L;

-      blue += blueInc;

-      if (blue > pVisual->blueMask) blue = 0L;

-    }

-    XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);

-    for (i = 0; i < ncolors; i++) {

-      pCmap->red[i].co.local.red = colors[i].red;

-      pCmap->green[i].co.local.green = colors[i].green;

-      pCmap->blue[i].co.local.blue = colors[i].blue;

-    }

-    free(colors);

-    break;

-    

-  case GrayScale: /* read and write */

-    break;

-

-  case PseudoColor: /* read and write */

-    break;

-

-  case DirectColor: /* read and write */

-    break;

-  }

-  

-  return True;

-}

-

-void

-xnestDestroyColormap(ColormapPtr pCmap)

-{

-  XFreeColormap(xnestDisplay, xnestColormap(pCmap));

-}

-

-#define SEARCH_PREDICATE \

-  (xnestWindow(pWin) != None && wColormap(pWin) == icws->cmapIDs[i])

-

-static int

-xnestCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)

-{

-  xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *)ptr;

-  int i;

-  

-  for (i = 0; i < icws->numCmapIDs; i++)

-    if (SEARCH_PREDICATE) {

-      icws->numWindows++;

-      return WT_DONTWALKCHILDREN;

-    }

-  

-  return WT_WALKCHILDREN;

-}

-

-static int

-xnestGetInstalledColormapWindows(WindowPtr pWin, pointer ptr)

-{

-  xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *)ptr;

-  int i;

-  

-  for (i = 0; i < icws->numCmapIDs; i++)

-    if (SEARCH_PREDICATE) {

-      icws->windows[icws->index++] = xnestWindow(pWin);

-      return WT_DONTWALKCHILDREN;

-    }

-  

-  return WT_WALKCHILDREN;

-}

-

-static Window *xnestOldInstalledColormapWindows = NULL;

-static int xnestNumOldInstalledColormapWindows = 0;

-

-static Bool

-xnestSameInstalledColormapWindows(Window *windows, int numWindows)

-{

-  if (xnestNumOldInstalledColormapWindows != numWindows) 

-    return False;

-

-  if (xnestOldInstalledColormapWindows == windows) 

-    return True;

-

-  if (xnestOldInstalledColormapWindows == NULL || windows == NULL) 

-    return False;

-

-  if (memcmp(xnestOldInstalledColormapWindows, windows, 

-	   numWindows * sizeof(Window))) 

-    return False;

-

-  return True;

-}

-

-void

-xnestSetInstalledColormapWindows(ScreenPtr pScreen)

-{

-  xnestInstalledColormapWindows icws;

-  int numWindows;

-  

-  icws.cmapIDs = (Colormap *)malloc(pScreen->maxInstalledCmaps *

-				    sizeof(Colormap));

-  icws.numCmapIDs = xnestListInstalledColormaps(pScreen, icws.cmapIDs);

-  icws.numWindows = 0;

-  WalkTree(pScreen, xnestCountInstalledColormapWindows, (pointer)&icws);

-  if (icws.numWindows) {

-    icws.windows = (Window *)malloc((icws.numWindows + 1) * sizeof(Window));

-    icws.index = 0;

-    WalkTree(pScreen, xnestGetInstalledColormapWindows, (pointer)&icws);

-    icws.windows[icws.numWindows] = xnestDefaultWindows[pScreen->myNum];

-    numWindows = icws.numWindows + 1;

-  }

-  else {

-    icws.windows = NULL;

-    numWindows = 0;

-  }

-  

-  free(icws.cmapIDs);

-  

-  if (!xnestSameInstalledColormapWindows(icws.windows, icws.numWindows)) {

-    free(xnestOldInstalledColormapWindows);

-

-#ifdef _XSERVER64

-    {

-      int i;

-      Window64 *windows = (Window64 *)malloc(numWindows * sizeof(Window64));

-

-      for(i = 0; i < numWindows; ++i)

-	  windows[i] = icws.windows[i];

-      XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],

-			    windows, numWindows);

-      free(windows);

-    }

-#else

-    XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],

-			  icws.windows, numWindows);

-#endif

-

-    xnestOldInstalledColormapWindows = icws.windows;

-    xnestNumOldInstalledColormapWindows = icws.numWindows;

-

-#ifdef DUMB_WINDOW_MANAGERS

-    /* 

-      This code is for dumb window managers.

-      This will only work with default local visual colormaps.

-      */

-    if (icws.numWindows)

-      {

-	WindowPtr pWin;

-	Visual *visual;

-	ColormapPtr pCmap;

-

-	pWin = xnestWindowPtr(icws.windows[0]);

-	visual = xnestVisualFromID(pScreen, wVisual(pWin));

-	

-	if (visual == xnestDefaultVisual(pScreen))

-	    dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),

-				    RT_COLORMAP, serverClient, DixUseAccess);

-	else

-	    dixLookupResourceByType((pointer *)&pCmap, pScreen->defColormap,

-				    RT_COLORMAP, serverClient, DixUseAccess);

-	

-	XSetWindowColormap(xnestDisplay, 

-			   xnestDefaultWindows[pScreen->myNum],

-			   xnestColormap(pCmap));

-      }

-#endif /* DUMB_WINDOW_MANAGERS */

-  }

-  else

-    free(icws.windows);

-}

-

-void

-xnestSetScreenSaverColormapWindow(ScreenPtr pScreen)

-{

-  free(xnestOldInstalledColormapWindows);

-  

-#ifdef _XSERVER64

-  {

-    Window64 window;

-

-    window = xnestScreenSaverWindows[pScreen->myNum];

-    XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],

-			  &window, 1);

-    xnestScreenSaverWindows[pScreen->myNum] = window;

-  }

-#else

-  XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],

-			&xnestScreenSaverWindows[pScreen->myNum], 1);

-#endif /* _XSERVER64 */

-  

-  xnestOldInstalledColormapWindows = NULL;

-  xnestNumOldInstalledColormapWindows = 0;

-

-  xnestDirectUninstallColormaps(pScreen);

-}

-

-void

-xnestDirectInstallColormaps(ScreenPtr pScreen)

-{

-  int i, n;

-  Colormap pCmapIDs[MAXCMAPS];

-  

-  if (!xnestDoDirectColormaps) return;

-

-  n = (*pScreen->ListInstalledColormaps)(pScreen, pCmapIDs);

-

-  for (i = 0; i < n; i++) {

-    ColormapPtr pCmap;

-    

-    dixLookupResourceByType((pointer *)&pCmap, pCmapIDs[i], RT_COLORMAP,

-			    serverClient, DixInstallAccess);

-    if (pCmap)

-      XInstallColormap(xnestDisplay, xnestColormap(pCmap));

-  }

-}

-

-void

-xnestDirectUninstallColormaps(ScreenPtr pScreen)

-{

-  int i, n;

-  Colormap pCmapIDs[MAXCMAPS];

-

-  if (!xnestDoDirectColormaps) return;

-

-  n = (*pScreen->ListInstalledColormaps)(pScreen, pCmapIDs);

-

-  for (i = 0; i < n; i++) {

-    ColormapPtr pCmap;

-    

-    dixLookupResourceByType((pointer *)&pCmap, pCmapIDs[i], RT_COLORMAP,

-			    serverClient, DixUninstallAccess);

-    if (pCmap)

-      XUninstallColormap(xnestDisplay, xnestColormap(pCmap));

-  }

-}

-

-void

-xnestInstallColormap(ColormapPtr pCmap)

-{

-  ColormapPtr pOldCmap = GetInstalledColormap(pCmap->pScreen);

-  

-  if(pCmap != pOldCmap)

-    {

-      xnestDirectUninstallColormaps(pCmap->pScreen);

-

-      /* Uninstall pInstalledMap. Notify all interested parties. */

-      if(pOldCmap != (ColormapPtr)None)

-	WalkTree(pCmap->pScreen, TellLostMap, (pointer)&pOldCmap->mid);

-      

-      SetInstalledColormap(pCmap->pScreen, pCmap);

-      WalkTree(pCmap->pScreen, TellGainedMap, (pointer)&pCmap->mid);

-      

-      xnestSetInstalledColormapWindows(pCmap->pScreen);

-      xnestDirectInstallColormaps(pCmap->pScreen);

-    }

-}

-

-void

-xnestUninstallColormap(ColormapPtr pCmap)

-{

-  ColormapPtr pCurCmap = GetInstalledColormap(pCmap->pScreen);

-  

-  if(pCmap == pCurCmap)

-    {

-      if (pCmap->mid != pCmap->pScreen->defColormap)

-        {

-	  dixLookupResourceByType((pointer *)&pCurCmap,

-				  pCmap->pScreen->defColormap,

-				  RT_COLORMAP,

-				  serverClient, DixInstallAccess);

-	  (*pCmap->pScreen->InstallColormap)(pCurCmap);

-        }

-    }

-}

-

-static Bool xnestInstalledDefaultColormap = False;

-

-int

-xnestListInstalledColormaps(ScreenPtr pScreen, Colormap *pCmapIDs)

-{

-  if (xnestInstalledDefaultColormap) {

-    *pCmapIDs = GetInstalledColormap(pScreen)->mid;

-    return 1;

-  }

-  else

-    return 0;

-}

-

-void

-xnestStoreColors(ColormapPtr pCmap, int nColors, xColorItem *pColors)

-{

-  if (pCmap->pVisual->class & DynamicClass)

-#ifdef _XSERVER64

-  {

-    int i;

-    XColor *pColors64 = (XColor *)malloc(nColors * sizeof(XColor) );

-

-    for(i = 0; i < nColors; ++i)

-    {

-      pColors64[i].pixel = pColors[i].pixel;

-      pColors64[i].red = pColors[i].red;

-      pColors64[i].green = pColors[i].green;

-      pColors64[i].blue = pColors[i].blue;

-      pColors64[i].flags = pColors[i].flags;

-    }

-    XStoreColors(xnestDisplay, xnestColormap(pCmap), pColors64, nColors);

-    free(pColors64);

-  }

-#else

-    XStoreColors(xnestDisplay, xnestColormap(pCmap),

-		 (XColor *)pColors, nColors);

-#endif

-}

-

-void

-xnestResolveColor(unsigned short *pRed, unsigned short *pGreen,

-		  unsigned short *pBlue, VisualPtr pVisual)

-{

-  int shift;

-  unsigned int lim;

-  

-  shift = 16 - pVisual->bitsPerRGBValue;

-  lim = (1 << pVisual->bitsPerRGBValue) - 1;

-

-  if ((pVisual->class == PseudoColor) || (pVisual->class == DirectColor))

-    {

-      /* rescale to rgb bits */

-      *pRed = ((*pRed >> shift) * 65535) / lim;

-      *pGreen = ((*pGreen >> shift) * 65535) / lim;

-      *pBlue = ((*pBlue >> shift) * 65535) / lim;

-    }

-  else if (pVisual->class == GrayScale)

-    {

-      /* rescale to gray then rgb bits */

-      *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;

-      *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;

-    }

-  else if (pVisual->class == StaticGray)

-    {

-      unsigned int limg;

- 

-      limg = pVisual->ColormapEntries - 1;

-      /* rescale to gray then [0..limg] then [0..65535] then rgb bits */

-      *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;

-      *pRed = ((((*pRed * (limg + 1))) >> 16) * 65535) / limg;

-      *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;

-    }

-  else

-    {

-      unsigned limr, limg, limb;

-      

-      limr = pVisual->redMask >> pVisual->offsetRed;

-      limg = pVisual->greenMask >> pVisual->offsetGreen;

-      limb = pVisual->blueMask >> pVisual->offsetBlue;

-      /* rescale to [0..limN] then [0..65535] then rgb bits */

-      *pRed = ((((((*pRed * (limr + 1)) >> 16) *

-		  65535) / limr) >> shift) * 65535) / lim;

-      *pGreen = ((((((*pGreen * (limg + 1)) >> 16) *

-		    65535) / limg) >> shift) * 65535) / lim;

-      *pBlue = ((((((*pBlue * (limb + 1)) >> 16) *

-		   65535) / limb) >> shift) * 65535) / lim;

-    }

-}

-

-Bool

-xnestCreateDefaultColormap(ScreenPtr pScreen)

-{

-  VisualPtr   pVisual;

-  ColormapPtr pCmap;

-  unsigned short zero = 0, ones = 0xFFFF;  

-  Pixel wp, bp;

-

-  if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))

-      return FALSE;

-

-  for (pVisual = pScreen->visuals;

-       pVisual->vid != pScreen->rootVisual;

-       pVisual++);

-

-  if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &pCmap,

-		     (pVisual->class & DynamicClass) ? AllocNone : AllocAll, 0)

-      != Success)

-    return False;

-

-  wp = pScreen->whitePixel;

-  bp = pScreen->blackPixel;

-  if ((AllocColor(pCmap, &ones, &ones, &ones, &wp, 0) !=

-       Success) ||

-      (AllocColor(pCmap, &zero, &zero, &zero, &bp, 0) !=

-       Success))

-    return FALSE;

-  pScreen->whitePixel = wp;

-  pScreen->blackPixel = bp;

-  (*pScreen->InstallColormap)(pCmap);

-

-  xnestInstalledDefaultColormap = True;

-

-  return True;

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "scrnintstr.h"
+#include "window.h"
+#include "windowstr.h"
+#include "colormapst.h"
+#include "resource.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "Screen.h"
+#include "Color.h"
+#include "Visual.h"
+#include "XNWindow.h"
+#include "Args.h"
+
+DevPrivateKeyRec xnestColormapPrivateKeyRec;
+
+static DevPrivateKeyRec cmapScrPrivateKeyRec;
+
+#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)
+
+#define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))
+#define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))
+
+Bool
+xnestCreateColormap(ColormapPtr pCmap)
+{
+    VisualPtr pVisual;
+    XColor *colors;
+    int i, ncolors;
+    Pixel red, green, blue;
+    Pixel redInc, greenInc, blueInc;
+
+    pVisual = pCmap->pVisual;
+    ncolors = pVisual->ColormapEntries;
+
+    xnestColormapPriv(pCmap)->colormap =
+        XCreateColormap(xnestDisplay,
+                        xnestDefaultWindows[pCmap->pScreen->myNum],
+                        xnestVisual(pVisual),
+                        (pVisual->class & DynamicClass) ? AllocAll : AllocNone);
+
+    switch (pVisual->class) {
+    case StaticGray:           /* read only */
+        colors = (XColor *) malloc(ncolors * sizeof(XColor));
+        for (i = 0; i < ncolors; i++)
+            colors[i].pixel = i;
+        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
+        for (i = 0; i < ncolors; i++) {
+            pCmap->red[i].co.local.red = colors[i].red;
+            pCmap->red[i].co.local.green = colors[i].red;
+            pCmap->red[i].co.local.blue = colors[i].red;
+        }
+        free(colors);
+        break;
+
+    case StaticColor:          /* read only */
+        colors = (XColor *) malloc(ncolors * sizeof(XColor));
+        for (i = 0; i < ncolors; i++)
+            colors[i].pixel = i;
+        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
+        for (i = 0; i < ncolors; i++) {
+            pCmap->red[i].co.local.red = colors[i].red;
+            pCmap->red[i].co.local.green = colors[i].green;
+            pCmap->red[i].co.local.blue = colors[i].blue;
+        }
+        free(colors);
+        break;
+
+    case TrueColor:            /* read only */
+        colors = (XColor *) malloc(ncolors * sizeof(XColor));
+        red = green = blue = 0L;
+        redInc = lowbit(pVisual->redMask);
+        greenInc = lowbit(pVisual->greenMask);
+        blueInc = lowbit(pVisual->blueMask);
+        for (i = 0; i < ncolors; i++) {
+            colors[i].pixel = red | green | blue;
+            red += redInc;
+            if (red > pVisual->redMask)
+                red = 0L;
+            green += greenInc;
+            if (green > pVisual->greenMask)
+                green = 0L;
+            blue += blueInc;
+            if (blue > pVisual->blueMask)
+                blue = 0L;
+        }
+        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
+        for (i = 0; i < ncolors; i++) {
+            pCmap->red[i].co.local.red = colors[i].red;
+            pCmap->green[i].co.local.green = colors[i].green;
+            pCmap->blue[i].co.local.blue = colors[i].blue;
+        }
+        free(colors);
+        break;
+
+    case GrayScale:            /* read and write */
+        break;
+
+    case PseudoColor:          /* read and write */
+        break;
+
+    case DirectColor:          /* read and write */
+        break;
+    }
+
+    return True;
+}
+
+void
+xnestDestroyColormap(ColormapPtr pCmap)
+{
+    XFreeColormap(xnestDisplay, xnestColormap(pCmap));
+}
+
+#define SEARCH_PREDICATE \
+  (xnestWindow(pWin) != None && wColormap(pWin) == icws->cmapIDs[i])
+
+static int
+xnestCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)
+{
+    xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *) ptr;
+    int i;
+
+    for (i = 0; i < icws->numCmapIDs; i++)
+        if (SEARCH_PREDICATE) {
+            icws->numWindows++;
+            return WT_DONTWALKCHILDREN;
+        }
+
+    return WT_WALKCHILDREN;
+}
+
+static int
+xnestGetInstalledColormapWindows(WindowPtr pWin, pointer ptr)
+{
+    xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *) ptr;
+    int i;
+
+    for (i = 0; i < icws->numCmapIDs; i++)
+        if (SEARCH_PREDICATE) {
+            icws->windows[icws->index++] = xnestWindow(pWin);
+            return WT_DONTWALKCHILDREN;
+        }
+
+    return WT_WALKCHILDREN;
+}
+
+static Window *xnestOldInstalledColormapWindows = NULL;
+static int xnestNumOldInstalledColormapWindows = 0;
+
+static Bool
+xnestSameInstalledColormapWindows(Window *windows, int numWindows)
+{
+    if (xnestNumOldInstalledColormapWindows != numWindows)
+        return False;
+
+    if (xnestOldInstalledColormapWindows == windows)
+        return True;
+
+    if (xnestOldInstalledColormapWindows == NULL || windows == NULL)
+        return False;
+
+    if (memcmp(xnestOldInstalledColormapWindows, windows,
+               numWindows * sizeof(Window)))
+        return False;
+
+    return True;
+}
+
+void
+xnestSetInstalledColormapWindows(ScreenPtr pScreen)
+{
+    xnestInstalledColormapWindows icws;
+    int numWindows;
+
+    icws.cmapIDs = (Colormap *) malloc(pScreen->maxInstalledCmaps *
+                                       sizeof(Colormap));
+    icws.numCmapIDs = xnestListInstalledColormaps(pScreen, icws.cmapIDs);
+    icws.numWindows = 0;
+    WalkTree(pScreen, xnestCountInstalledColormapWindows, (pointer) &icws);
+    if (icws.numWindows) {
+        icws.windows =
+            (Window *) malloc((icws.numWindows + 1) * sizeof(Window));
+        icws.index = 0;
+        WalkTree(pScreen, xnestGetInstalledColormapWindows, (pointer) &icws);
+        icws.windows[icws.numWindows] = xnestDefaultWindows[pScreen->myNum];
+        numWindows = icws.numWindows + 1;
+    }
+    else {
+        icws.windows = NULL;
+        numWindows = 0;
+    }
+
+    free(icws.cmapIDs);
+
+    if (!xnestSameInstalledColormapWindows(icws.windows, icws.numWindows)) {
+        free(xnestOldInstalledColormapWindows);
+
+#ifdef _XSERVER64
+        {
+            int i;
+            Window64 *windows =
+                (Window64 *) malloc(numWindows * sizeof(Window64));
+
+            for (i = 0; i < numWindows; ++i)
+                windows[i] = icws.windows[i];
+            XSetWMColormapWindows(xnestDisplay,
+                                  xnestDefaultWindows[pScreen->myNum], windows,
+                                  numWindows);
+            free(windows);
+        }
+#else
+        XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
+                              icws.windows, numWindows);
+#endif
+
+        xnestOldInstalledColormapWindows = icws.windows;
+        xnestNumOldInstalledColormapWindows = icws.numWindows;
+
+#ifdef DUMB_WINDOW_MANAGERS
+        /* 
+           This code is for dumb window managers.
+           This will only work with default local visual colormaps.
+         */
+        if (icws.numWindows) {
+            WindowPtr pWin;
+            Visual *visual;
+            ColormapPtr pCmap;
+
+            pWin = xnestWindowPtr(icws.windows[0]);
+            visual = xnestVisualFromID(pScreen, wVisual(pWin));
+
+            if (visual == xnestDefaultVisual(pScreen))
+                dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
+                                        RT_COLORMAP, serverClient,
+                                        DixUseAccess);
+            else
+                dixLookupResourceByType((pointer *) &pCmap,
+                                        pScreen->defColormap, RT_COLORMAP,
+                                        serverClient, DixUseAccess);
+
+            XSetWindowColormap(xnestDisplay,
+                               xnestDefaultWindows[pScreen->myNum],
+                               xnestColormap(pCmap));
+        }
+#endif                          /* DUMB_WINDOW_MANAGERS */
+    }
+    else
+        free(icws.windows);
+}
+
+void
+xnestSetScreenSaverColormapWindow(ScreenPtr pScreen)
+{
+    free(xnestOldInstalledColormapWindows);
+
+#ifdef _XSERVER64
+    {
+        Window64 window;
+
+        window = xnestScreenSaverWindows[pScreen->myNum];
+        XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
+                              &window, 1);
+        xnestScreenSaverWindows[pScreen->myNum] = window;
+    }
+#else
+    XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
+                          &xnestScreenSaverWindows[pScreen->myNum], 1);
+#endif                          /* _XSERVER64 */
+
+    xnestOldInstalledColormapWindows = NULL;
+    xnestNumOldInstalledColormapWindows = 0;
+
+    xnestDirectUninstallColormaps(pScreen);
+}
+
+void
+xnestDirectInstallColormaps(ScreenPtr pScreen)
+{
+    int i, n;
+    Colormap pCmapIDs[MAXCMAPS];
+
+    if (!xnestDoDirectColormaps)
+        return;
+
+    n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);
+
+    for (i = 0; i < n; i++) {
+        ColormapPtr pCmap;
+
+        dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
+                                serverClient, DixInstallAccess);
+        if (pCmap)
+            XInstallColormap(xnestDisplay, xnestColormap(pCmap));
+    }
+}
+
+void
+xnestDirectUninstallColormaps(ScreenPtr pScreen)
+{
+    int i, n;
+    Colormap pCmapIDs[MAXCMAPS];
+
+    if (!xnestDoDirectColormaps)
+        return;
+
+    n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);
+
+    for (i = 0; i < n; i++) {
+        ColormapPtr pCmap;
+
+        dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
+                                serverClient, DixUninstallAccess);
+        if (pCmap)
+            XUninstallColormap(xnestDisplay, xnestColormap(pCmap));
+    }
+}
+
+void
+xnestInstallColormap(ColormapPtr pCmap)
+{
+    ColormapPtr pOldCmap = GetInstalledColormap(pCmap->pScreen);
+
+    if (pCmap != pOldCmap) {
+        xnestDirectUninstallColormaps(pCmap->pScreen);
+
+        /* Uninstall pInstalledMap. Notify all interested parties. */
+        if (pOldCmap != (ColormapPtr) None)
+            WalkTree(pCmap->pScreen, TellLostMap, (pointer) &pOldCmap->mid);
+
+        SetInstalledColormap(pCmap->pScreen, pCmap);
+        WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &pCmap->mid);
+
+        xnestSetInstalledColormapWindows(pCmap->pScreen);
+        xnestDirectInstallColormaps(pCmap->pScreen);
+    }
+}
+
+void
+xnestUninstallColormap(ColormapPtr pCmap)
+{
+    ColormapPtr pCurCmap = GetInstalledColormap(pCmap->pScreen);
+
+    if (pCmap == pCurCmap) {
+        if (pCmap->mid != pCmap->pScreen->defColormap) {
+            dixLookupResourceByType((pointer *) &pCurCmap,
+                                    pCmap->pScreen->defColormap,
+                                    RT_COLORMAP,
+                                    serverClient, DixInstallAccess);
+            (*pCmap->pScreen->InstallColormap) (pCurCmap);
+        }
+    }
+}
+
+static Bool xnestInstalledDefaultColormap = False;
+
+int
+xnestListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmapIDs)
+{
+    if (xnestInstalledDefaultColormap) {
+        *pCmapIDs = GetInstalledColormap(pScreen)->mid;
+        return 1;
+    }
+    else
+        return 0;
+}
+
+void
+xnestStoreColors(ColormapPtr pCmap, int nColors, xColorItem * pColors)
+{
+    if (pCmap->pVisual->class & DynamicClass)
+#ifdef _XSERVER64
+    {
+        int i;
+        XColor *pColors64 = (XColor *) malloc(nColors * sizeof(XColor));
+
+        for (i = 0; i < nColors; ++i) {
+            pColors64[i].pixel = pColors[i].pixel;
+            pColors64[i].red = pColors[i].red;
+            pColors64[i].green = pColors[i].green;
+            pColors64[i].blue = pColors[i].blue;
+            pColors64[i].flags = pColors[i].flags;
+        }
+        XStoreColors(xnestDisplay, xnestColormap(pCmap), pColors64, nColors);
+        free(pColors64);
+    }
+#else
+        XStoreColors(xnestDisplay, xnestColormap(pCmap),
+                     (XColor *) pColors, nColors);
+#endif
+}
+
+void
+xnestResolveColor(unsigned short *pRed, unsigned short *pGreen,
+                  unsigned short *pBlue, VisualPtr pVisual)
+{
+    int shift;
+    unsigned int lim;
+
+    shift = 16 - pVisual->bitsPerRGBValue;
+    lim = (1 << pVisual->bitsPerRGBValue) - 1;
+
+    if ((pVisual->class == PseudoColor) || (pVisual->class == DirectColor)) {
+        /* rescale to rgb bits */
+        *pRed = ((*pRed >> shift) * 65535) / lim;
+        *pGreen = ((*pGreen >> shift) * 65535) / lim;
+        *pBlue = ((*pBlue >> shift) * 65535) / lim;
+    }
+    else if (pVisual->class == GrayScale) {
+        /* rescale to gray then rgb bits */
+        *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;
+        *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;
+    }
+    else if (pVisual->class == StaticGray) {
+        unsigned int limg;
+
+        limg = pVisual->ColormapEntries - 1;
+        /* rescale to gray then [0..limg] then [0..65535] then rgb bits */
+        *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;
+        *pRed = ((((*pRed * (limg + 1))) >> 16) * 65535) / limg;
+        *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;
+    }
+    else {
+        unsigned limr, limg, limb;
+
+        limr = pVisual->redMask >> pVisual->offsetRed;
+        limg = pVisual->greenMask >> pVisual->offsetGreen;
+        limb = pVisual->blueMask >> pVisual->offsetBlue;
+        /* rescale to [0..limN] then [0..65535] then rgb bits */
+        *pRed = ((((((*pRed * (limr + 1)) >> 16) *
+                    65535) / limr) >> shift) * 65535) / lim;
+        *pGreen = ((((((*pGreen * (limg + 1)) >> 16) *
+                      65535) / limg) >> shift) * 65535) / lim;
+        *pBlue = ((((((*pBlue * (limb + 1)) >> 16) *
+                     65535) / limb) >> shift) * 65535) / lim;
+    }
+}
+
+Bool
+xnestCreateDefaultColormap(ScreenPtr pScreen)
+{
+    VisualPtr pVisual;
+    ColormapPtr pCmap;
+    unsigned short zero = 0, ones = 0xFFFF;
+    Pixel wp, bp;
+
+    if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))
+        return FALSE;
+
+    for (pVisual = pScreen->visuals;
+         pVisual->vid != pScreen->rootVisual; pVisual++);
+
+    if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &pCmap,
+                       (pVisual->class & DynamicClass) ? AllocNone : AllocAll,
+                       0)
+        != Success)
+        return False;
+
+    wp = pScreen->whitePixel;
+    bp = pScreen->blackPixel;
+    if ((AllocColor(pCmap, &ones, &ones, &ones, &wp, 0) !=
+         Success) ||
+        (AllocColor(pCmap, &zero, &zero, &zero, &bp, 0) != Success))
+        return FALSE;
+    pScreen->whitePixel = wp;
+    pScreen->blackPixel = bp;
+    (*pScreen->InstallColormap) (pCmap);
+
+    xnestInstalledDefaultColormap = True;
+
+    return True;
+}
diff --git a/xorg-server/hw/xnest/Cursor.c b/xorg-server/hw/xnest/Cursor.c
index f35517abb..285e10ebf 100644
--- a/xorg-server/hw/xnest/Cursor.c
+++ b/xorg-server/hw/xnest/Cursor.c
@@ -1,182 +1,173 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "screenint.h"

-#include "input.h"

-#include "misc.h"

-#include "cursor.h"

-#include "cursorstr.h"

-#include "scrnintstr.h"

-#include "servermd.h"

-#include "mipointrst.h"

-

-#include "Xnest.h"

-

-#include "Display.h"

-#include "Screen.h"

-#include "XNCursor.h"

-#include "Visual.h"

-#include "Keyboard.h"

-#include "Args.h"

-

-xnestCursorFuncRec xnestCursorFuncs = {NULL};

-

-Bool

-xnestRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-  XImage *ximage;

-  Pixmap source, mask;

-  XColor fg_color, bg_color;

-  unsigned long valuemask;

-  XGCValues values;

-

-  valuemask = GCFunction | 

-              GCPlaneMask | 

-	      GCForeground |

-	      GCBackground |

-	      GCClipMask;

-

-  values.function = GXcopy;

-  values.plane_mask = AllPlanes;

-  values.foreground = 1L;

-  values.background = 0L;

-  values.clip_mask = None;

-

-  XChangeGC(xnestDisplay, xnestBitmapGC, valuemask, &values);

-

-  source = XCreatePixmap(xnestDisplay, 

-			 xnestDefaultWindows[pScreen->myNum],

-			 pCursor->bits->width,

-			 pCursor->bits->height,

-			 1);

-  

-  mask   = XCreatePixmap(xnestDisplay, 

-			 xnestDefaultWindows[pScreen->myNum],

-			 pCursor->bits->width,

-			 pCursor->bits->height,

-			 1);

-  

-  ximage = XCreateImage(xnestDisplay, 

-			xnestDefaultVisual(pScreen),

-			1, XYBitmap, 0, 

-			(char *)pCursor->bits->source,

-			pCursor->bits->width,

-			pCursor->bits->height,

-			BitmapPad(xnestDisplay), 0);

-  

-  XPutImage(xnestDisplay, source, xnestBitmapGC, ximage,

-	    0, 0, 0, 0, pCursor->bits->width, pCursor->bits->height);

-  

-  XFree(ximage);

-  

-  ximage = XCreateImage(xnestDisplay, 

-			xnestDefaultVisual(pScreen),

-			1, XYBitmap, 0, 

-			(char *)pCursor->bits->mask,

-			pCursor->bits->width,

-			pCursor->bits->height,

-			BitmapPad(xnestDisplay), 0);

-  

-  XPutImage(xnestDisplay, mask, xnestBitmapGC, ximage,

-	    0, 0, 0, 0, pCursor->bits->width, pCursor->bits->height);

-  

-  XFree(ximage);

-  

-  fg_color.red = pCursor->foreRed;

-  fg_color.green = pCursor->foreGreen;

-  fg_color.blue = pCursor->foreBlue;

-  

-  bg_color.red = pCursor->backRed;

-  bg_color.green = pCursor->backGreen;

-  bg_color.blue = pCursor->backBlue;

-

-  xnestSetCursorPriv(pCursor, pScreen, malloc(sizeof(xnestPrivCursor)));

-  xnestCursor(pCursor, pScreen) = 

-    XCreatePixmapCursor(xnestDisplay, source, mask, &fg_color, &bg_color,

-			pCursor->bits->xhot, pCursor->bits->yhot);

-  

-  XFreePixmap(xnestDisplay, source);

-  XFreePixmap(xnestDisplay, mask);

-  

-  return True;

-}

-

-Bool

-xnestUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-  XFreeCursor(xnestDisplay, xnestCursor(pCursor, pScreen));

-  free(xnestGetCursorPriv(pCursor, pScreen));

-  return True;

-}

-

-void

-xnestRecolorCursor(ScreenPtr pScreen, CursorPtr pCursor, Bool displayed)

-{

-  XColor fg_color, bg_color;

-  

-  fg_color.red = pCursor->foreRed;

-  fg_color.green = pCursor->foreGreen;

-  fg_color.blue = pCursor->foreBlue;

-  

-  bg_color.red = pCursor->backRed;

-  bg_color.green = pCursor->backGreen;

-  bg_color.blue = pCursor->backBlue;

-  

-  XRecolorCursor(xnestDisplay, 

-		 xnestCursor(pCursor, pScreen),

-		 &fg_color, &bg_color);

-}

-

-void xnestSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)

-{

-    if (pCursor)

-    {

-	XDefineCursor(xnestDisplay, 

-		      xnestDefaultWindows[pScreen->myNum], 

-		      xnestCursor(pCursor, pScreen));

-    }

-}

-

-void

-xnestMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

-{

-}

-

-Bool

-xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    xnestCursorFuncPtr pScreenPriv;

-

-    pScreenPriv = (xnestCursorFuncPtr)

-            dixLookupPrivate(&pScreen->devPrivates, xnestCursorScreenKey);

-

-    return pScreenPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);

-}

-

-void

-xnestDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-    xnestCursorFuncPtr pScreenPriv;

-

-    pScreenPriv = (xnestCursorFuncPtr)

-            dixLookupPrivate(&pScreen->devPrivates, xnestCursorScreenKey);

-

-    pScreenPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "screenint.h"
+#include "input.h"
+#include "misc.h"
+#include "cursor.h"
+#include "cursorstr.h"
+#include "scrnintstr.h"
+#include "servermd.h"
+#include "mipointrst.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "Screen.h"
+#include "XNCursor.h"
+#include "Visual.h"
+#include "Keyboard.h"
+#include "Args.h"
+
+xnestCursorFuncRec xnestCursorFuncs = { NULL };
+
+Bool
+xnestRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+    XImage *ximage;
+    Pixmap source, mask;
+    XColor fg_color, bg_color;
+    unsigned long valuemask;
+    XGCValues values;
+
+    valuemask = GCFunction |
+        GCPlaneMask | GCForeground | GCBackground | GCClipMask;
+
+    values.function = GXcopy;
+    values.plane_mask = AllPlanes;
+    values.foreground = 1L;
+    values.background = 0L;
+    values.clip_mask = None;
+
+    XChangeGC(xnestDisplay, xnestBitmapGC, valuemask, &values);
+
+    source = XCreatePixmap(xnestDisplay,
+                           xnestDefaultWindows[pScreen->myNum],
+                           pCursor->bits->width, pCursor->bits->height, 1);
+
+    mask = XCreatePixmap(xnestDisplay,
+                         xnestDefaultWindows[pScreen->myNum],
+                         pCursor->bits->width, pCursor->bits->height, 1);
+
+    ximage = XCreateImage(xnestDisplay,
+                          xnestDefaultVisual(pScreen),
+                          1, XYBitmap, 0,
+                          (char *) pCursor->bits->source,
+                          pCursor->bits->width,
+                          pCursor->bits->height, BitmapPad(xnestDisplay), 0);
+
+    XPutImage(xnestDisplay, source, xnestBitmapGC, ximage,
+              0, 0, 0, 0, pCursor->bits->width, pCursor->bits->height);
+
+    XFree(ximage);
+
+    ximage = XCreateImage(xnestDisplay,
+                          xnestDefaultVisual(pScreen),
+                          1, XYBitmap, 0,
+                          (char *) pCursor->bits->mask,
+                          pCursor->bits->width,
+                          pCursor->bits->height, BitmapPad(xnestDisplay), 0);
+
+    XPutImage(xnestDisplay, mask, xnestBitmapGC, ximage,
+              0, 0, 0, 0, pCursor->bits->width, pCursor->bits->height);
+
+    XFree(ximage);
+
+    fg_color.red = pCursor->foreRed;
+    fg_color.green = pCursor->foreGreen;
+    fg_color.blue = pCursor->foreBlue;
+
+    bg_color.red = pCursor->backRed;
+    bg_color.green = pCursor->backGreen;
+    bg_color.blue = pCursor->backBlue;
+
+    xnestSetCursorPriv(pCursor, pScreen, malloc(sizeof(xnestPrivCursor)));
+    xnestCursor(pCursor, pScreen) =
+        XCreatePixmapCursor(xnestDisplay, source, mask, &fg_color, &bg_color,
+                            pCursor->bits->xhot, pCursor->bits->yhot);
+
+    XFreePixmap(xnestDisplay, source);
+    XFreePixmap(xnestDisplay, mask);
+
+    return True;
+}
+
+Bool
+xnestUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+    XFreeCursor(xnestDisplay, xnestCursor(pCursor, pScreen));
+    free(xnestGetCursorPriv(pCursor, pScreen));
+    return True;
+}
+
+void
+xnestRecolorCursor(ScreenPtr pScreen, CursorPtr pCursor, Bool displayed)
+{
+    XColor fg_color, bg_color;
+
+    fg_color.red = pCursor->foreRed;
+    fg_color.green = pCursor->foreGreen;
+    fg_color.blue = pCursor->foreBlue;
+
+    bg_color.red = pCursor->backRed;
+    bg_color.green = pCursor->backGreen;
+    bg_color.blue = pCursor->backBlue;
+
+    XRecolorCursor(xnestDisplay,
+                   xnestCursor(pCursor, pScreen), &fg_color, &bg_color);
+}
+
+void
+xnestSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x,
+               int y)
+{
+    if (pCursor) {
+        XDefineCursor(xnestDisplay,
+                      xnestDefaultWindows[pScreen->myNum],
+                      xnestCursor(pCursor, pScreen));
+    }
+}
+
+void
+xnestMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+{
+}
+
+Bool
+xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    xnestCursorFuncPtr pScreenPriv;
+
+    pScreenPriv = (xnestCursorFuncPtr)
+        dixLookupPrivate(&pScreen->devPrivates, xnestCursorScreenKey);
+
+    return pScreenPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
+}
+
+void
+xnestDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+    xnestCursorFuncPtr pScreenPriv;
+
+    pScreenPriv = (xnestCursorFuncPtr)
+        dixLookupPrivate(&pScreen->devPrivates, xnestCursorScreenKey);
+
+    pScreenPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);
+}
diff --git a/xorg-server/hw/xnest/Display.c b/xorg-server/hw/xnest/Display.c
index 3176b60d7..a2f8acbaa 100644
--- a/xorg-server/hw/xnest/Display.c
+++ b/xorg-server/hw/xnest/Display.c
@@ -12,7 +12,6 @@ is" without express or implied warranty.
 
 */
 
-
 #ifdef HAVE_XNEST_CONFIG_H
 #include <xnest-config.h>
 #endif
@@ -47,8 +46,8 @@ int *xnestDepths;
 int xnestNumDepths;
 XPixmapFormatValues *xnestPixmapFormats;
 int xnestNumPixmapFormats;
-Pixel xnestBlackPixel;             
-Pixel xnestWhitePixel;             
+Pixel xnestBlackPixel;
+Pixel xnestWhitePixel;
 Drawable xnestDefaultDrawables[MAXDEPTH + 1];
 Pixmap xnestIconBitmap;
 Pixmap xnestScreenSaverPixmap;
@@ -61,7 +60,8 @@ unsigned long xnestEventMask;
 #endif
 
 static int _X_NORETURN
-x_io_error_handler (Display *dpy) {
+x_io_error_handler(Display * dpy)
+{
     ErrorF("Lost connection to X server: %s\n", strerror(errno));
     CloseWellKnownConnections();
     OsCleanup(1);
@@ -71,141 +71,143 @@ x_io_error_handler (Display *dpy) {
 void
 xnestOpenDisplay(int argc, char *argv[])
 {
-  XVisualInfo vi;
-  long mask;
-  int i, j;
-
-  if (!xnestDoFullGeneration) return;
-
-  XSetIOErrorHandler(x_io_error_handler);
-
-  xnestCloseDisplay();
-
-  xnestDisplay = XOpenDisplay(xnestDisplayName);
-  if (xnestDisplay == NULL)
-    FatalError("Unable to open display \"%s\".\n", 
-	       XDisplayName(xnestDisplayName));
-
-  if (xnestSynchronize)
-    XSynchronize(xnestDisplay, True);
-
-  mask = VisualScreenMask;
-  vi.screen = DefaultScreen(xnestDisplay);
-  xnestVisuals = XGetVisualInfo(xnestDisplay, mask, &vi, &xnestNumVisuals);
-  if (xnestNumVisuals == 0 || xnestVisuals == NULL)
-    FatalError("Unable to find any visuals.\n");
-
-  if (xnestUserDefaultClass || xnestUserDefaultDepth) {
-    xnestDefaultVisualIndex = UNDEFINED;
-    for (i = 0; i < xnestNumVisuals; i++)
-      if ((!xnestUserDefaultClass ||
-	   xnestVisuals[i].class == xnestDefaultClass)
-	  &&
-	  (!xnestUserDefaultDepth ||
-	   xnestVisuals[i].depth == xnestDefaultDepth)) {
-	xnestDefaultVisualIndex = i;
-	break;
-      }
-    if (xnestDefaultVisualIndex == UNDEFINED) 
-      FatalError("Unable to find desired default visual.\n");
-  }
-  else {
-    vi.visualid = XVisualIDFromVisual(DefaultVisual(xnestDisplay, 
-				      DefaultScreen(xnestDisplay))); 
-    xnestDefaultVisualIndex = 0;
-    for (i = 0; i < xnestNumVisuals; i++)
-      if (vi.visualid == xnestVisuals[i].visualid)
-	xnestDefaultVisualIndex = i;
-  }
-  
-  xnestNumDefaultColormaps = xnestNumVisuals;
-  xnestDefaultColormaps = (Colormap *)malloc(xnestNumDefaultColormaps *
-					     sizeof(Colormap));
-  for (i = 0; i < xnestNumDefaultColormaps; i++)
-    xnestDefaultColormaps[i] = XCreateColormap(xnestDisplay,
-					       DefaultRootWindow(xnestDisplay),
-					       xnestVisuals[i].visual,
-					       AllocNone);
-  
-  xnestDepths = XListDepths(xnestDisplay, DefaultScreen(xnestDisplay),
-			    &xnestNumDepths);
-
-  xnestPixmapFormats = XListPixmapFormats(xnestDisplay, 
-					  &xnestNumPixmapFormats);
-  
-  xnestBlackPixel = BlackPixel(xnestDisplay, DefaultScreen(xnestDisplay));
-  xnestWhitePixel = WhitePixel(xnestDisplay, DefaultScreen(xnestDisplay));
-
-  if (xnestParentWindow != (Window) 0)
-    xnestEventMask = StructureNotifyMask;
-  else
-    xnestEventMask = 0L;
-  
-  for (i = 0; i <= MAXDEPTH; i++)
-    xnestDefaultDrawables[i] = None;
-  
-  for (i = 0; i < xnestNumPixmapFormats; i++)
-    for (j = 0; j < xnestNumDepths; j++)
-      if (xnestPixmapFormats[i].depth == 1 ||
-	  xnestPixmapFormats[i].depth == xnestDepths[j]) {
-	xnestDefaultDrawables[xnestPixmapFormats[i].depth] =
-	  XCreatePixmap(xnestDisplay, DefaultRootWindow(xnestDisplay), 
-			1, 1, xnestPixmapFormats[i].depth);
-      }
-  
-  xnestBitmapGC = XCreateGC(xnestDisplay, xnestDefaultDrawables[1], 0L, NULL);
-  
-  if (!(xnestUserGeometry & XValue))
-    xnestX = 0;
-  
-  if (!(xnestUserGeometry & YValue))
-    xnestY = 0;
-  
-  if (xnestParentWindow == 0) {
-    if (!(xnestUserGeometry & WidthValue))
-      xnestWidth = 3 * DisplayWidth(xnestDisplay, 
-				    DefaultScreen(xnestDisplay)) / 4;
-  
-    if (!(xnestUserGeometry & HeightValue))
-      xnestHeight = 3 * DisplayHeight(xnestDisplay, 
-				      DefaultScreen(xnestDisplay)) / 4;
-  }
-
-  if (!xnestUserBorderWidth)
-    xnestBorderWidth = 1;
-
-  xnestIconBitmap = 
-    XCreateBitmapFromData(xnestDisplay,
-			  DefaultRootWindow(xnestDisplay),
-			  (char *)icon_bits,
-			  icon_width,
-			  icon_height);
-  
-  xnestScreenSaverPixmap = 
-    XCreatePixmapFromBitmapData(xnestDisplay,
-				DefaultRootWindow(xnestDisplay),
-				(char *)screensaver_bits,
-				screensaver_width,
-				screensaver_height,
-				xnestWhitePixel,
-				xnestBlackPixel,
-				DefaultDepth(xnestDisplay,
-					     DefaultScreen(xnestDisplay)));
+    XVisualInfo vi;
+    long mask;
+    int i, j;
+
+    if (!xnestDoFullGeneration)
+        return;
+
+    XSetIOErrorHandler(x_io_error_handler);
+
+    xnestCloseDisplay();
+
+    xnestDisplay = XOpenDisplay(xnestDisplayName);
+    if (xnestDisplay == NULL)
+        FatalError("Unable to open display \"%s\".\n",
+                   XDisplayName(xnestDisplayName));
+
+    if (xnestSynchronize)
+        XSynchronize(xnestDisplay, True);
+
+    mask = VisualScreenMask;
+    vi.screen = DefaultScreen(xnestDisplay);
+    xnestVisuals = XGetVisualInfo(xnestDisplay, mask, &vi, &xnestNumVisuals);
+    if (xnestNumVisuals == 0 || xnestVisuals == NULL)
+        FatalError("Unable to find any visuals.\n");
+
+    if (xnestUserDefaultClass || xnestUserDefaultDepth) {
+        xnestDefaultVisualIndex = UNDEFINED;
+        for (i = 0; i < xnestNumVisuals; i++)
+            if ((!xnestUserDefaultClass ||
+                 xnestVisuals[i].class == xnestDefaultClass)
+                &&
+                (!xnestUserDefaultDepth ||
+                 xnestVisuals[i].depth == xnestDefaultDepth)) {
+                xnestDefaultVisualIndex = i;
+                break;
+            }
+        if (xnestDefaultVisualIndex == UNDEFINED)
+            FatalError("Unable to find desired default visual.\n");
+    }
+    else {
+        vi.visualid = XVisualIDFromVisual(DefaultVisual(xnestDisplay,
+                                                        DefaultScreen
+                                                        (xnestDisplay)));
+        xnestDefaultVisualIndex = 0;
+        for (i = 0; i < xnestNumVisuals; i++)
+            if (vi.visualid == xnestVisuals[i].visualid)
+                xnestDefaultVisualIndex = i;
+    }
+
+    xnestNumDefaultColormaps = xnestNumVisuals;
+    xnestDefaultColormaps = (Colormap *) malloc(xnestNumDefaultColormaps *
+                                                sizeof(Colormap));
+    for (i = 0; i < xnestNumDefaultColormaps; i++)
+        xnestDefaultColormaps[i] = XCreateColormap(xnestDisplay,
+                                                   DefaultRootWindow
+                                                   (xnestDisplay),
+                                                   xnestVisuals[i].visual,
+                                                   AllocNone);
+
+    xnestDepths = XListDepths(xnestDisplay, DefaultScreen(xnestDisplay),
+                              &xnestNumDepths);
+
+    xnestPixmapFormats = XListPixmapFormats(xnestDisplay,
+                                            &xnestNumPixmapFormats);
+
+    xnestBlackPixel = BlackPixel(xnestDisplay, DefaultScreen(xnestDisplay));
+    xnestWhitePixel = WhitePixel(xnestDisplay, DefaultScreen(xnestDisplay));
+
+    if (xnestParentWindow != (Window) 0)
+        xnestEventMask = StructureNotifyMask;
+    else
+        xnestEventMask = 0L;
+
+    for (i = 0; i <= MAXDEPTH; i++)
+        xnestDefaultDrawables[i] = None;
+
+    for (i = 0; i < xnestNumPixmapFormats; i++)
+        for (j = 0; j < xnestNumDepths; j++)
+            if (xnestPixmapFormats[i].depth == 1 ||
+                xnestPixmapFormats[i].depth == xnestDepths[j]) {
+                xnestDefaultDrawables[xnestPixmapFormats[i].depth] =
+                    XCreatePixmap(xnestDisplay, DefaultRootWindow(xnestDisplay),
+                                  1, 1, xnestPixmapFormats[i].depth);
+            }
+
+    xnestBitmapGC = XCreateGC(xnestDisplay, xnestDefaultDrawables[1], 0L, NULL);
+
+    if (!(xnestUserGeometry & XValue))
+        xnestX = 0;
+
+    if (!(xnestUserGeometry & YValue))
+        xnestY = 0;
+
+    if (xnestParentWindow == 0) {
+        if (!(xnestUserGeometry & WidthValue))
+            xnestWidth = 3 * DisplayWidth(xnestDisplay,
+                                          DefaultScreen(xnestDisplay)) / 4;
+
+        if (!(xnestUserGeometry & HeightValue))
+            xnestHeight = 3 * DisplayHeight(xnestDisplay,
+                                            DefaultScreen(xnestDisplay)) / 4;
+    }
+
+    if (!xnestUserBorderWidth)
+        xnestBorderWidth = 1;
+
+    xnestIconBitmap =
+        XCreateBitmapFromData(xnestDisplay,
+                              DefaultRootWindow(xnestDisplay),
+                              (char *) icon_bits, icon_width, icon_height);
+
+    xnestScreenSaverPixmap =
+        XCreatePixmapFromBitmapData(xnestDisplay,
+                                    DefaultRootWindow(xnestDisplay),
+                                    (char *) screensaver_bits,
+                                    screensaver_width,
+                                    screensaver_height,
+                                    xnestWhitePixel,
+                                    xnestBlackPixel,
+                                    DefaultDepth(xnestDisplay,
+                                                 DefaultScreen(xnestDisplay)));
 }
 
 void
 xnestCloseDisplay(void)
 {
-  if (!xnestDoFullGeneration || !xnestDisplay) return;
-
-  /*
-    If xnestDoFullGeneration all x resources will be destroyed upon closing
-    the display connection.  There is no need to generate extra protocol.
-    */
-
-  free(xnestDefaultColormaps);
-  XFree(xnestVisuals);
-  XFree(xnestDepths);
-  XFree(xnestPixmapFormats);
-  XCloseDisplay(xnestDisplay);
+    if (!xnestDoFullGeneration || !xnestDisplay)
+        return;
+
+    /*
+       If xnestDoFullGeneration all x resources will be destroyed upon closing
+       the display connection.  There is no need to generate extra protocol.
+     */
+
+    free(xnestDefaultColormaps);
+    XFree(xnestVisuals);
+    XFree(xnestDepths);
+    XFree(xnestPixmapFormats);
+    XCloseDisplay(xnestDisplay);
 }
diff --git a/xorg-server/hw/xnest/Events.c b/xorg-server/hw/xnest/Events.c
index 619427ded..447d5a72b 100644
--- a/xorg-server/hw/xnest/Events.c
+++ b/xorg-server/hw/xnest/Events.c
@@ -46,7 +46,7 @@ CARD32 lastEventTime = 0;
 void
 ProcessInputEvents(void)
 {
-  mieqProcessInputEvents();
+    mieqProcessInputEvents();
 }
 
 int
@@ -60,158 +60,159 @@ TimeSinceLastInputEvent(void)
 void
 SetTimeSinceLastInputEvent(void)
 {
-  lastEventTime = GetTimeInMillis();
+    lastEventTime = GetTimeInMillis();
 }
 
 static Bool
-xnestExposurePredicate(Display *display, XEvent *event, char *args)
+xnestExposurePredicate(Display * display, XEvent * event, char *args)
 {
-  return event->type == Expose || event->type == ProcessedExpose;
+    return event->type == Expose || event->type == ProcessedExpose;
 }
 
 static Bool
-xnestNotExposurePredicate(Display *display, XEvent *event, char *args)
+xnestNotExposurePredicate(Display * display, XEvent * event, char *args)
 {
-  return !xnestExposurePredicate(display, event, args);
+    return !xnestExposurePredicate(display, event, args);
 }
 
 void
 xnestCollectExposures(void)
 {
-  XEvent X;
-  WindowPtr pWin;
-  RegionRec Rgn;
-  BoxRec Box;
-  
-  while (XCheckIfEvent(xnestDisplay, &X, xnestExposurePredicate, NULL)) {
-    pWin = xnestWindowPtr(X.xexpose.window);
-    
-    if (pWin && X.xexpose.width && X.xexpose.height) {
-      Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + X.xexpose.x;
-      Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + X.xexpose.y;
-      Box.x2 = Box.x1 + X.xexpose.width;
-      Box.y2 = Box.y1 + X.xexpose.height;
-      
-      RegionInit(&Rgn, &Box, 1);
-      
-      miSendExposures(pWin, &Rgn, Box.x2, Box.y2);
+    XEvent X;
+    WindowPtr pWin;
+    RegionRec Rgn;
+    BoxRec Box;
+
+    while (XCheckIfEvent(xnestDisplay, &X, xnestExposurePredicate, NULL)) {
+        pWin = xnestWindowPtr(X.xexpose.window);
+
+        if (pWin && X.xexpose.width && X.xexpose.height) {
+            Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + X.xexpose.x;
+            Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + X.xexpose.y;
+            Box.x2 = Box.x1 + X.xexpose.width;
+            Box.y2 = Box.y1 + X.xexpose.height;
+
+            RegionInit(&Rgn, &Box, 1);
+
+            miSendExposures(pWin, &Rgn, Box.x2, Box.y2);
+        }
     }
-  }
 }
 
 void
 xnestQueueKeyEvent(int type, unsigned int keycode)
 {
-  lastEventTime = GetTimeInMillis();
-  QueueKeyboardEvents(xnestKeyboardDevice, type, keycode, NULL);
+    lastEventTime = GetTimeInMillis();
+    QueueKeyboardEvents(xnestKeyboardDevice, type, keycode, NULL);
 }
 
 void
 xnestCollectEvents(void)
 {
-  XEvent X;
-  int valuators[2];
-  ValuatorMask mask;
-  ScreenPtr pScreen;
-
-  while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {
-    switch (X.type) {
-    case KeyPress:
-      xnestUpdateModifierState(X.xkey.state);
-      xnestQueueKeyEvent(KeyPress, X.xkey.keycode);
-      break;
-      
-    case KeyRelease:
-      xnestUpdateModifierState(X.xkey.state);
-      xnestQueueKeyEvent(KeyRelease, X.xkey.keycode);
-      break;
-      
-    case ButtonPress:
-      valuator_mask_set_range(&mask, 0, 0, NULL);
-      xnestUpdateModifierState(X.xkey.state);
-      lastEventTime = GetTimeInMillis();
-      QueuePointerEvents(xnestPointerDevice, ButtonPress,
-                         X.xbutton.button, POINTER_RELATIVE, &mask);
-      break;
-      
-    case ButtonRelease:
-      valuator_mask_set_range(&mask, 0, 0, NULL);
-      xnestUpdateModifierState(X.xkey.state);
-      lastEventTime = GetTimeInMillis();
-      QueuePointerEvents(xnestPointerDevice, ButtonRelease,
-                         X.xbutton.button, POINTER_RELATIVE, &mask);
-      break;
-      
-    case MotionNotify:
-      valuators[0] = X.xmotion.x;
-      valuators[1] = X.xmotion.y;
-      valuator_mask_set_range(&mask, 0, 2, valuators);
-      lastEventTime = GetTimeInMillis();
-      QueuePointerEvents(xnestPointerDevice, MotionNotify,
-                         0, POINTER_ABSOLUTE, &mask);
-      break;
-      
-    case FocusIn:
-      if (X.xfocus.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xfocus.window);
-	if (pScreen)
-	  xnestDirectInstallColormaps(pScreen);
-      }
-      break;
-   
-    case FocusOut:
-      if (X.xfocus.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xfocus.window);
-	if (pScreen)
-	  xnestDirectUninstallColormaps(pScreen);
-      }
-      break;
-
-    case KeymapNotify:
-      break;
-
-    case EnterNotify:
-      if (X.xcrossing.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xcrossing.window);
-	if (pScreen) {
-	  NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x, X.xcrossing.y);
-          valuators[0] = X.xcrossing.x;
-          valuators[1] = X.xcrossing.y;
-          valuator_mask_set_range(&mask, 0, 2, valuators);
-          lastEventTime = GetTimeInMillis();
-          QueuePointerEvents(xnestPointerDevice, MotionNotify,
-                             0, POINTER_ABSOLUTE, &mask);
-	  xnestDirectInstallColormaps(pScreen);
-	}
-      }
-      break;
-      
-    case LeaveNotify:
-      if (X.xcrossing.detail != NotifyInferior) {
-	pScreen = xnestScreen(X.xcrossing.window);
-	if (pScreen) {
-	  xnestDirectUninstallColormaps(pScreen);
-	}	
-      }
-      break;
-      
-    case DestroyNotify:
-      if (xnestParentWindow != (Window) 0 &&
-	  X.xdestroywindow.window == xnestParentWindow)
-	exit (0);
-      break;
-
-    case CirculateNotify:
-    case ConfigureNotify:
-    case GravityNotify:
-    case MapNotify:
-    case ReparentNotify:
-    case UnmapNotify:
-      break;
-      
-    default:
-      ErrorF("xnest warning: unhandled event\n");
-      break;
+    XEvent X;
+    int valuators[2];
+    ValuatorMask mask;
+    ScreenPtr pScreen;
+
+    while (XCheckIfEvent(xnestDisplay, &X, xnestNotExposurePredicate, NULL)) {
+        switch (X.type) {
+        case KeyPress:
+            xnestUpdateModifierState(X.xkey.state);
+            xnestQueueKeyEvent(KeyPress, X.xkey.keycode);
+            break;
+
+        case KeyRelease:
+            xnestUpdateModifierState(X.xkey.state);
+            xnestQueueKeyEvent(KeyRelease, X.xkey.keycode);
+            break;
+
+        case ButtonPress:
+            valuator_mask_set_range(&mask, 0, 0, NULL);
+            xnestUpdateModifierState(X.xkey.state);
+            lastEventTime = GetTimeInMillis();
+            QueuePointerEvents(xnestPointerDevice, ButtonPress,
+                               X.xbutton.button, POINTER_RELATIVE, &mask);
+            break;
+
+        case ButtonRelease:
+            valuator_mask_set_range(&mask, 0, 0, NULL);
+            xnestUpdateModifierState(X.xkey.state);
+            lastEventTime = GetTimeInMillis();
+            QueuePointerEvents(xnestPointerDevice, ButtonRelease,
+                               X.xbutton.button, POINTER_RELATIVE, &mask);
+            break;
+
+        case MotionNotify:
+            valuators[0] = X.xmotion.x;
+            valuators[1] = X.xmotion.y;
+            valuator_mask_set_range(&mask, 0, 2, valuators);
+            lastEventTime = GetTimeInMillis();
+            QueuePointerEvents(xnestPointerDevice, MotionNotify,
+                               0, POINTER_ABSOLUTE, &mask);
+            break;
+
+        case FocusIn:
+            if (X.xfocus.detail != NotifyInferior) {
+                pScreen = xnestScreen(X.xfocus.window);
+                if (pScreen)
+                    xnestDirectInstallColormaps(pScreen);
+            }
+            break;
+
+        case FocusOut:
+            if (X.xfocus.detail != NotifyInferior) {
+                pScreen = xnestScreen(X.xfocus.window);
+                if (pScreen)
+                    xnestDirectUninstallColormaps(pScreen);
+            }
+            break;
+
+        case KeymapNotify:
+            break;
+
+        case EnterNotify:
+            if (X.xcrossing.detail != NotifyInferior) {
+                pScreen = xnestScreen(X.xcrossing.window);
+                if (pScreen) {
+                    NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x,
+                                     X.xcrossing.y);
+                    valuators[0] = X.xcrossing.x;
+                    valuators[1] = X.xcrossing.y;
+                    valuator_mask_set_range(&mask, 0, 2, valuators);
+                    lastEventTime = GetTimeInMillis();
+                    QueuePointerEvents(xnestPointerDevice, MotionNotify,
+                                       0, POINTER_ABSOLUTE, &mask);
+                    xnestDirectInstallColormaps(pScreen);
+                }
+            }
+            break;
+
+        case LeaveNotify:
+            if (X.xcrossing.detail != NotifyInferior) {
+                pScreen = xnestScreen(X.xcrossing.window);
+                if (pScreen) {
+                    xnestDirectUninstallColormaps(pScreen);
+                }
+            }
+            break;
+
+        case DestroyNotify:
+            if (xnestParentWindow != (Window) 0 &&
+                X.xdestroywindow.window == xnestParentWindow)
+                exit(0);
+            break;
+
+        case CirculateNotify:
+        case ConfigureNotify:
+        case GravityNotify:
+        case MapNotify:
+        case ReparentNotify:
+        case UnmapNotify:
+            break;
+
+        default:
+            ErrorF("xnest warning: unhandled event\n");
+            break;
+        }
     }
-  }
 }
diff --git a/xorg-server/hw/xnest/Font.c b/xorg-server/hw/xnest/Font.c
index 87e622680..1e95588ef 100644
--- a/xorg-server/hw/xnest/Font.c
+++ b/xorg-server/hw/xnest/Font.c
@@ -1,86 +1,88 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xatom.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "regionstr.h"

-#include <X11/fonts/font.h>

-#include <X11/fonts/fontstruct.h>

-#include "scrnintstr.h"

-

-#include "Xnest.h"

-

-#include "Display.h"

-#include "XNFont.h"

-

-int xnestFontPrivateIndex;

-

-Bool

-xnestRealizeFont(ScreenPtr pScreen, FontPtr pFont)

-{

-  pointer priv;

-  Atom name_atom, value_atom;

-  int nprops;

-  FontPropPtr props;

-  int i;

-  const char *name;

-

-  FontSetPrivate(pFont, xnestFontPrivateIndex, NULL);

-

-  name_atom = MakeAtom("FONT", 4, True);

-  value_atom = 0L;

-

-  nprops = pFont->info.nprops;

-  props = pFont->info.props;

-

-  for (i = 0; i < nprops; i++)

-    if (props[i].name == name_atom) {

-      value_atom = props[i].value;

-      break;

-    }

-

-  if (!value_atom) return False;

-

-  name = NameForAtom(value_atom);

-

-  if (!name) return False;

-

-  priv = (pointer)malloc(sizeof(xnestPrivFont));

-  FontSetPrivate(pFont, xnestFontPrivateIndex, priv);

-  

-  xnestFontPriv(pFont)->font_struct = XLoadQueryFont(xnestDisplay, name);

-

-  if (!xnestFontStruct(pFont)) return False;

-						     

-  return True;

-}

-

-

-Bool

-xnestUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)

-{

-  if (xnestFontPriv(pFont)) {

-    if (xnestFontStruct(pFont)) 

-      XFreeFont(xnestDisplay, xnestFontStruct(pFont));

-    free(xnestFontPriv(pFont));

-    FontSetPrivate(pFont, xnestFontPrivateIndex, NULL);

-  }

-  return True;

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xatom.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "regionstr.h"
+#include <X11/fonts/font.h>
+#include <X11/fonts/fontstruct.h>
+#include "scrnintstr.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "XNFont.h"
+
+int xnestFontPrivateIndex;
+
+Bool
+xnestRealizeFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    pointer priv;
+    Atom name_atom, value_atom;
+    int nprops;
+    FontPropPtr props;
+    int i;
+    const char *name;
+
+    FontSetPrivate(pFont, xnestFontPrivateIndex, NULL);
+
+    name_atom = MakeAtom("FONT", 4, True);
+    value_atom = 0L;
+
+    nprops = pFont->info.nprops;
+    props = pFont->info.props;
+
+    for (i = 0; i < nprops; i++)
+        if (props[i].name == name_atom) {
+            value_atom = props[i].value;
+            break;
+        }
+
+    if (!value_atom)
+        return False;
+
+    name = NameForAtom(value_atom);
+
+    if (!name)
+        return False;
+
+    priv = (pointer) malloc(sizeof(xnestPrivFont));
+    FontSetPrivate(pFont, xnestFontPrivateIndex, priv);
+
+    xnestFontPriv(pFont)->font_struct = XLoadQueryFont(xnestDisplay, name);
+
+    if (!xnestFontStruct(pFont))
+        return False;
+
+    return True;
+}
+
+Bool
+xnestUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    if (xnestFontPriv(pFont)) {
+        if (xnestFontStruct(pFont))
+            XFreeFont(xnestDisplay, xnestFontStruct(pFont));
+        free(xnestFontPriv(pFont));
+        FontSetPrivate(pFont, xnestFontPrivateIndex, NULL);
+    }
+    return True;
+}
diff --git a/xorg-server/hw/xnest/GC.c b/xorg-server/hw/xnest/GC.c
index 48fe4dcbc..cfaf71475 100644
--- a/xorg-server/hw/xnest/GC.c
+++ b/xorg-server/hw/xnest/GC.c
@@ -29,7 +29,7 @@ is" without express or implied warranty.
 #include "Xnest.h"
 
 #include "Display.h"
-#include "XNGC.h" 
+#include "XNGC.h"
 #include "GCOps.h"
 #include "Drawable.h"
 #include "XNFont.h"
@@ -38,51 +38,51 @@ is" without express or implied warranty.
 DevPrivateKeyRec xnestGCPrivateKeyRec;
 
 static GCFuncs xnestFuncs = {
-  xnestValidateGC,
-  xnestChangeGC,
-  xnestCopyGC,
-  xnestDestroyGC,
-  xnestChangeClip,
-  xnestDestroyClip,
-  xnestCopyClip,
+    xnestValidateGC,
+    xnestChangeGC,
+    xnestCopyGC,
+    xnestDestroyGC,
+    xnestChangeClip,
+    xnestDestroyClip,
+    xnestCopyClip,
 };
 
 static GCOps xnestOps = {
-  xnestFillSpans,
-  xnestSetSpans,
-  xnestPutImage,
-  xnestCopyArea, 
-  xnestCopyPlane,
-  xnestPolyPoint,
-  xnestPolylines,
-  xnestPolySegment,
-  xnestPolyRectangle,
-  xnestPolyArc,
-  xnestFillPolygon,
-  xnestPolyFillRect,
-  xnestPolyFillArc,
-  xnestPolyText8, 
-  xnestPolyText16,
-  xnestImageText8,
-  xnestImageText16,
-  xnestImageGlyphBlt,
-  xnestPolyGlyphBlt,
-  xnestPushPixels
+    xnestFillSpans,
+    xnestSetSpans,
+    xnestPutImage,
+    xnestCopyArea,
+    xnestCopyPlane,
+    xnestPolyPoint,
+    xnestPolylines,
+    xnestPolySegment,
+    xnestPolyRectangle,
+    xnestPolyArc,
+    xnestFillPolygon,
+    xnestPolyFillRect,
+    xnestPolyFillArc,
+    xnestPolyText8,
+    xnestPolyText16,
+    xnestImageText8,
+    xnestImageText16,
+    xnestImageGlyphBlt,
+    xnestPolyGlyphBlt,
+    xnestPushPixels
 };
 
 Bool
 xnestCreateGC(GCPtr pGC)
 {
-  pGC->funcs = &xnestFuncs;
-  pGC->ops = &xnestOps;
-  
-  pGC->miTranslate = 1;
-   
-  xnestGCPriv(pGC)->gc = XCreateGC(xnestDisplay, 
-				   xnestDefaultDrawables[pGC->depth], 
-				   0L, NULL);
-
-  return True;
+    pGC->funcs = &xnestFuncs;
+    pGC->ops = &xnestOps;
+
+    pGC->miTranslate = 1;
+
+    xnestGCPriv(pGC)->gc = XCreateGC(xnestDisplay,
+                                     xnestDefaultDrawables[pGC->depth],
+                                     0L, NULL);
+
+    return True;
 }
 
 void
@@ -93,238 +93,236 @@ xnestValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
 void
 xnestChangeGC(GCPtr pGC, unsigned long mask)
 {
-  XGCValues values;
-  
-  if (mask & GCFunction)
-    values.function = pGC->alu;
-  
-  if (mask & GCPlaneMask)
-    values.plane_mask = pGC->planemask;
-  
-  if (mask & GCForeground)
-    values.foreground = xnestPixel(pGC->fgPixel);
-  
-  if (mask & GCBackground)
-    values.background = xnestPixel(pGC->bgPixel);
-
-  if (mask & GCLineWidth)
-    values.line_width = pGC->lineWidth;
-    
-  if (mask & GCLineStyle)
-    values.line_style = pGC->lineStyle;
-
-  if (mask & GCCapStyle)
-    values.cap_style = pGC->capStyle;
-
-  if (mask & GCJoinStyle)
-    values.join_style = pGC->joinStyle;
-
-  if (mask & GCFillStyle)
-    values.fill_style = pGC->fillStyle;
-
-  if (mask & GCFillRule)
-    values.fill_rule = pGC->fillRule;
-  
-  if (mask & GCTile) {
-    if (pGC->tileIsPixel)
-      mask &= ~GCTile;
-    else
-      values.tile = xnestPixmap(pGC->tile.pixmap);
-  }
-
-  if (mask & GCStipple)
-    values.stipple = xnestPixmap(pGC->stipple);
-
-  if (mask & GCTileStipXOrigin)
-    values.ts_x_origin = pGC->patOrg.x;
-
-  if (mask & GCTileStipYOrigin)
-    values.ts_y_origin = pGC->patOrg.y;
-
-  if (mask & GCFont)
-    values.font = xnestFont(pGC->font);
-
-  if (mask & GCSubwindowMode)
-    values.subwindow_mode = pGC->subWindowMode;
-
-  if (mask & GCGraphicsExposures)
-    values.graphics_exposures = pGC->graphicsExposures;
-
-  if (mask & GCClipXOrigin)
-    values.clip_x_origin = pGC->clipOrg.x;
-
-  if (mask & GCClipYOrigin)
-    values.clip_y_origin = pGC->clipOrg.y;
-
-  if (mask & GCClipMask) /* this is handled in change clip */
-    mask &= ~GCClipMask;
-
-  if (mask & GCDashOffset)
-    values.dash_offset = pGC->dashOffset;
-
-  if (mask & GCDashList) {
-    mask &= ~GCDashList;
-    XSetDashes(xnestDisplay, xnestGC(pGC), 
-	       pGC->dashOffset, (char *)pGC->dash, pGC->numInDashList);
-  }
-
-  if (mask & GCArcMode)
-    values.arc_mode = pGC->arcMode;
-
-  if (mask)
-    XChangeGC(xnestDisplay, xnestGC(pGC), mask, &values);
+    XGCValues values;
+
+    if (mask & GCFunction)
+        values.function = pGC->alu;
+
+    if (mask & GCPlaneMask)
+        values.plane_mask = pGC->planemask;
+
+    if (mask & GCForeground)
+        values.foreground = xnestPixel(pGC->fgPixel);
+
+    if (mask & GCBackground)
+        values.background = xnestPixel(pGC->bgPixel);
+
+    if (mask & GCLineWidth)
+        values.line_width = pGC->lineWidth;
+
+    if (mask & GCLineStyle)
+        values.line_style = pGC->lineStyle;
+
+    if (mask & GCCapStyle)
+        values.cap_style = pGC->capStyle;
+
+    if (mask & GCJoinStyle)
+        values.join_style = pGC->joinStyle;
+
+    if (mask & GCFillStyle)
+        values.fill_style = pGC->fillStyle;
+
+    if (mask & GCFillRule)
+        values.fill_rule = pGC->fillRule;
+
+    if (mask & GCTile) {
+        if (pGC->tileIsPixel)
+            mask &= ~GCTile;
+        else
+            values.tile = xnestPixmap(pGC->tile.pixmap);
+    }
+
+    if (mask & GCStipple)
+        values.stipple = xnestPixmap(pGC->stipple);
+
+    if (mask & GCTileStipXOrigin)
+        values.ts_x_origin = pGC->patOrg.x;
+
+    if (mask & GCTileStipYOrigin)
+        values.ts_y_origin = pGC->patOrg.y;
+
+    if (mask & GCFont)
+        values.font = xnestFont(pGC->font);
+
+    if (mask & GCSubwindowMode)
+        values.subwindow_mode = pGC->subWindowMode;
+
+    if (mask & GCGraphicsExposures)
+        values.graphics_exposures = pGC->graphicsExposures;
+
+    if (mask & GCClipXOrigin)
+        values.clip_x_origin = pGC->clipOrg.x;
+
+    if (mask & GCClipYOrigin)
+        values.clip_y_origin = pGC->clipOrg.y;
+
+    if (mask & GCClipMask)      /* this is handled in change clip */
+        mask &= ~GCClipMask;
+
+    if (mask & GCDashOffset)
+        values.dash_offset = pGC->dashOffset;
+
+    if (mask & GCDashList) {
+        mask &= ~GCDashList;
+        XSetDashes(xnestDisplay, xnestGC(pGC),
+                   pGC->dashOffset, (char *) pGC->dash, pGC->numInDashList);
+    }
+
+    if (mask & GCArcMode)
+        values.arc_mode = pGC->arcMode;
+
+    if (mask)
+        XChangeGC(xnestDisplay, xnestGC(pGC), mask, &values);
 }
 
 void
 xnestCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
 {
-  XCopyGC(xnestDisplay, xnestGC(pGCSrc), mask, xnestGC(pGCDst));
+    XCopyGC(xnestDisplay, xnestGC(pGCSrc), mask, xnestGC(pGCDst));
 }
 
 void
 xnestDestroyGC(GCPtr pGC)
 {
-  XFreeGC(xnestDisplay, xnestGC(pGC));
+    XFreeGC(xnestDisplay, xnestGC(pGC));
 }
 
 void
 xnestChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
 {
-  int i, size;
-  BoxPtr pBox;
-  XRectangle *pRects;
+    int i, size;
+    BoxPtr pBox;
+    XRectangle *pRects;
 
-  xnestDestroyClipHelper(pGC);
+    xnestDestroyClipHelper(pGC);
 
-  switch(type) 
-    {
+    switch (type) {
     case CT_NONE:
-      XSetClipMask(xnestDisplay, xnestGC(pGC), None);
-      break;
-      
+        XSetClipMask(xnestDisplay, xnestGC(pGC), None);
+        break;
+
     case CT_REGION:
-      nRects = RegionNumRects((RegionPtr)pValue);
-      size = nRects * sizeof(*pRects);
-      pRects = (XRectangle *) malloc(size);
-      pBox = RegionRects((RegionPtr)pValue);
-      for (i = nRects; i-- > 0; ) {
-	pRects[i].x = pBox[i].x1;
-	pRects[i].y = pBox[i].y1;
-	pRects[i].width = pBox[i].x2 - pBox[i].x1;
-	pRects[i].height = pBox[i].y2 - pBox[i].y1;
-      }
-      XSetClipRectangles(xnestDisplay, xnestGC(pGC), 0, 0,
-			 pRects, nRects, Unsorted);
-      free((char *) pRects);
-      break;
+        nRects = RegionNumRects((RegionPtr) pValue);
+        size = nRects * sizeof(*pRects);
+        pRects = (XRectangle *) malloc(size);
+        pBox = RegionRects((RegionPtr) pValue);
+        for (i = nRects; i-- > 0;) {
+            pRects[i].x = pBox[i].x1;
+            pRects[i].y = pBox[i].y1;
+            pRects[i].width = pBox[i].x2 - pBox[i].x1;
+            pRects[i].height = pBox[i].y2 - pBox[i].y1;
+        }
+        XSetClipRectangles(xnestDisplay, xnestGC(pGC), 0, 0,
+                           pRects, nRects, Unsorted);
+        free((char *) pRects);
+        break;
 
     case CT_PIXMAP:
-      XSetClipMask(xnestDisplay, xnestGC(pGC), 
-		   xnestPixmap((PixmapPtr)pValue));
-      /*
-       * Need to change into region, so subsequent uses are with
-       * current pixmap contents.
-       */
-      pGC->clientClip = (pointer) (*pGC->pScreen->BitmapToRegion)((PixmapPtr)pValue);
-      (*pGC->pScreen->DestroyPixmap)((PixmapPtr)pValue);
-      pValue = pGC->clientClip;
-      type = CT_REGION;
-      break;
+        XSetClipMask(xnestDisplay, xnestGC(pGC),
+                     xnestPixmap((PixmapPtr) pValue));
+        /*
+         * Need to change into region, so subsequent uses are with
+         * current pixmap contents.
+         */
+        pGC->clientClip =
+            (pointer) (*pGC->pScreen->BitmapToRegion) ((PixmapPtr) pValue);
+        (*pGC->pScreen->DestroyPixmap) ((PixmapPtr) pValue);
+        pValue = pGC->clientClip;
+        type = CT_REGION;
+        break;
 
     case CT_UNSORTED:
-      XSetClipRectangles(xnestDisplay, xnestGC(pGC), 
-			 pGC->clipOrg.x, pGC->clipOrg.y,
-			 (XRectangle *)pValue, nRects, Unsorted);
-      break;
+        XSetClipRectangles(xnestDisplay, xnestGC(pGC),
+                           pGC->clipOrg.x, pGC->clipOrg.y,
+                           (XRectangle *) pValue, nRects, Unsorted);
+        break;
 
     case CT_YSORTED:
-      XSetClipRectangles(xnestDisplay, xnestGC(pGC), 
-			 pGC->clipOrg.x, pGC->clipOrg.y,
-			 (XRectangle *)pValue, nRects, YSorted);
-      break;
+        XSetClipRectangles(xnestDisplay, xnestGC(pGC),
+                           pGC->clipOrg.x, pGC->clipOrg.y,
+                           (XRectangle *) pValue, nRects, YSorted);
+        break;
 
     case CT_YXSORTED:
-      XSetClipRectangles(xnestDisplay, xnestGC(pGC), 
-			 pGC->clipOrg.x, pGC->clipOrg.y,
-			 (XRectangle *)pValue, nRects, YXSorted);
-      break;
+        XSetClipRectangles(xnestDisplay, xnestGC(pGC),
+                           pGC->clipOrg.x, pGC->clipOrg.y,
+                           (XRectangle *) pValue, nRects, YXSorted);
+        break;
 
     case CT_YXBANDED:
-      XSetClipRectangles(xnestDisplay, xnestGC(pGC), 
-			 pGC->clipOrg.x, pGC->clipOrg.y,
-			 (XRectangle *)pValue, nRects, YXBanded);
-      break;
+        XSetClipRectangles(xnestDisplay, xnestGC(pGC),
+                           pGC->clipOrg.x, pGC->clipOrg.y,
+                           (XRectangle *) pValue, nRects, YXBanded);
+        break;
     }
 
-  switch(type) 
-    {
+    switch (type) {
     default:
-      break;
+        break;
 
     case CT_UNSORTED:
     case CT_YSORTED:
     case CT_YXSORTED:
     case CT_YXBANDED:
-      
-      /*
-       * other parts of server can only deal with CT_NONE,
-       * CT_PIXMAP and CT_REGION client clips.
-       */
-      pGC->clientClip = (pointer) RegionFromRects(nRects,
-						  (xRectangle *)pValue, type);
-      free(pValue);
-      pValue = pGC->clientClip;
-      type = CT_REGION;
-
-      break;
+
+        /*
+         * other parts of server can only deal with CT_NONE,
+         * CT_PIXMAP and CT_REGION client clips.
+         */
+        pGC->clientClip = (pointer) RegionFromRects(nRects,
+                                                    (xRectangle *) pValue,
+                                                    type);
+        free(pValue);
+        pValue = pGC->clientClip;
+        type = CT_REGION;
+
+        break;
     }
 
-  pGC->clientClipType = type;
-  pGC->clientClip = pValue;
+    pGC->clientClipType = type;
+    pGC->clientClip = pValue;
 }
 
 void
 xnestDestroyClip(GCPtr pGC)
 {
-  xnestDestroyClipHelper(pGC);
+    xnestDestroyClipHelper(pGC);
 
-  XSetClipMask(xnestDisplay, xnestGC(pGC), None);
- 
-  pGC->clientClipType = CT_NONE;
-  pGC->clientClip = NULL;
+    XSetClipMask(xnestDisplay, xnestGC(pGC), None);
+
+    pGC->clientClipType = CT_NONE;
+    pGC->clientClip = NULL;
 }
 
 void
 xnestDestroyClipHelper(GCPtr pGC)
 {
-  switch (pGC->clientClipType)
-    {
+    switch (pGC->clientClipType) {
     default:
     case CT_NONE:
-      break;
-      
+        break;
+
     case CT_REGION:
-      RegionDestroy(pGC->clientClip);
-      break;
+        RegionDestroy(pGC->clientClip);
+        break;
     }
 }
 
 void
 xnestCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
 {
-  RegionPtr pRgn;
+    RegionPtr pRgn;
 
-  switch (pGCSrc->clientClipType)
-    {
+    switch (pGCSrc->clientClipType) {
     default:
     case CT_NONE:
-      xnestDestroyClip(pGCDst);
-      break;
+        xnestDestroyClip(pGCDst);
+        break;
 
     case CT_REGION:
-      pRgn = RegionCreate(NULL, 1);
-      RegionCopy(pRgn, pGCSrc->clientClip);
-      xnestChangeClip(pGCDst, CT_REGION, pRgn, 0);
-      break;
+        pRgn = RegionCreate(NULL, 1);
+        RegionCopy(pRgn, pGCSrc->clientClip);
+        xnestChangeClip(pGCDst, CT_REGION, pRgn, 0);
+        break;
     }
 }
diff --git a/xorg-server/hw/xnest/GCOps.c b/xorg-server/hw/xnest/GCOps.c
index d19ec6710..e26a1363b 100644
--- a/xorg-server/hw/xnest/GCOps.c
+++ b/xorg-server/hw/xnest/GCOps.c
@@ -1,327 +1,326 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "regionstr.h"

-#include <X11/fonts/fontstruct.h>

-#include "gcstruct.h"

-#include "scrnintstr.h"

-#include "windowstr.h"

-#include "pixmapstr.h"

-#include "region.h"

-#include "servermd.h"

-

-#include "Xnest.h"

-

-#include "Display.h"

-#include "Screen.h"

-#include "XNGC.h"

-#include "XNFont.h"

-#include "GCOps.h"

-#include "Drawable.h"

-#include "Visual.h"

-

-void

-xnestFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans, xPoint *pPoints,

-	       int *pWidths, int fSorted)

-{

-  ErrorF("xnest warning: function xnestFillSpans not implemented\n");

-}

-

-void

-xnestSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,

-	      xPoint *pPoints, int *pWidths, int nSpans, int fSorted)

-{

-  ErrorF("xnest warning: function xnestSetSpans not implemented\n");

-}

-

-void

-xnestGetSpans(DrawablePtr pDrawable, int maxWidth, DDXPointPtr pPoints,

-	      int *pWidths, int nSpans, char *pBuffer)

-{

-  ErrorF("xnest warning: function xnestGetSpans not implemented\n");

-}

-

-void

-xnestQueryBestSize(int class, unsigned short *pWidth, unsigned short *pHeight,

-		   ScreenPtr pScreen)

-{

-  unsigned int width, height;

-

-  width = *pWidth;

-  height = *pHeight;

-

-  XQueryBestSize(xnestDisplay, class, 

-		 xnestDefaultWindows[pScreen->myNum], 

-		 width, height, &width, &height);

-  

-  *pWidth = width;

-  *pHeight = height;

-}

-

-void

-xnestPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

-	      int w, int h, int leftPad, int format, char *pImage)

-{

-  XImage *ximage;

-  

-  ximage = XCreateImage(xnestDisplay, xnestDefaultVisual(pDrawable->pScreen), 

-			depth, format, leftPad, (char *)pImage, 

-			w, h, BitmapPad(xnestDisplay), 

-			(format == ZPixmap) ? 

-			   PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));

-  

-  if (ximage) {

-      XPutImage(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

-		ximage, 0, 0, x, y, w, h);

-      XFree(ximage);

-  }

-}

-

-void

-xnestGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,

-	      unsigned int format, unsigned long planeMask,

-	      char *pImage)

-{

-  XImage *ximage;

-  int length;

-

-  ximage = XGetImage(xnestDisplay, xnestDrawable(pDrawable),

-                     x, y, w, h, planeMask, format);

-

-  if (ximage) {

-      length = ximage->bytes_per_line * ximage->height;

-  

-      memmove(pImage, ximage->data, length);

-  

-      XDestroyImage(ximage);

-  }

-}

-

-static Bool

-xnestBitBlitPredicate(Display *display, XEvent *event, char *args)

-{

-  return event->type == GraphicsExpose || event->type == NoExpose;

-}

-

-static RegionPtr

-xnestBitBlitHelper(GCPtr pGC)

-{

-  if (!pGC->graphicsExposures) 

-    return NullRegion;

-  else {

-    XEvent event;

-    RegionPtr pReg, pTmpReg;

-    BoxRec Box;

-    Bool pending, overlap;

-

-    pReg = RegionCreate(NULL, 1);

-    pTmpReg = RegionCreate(NULL, 1);

-    if(!pReg || !pTmpReg) return NullRegion;

-    

-    pending = True;

-    while (pending) {

-      XIfEvent(xnestDisplay, &event, xnestBitBlitPredicate, NULL);

-      

-      switch (event.type) {

-      case NoExpose:

-	pending = False;

-	break;

-	

-      case GraphicsExpose:

-	Box.x1 = event.xgraphicsexpose.x;

-	Box.y1 = event.xgraphicsexpose.y;

-	Box.x2 = event.xgraphicsexpose.x + event.xgraphicsexpose.width;

-	Box.y2 = event.xgraphicsexpose.y + event.xgraphicsexpose.height;

-	RegionReset(pTmpReg, &Box);

-	RegionAppend(pReg, pTmpReg);

-	pending = event.xgraphicsexpose.count;

-	break;

-      }

-    }

-

-    RegionDestroy(pTmpReg);

-    RegionValidate(pReg, &overlap);

-    return pReg;

-  }

-}

-

-RegionPtr

-xnestCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,

-	      GCPtr pGC, int srcx, int srcy, int width, int height,

-	      int dstx, int dsty)

-{

-  XCopyArea(xnestDisplay, 

-	    xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),

-	    xnestGC(pGC), srcx, srcy, width, height, dstx, dsty);

-  

-  return xnestBitBlitHelper(pGC);

-}

-

-RegionPtr

-xnestCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,

-	       GCPtr pGC, int srcx, int srcy, int width, int height,

-	       int dstx, int dsty, unsigned long plane)

-{

-  XCopyPlane(xnestDisplay, 

-	     xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),

-	     xnestGC(pGC), srcx, srcy, width, height, dstx, dsty, plane);

-  

-  return xnestBitBlitHelper(pGC);

-}

-

-void

-xnestPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,

-	       DDXPointPtr pPoints)

-{

-  XDrawPoints(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

-              (XPoint *)pPoints, nPoints, mode);

-}

-

-void

-xnestPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,

-	       DDXPointPtr pPoints)

-{

-  XDrawLines(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

-              (XPoint *)pPoints, nPoints, mode);

-}

-

-void

-xnestPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,

-		 xSegment *pSegments)

-{

-  XDrawSegments(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

-                (XSegment *)pSegments, nSegments);

-}

-

-void

-xnestPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,

-		   xRectangle *pRectangles)

-{

-  XDrawRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-                  (XRectangle *)pRectangles, nRectangles);

-}

-

-void

-xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)

-{

-  XDrawArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-            (XArc *)pArcs, nArcs);

-}

-

-void

-xnestFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape, int mode,

-		 int nPoints, DDXPointPtr pPoints)

-{

-  XFillPolygon(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC), 

-               (XPoint *)pPoints, nPoints, shape, mode);

-}

-

-void

-xnestPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,

-		  xRectangle *pRectangles)

-{

-  XFillRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-                  (XRectangle *)pRectangles, nRectangles);

-}

-

-void

-xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs)

-{

-  XFillArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-            (XArc *)pArcs, nArcs);

-}

-

-int

-xnestPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

-	       char *string)

-{

-  int width;

-

-  XDrawString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-              x, y, string, count);

-  

-  width = XTextWidth(xnestFontStruct(pGC->font), string, count);

-  

-  return width + x;

-}

-

-int

-xnestPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

-		unsigned short *string)

-{

-  int width;

-

-  XDrawString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-                x, y, (XChar2b *)string, count);

-

-  width = XTextWidth16(xnestFontStruct(pGC->font), (XChar2b *)string, count);

-

-  return width + x;

-}

-

-void

-xnestImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

-		char *string)

-{

-  XDrawImageString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-                   x, y, string, count);

-}

-

-void

-xnestImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,

-		 unsigned short *string)

-{

-  XDrawImageString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),

-                     x, y, (XChar2b *)string, count);

-}

-

-void

-xnestImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,

-		   unsigned int nGlyphs, CharInfoPtr *pCharInfo,

-		   pointer pGlyphBase)

-{

-  ErrorF("xnest warning: function xnestImageGlyphBlt not implemented\n");

-}

-

-void

-xnestPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,

-		  unsigned int nGlyphs, CharInfoPtr *pCharInfo,

-		  pointer pGlyphBase)

-{

-  ErrorF("xnest warning: function xnestPolyGlyphBlt not implemented\n");

-}

-

-void

-xnestPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDst,

-		int width, int height, int x, int y)

-{

-  /* only works for solid bitmaps */

-  if (pGC->fillStyle == FillSolid)

-  {

-    XSetStipple (xnestDisplay, xnestGC(pGC), xnestPixmap(pBitmap));

-    XSetTSOrigin (xnestDisplay, xnestGC(pGC), x, y);

-    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillStippled);

-    XFillRectangle (xnestDisplay, xnestDrawable(pDst),

-		    xnestGC(pGC), x, y, width, height);

-    XSetFillStyle (xnestDisplay, xnestGC(pGC), FillSolid);

-  }

-  else

-    ErrorF("xnest warning: function xnestPushPixels not implemented\n");

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "regionstr.h"
+#include <X11/fonts/fontstruct.h>
+#include "gcstruct.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "region.h"
+#include "servermd.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "Screen.h"
+#include "XNGC.h"
+#include "XNFont.h"
+#include "GCOps.h"
+#include "Drawable.h"
+#include "Visual.h"
+
+void
+xnestFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans, xPoint * pPoints,
+               int *pWidths, int fSorted)
+{
+    ErrorF("xnest warning: function xnestFillSpans not implemented\n");
+}
+
+void
+xnestSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,
+              xPoint * pPoints, int *pWidths, int nSpans, int fSorted)
+{
+    ErrorF("xnest warning: function xnestSetSpans not implemented\n");
+}
+
+void
+xnestGetSpans(DrawablePtr pDrawable, int maxWidth, DDXPointPtr pPoints,
+              int *pWidths, int nSpans, char *pBuffer)
+{
+    ErrorF("xnest warning: function xnestGetSpans not implemented\n");
+}
+
+void
+xnestQueryBestSize(int class, unsigned short *pWidth, unsigned short *pHeight,
+                   ScreenPtr pScreen)
+{
+    unsigned int width, height;
+
+    width = *pWidth;
+    height = *pHeight;
+
+    XQueryBestSize(xnestDisplay, class,
+                   xnestDefaultWindows[pScreen->myNum],
+                   width, height, &width, &height);
+
+    *pWidth = width;
+    *pHeight = height;
+}
+
+void
+xnestPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+              int w, int h, int leftPad, int format, char *pImage)
+{
+    XImage *ximage;
+
+    ximage = XCreateImage(xnestDisplay, xnestDefaultVisual(pDrawable->pScreen),
+                          depth, format, leftPad, (char *) pImage,
+                          w, h, BitmapPad(xnestDisplay),
+                          (format == ZPixmap) ?
+                          PixmapBytePad(w, depth) : BitmapBytePad(w + leftPad));
+
+    if (ximage) {
+        XPutImage(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                  ximage, 0, 0, x, y, w, h);
+        XFree(ximage);
+    }
+}
+
+void
+xnestGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
+              unsigned int format, unsigned long planeMask, char *pImage)
+{
+    XImage *ximage;
+    int length;
+
+    ximage = XGetImage(xnestDisplay, xnestDrawable(pDrawable),
+                       x, y, w, h, planeMask, format);
+
+    if (ximage) {
+        length = ximage->bytes_per_line * ximage->height;
+
+        memmove(pImage, ximage->data, length);
+
+        XDestroyImage(ximage);
+    }
+}
+
+static Bool
+xnestBitBlitPredicate(Display * display, XEvent * event, char *args)
+{
+    return event->type == GraphicsExpose || event->type == NoExpose;
+}
+
+static RegionPtr
+xnestBitBlitHelper(GCPtr pGC)
+{
+    if (!pGC->graphicsExposures)
+        return NullRegion;
+    else {
+        XEvent event;
+        RegionPtr pReg, pTmpReg;
+        BoxRec Box;
+        Bool pending, overlap;
+
+        pReg = RegionCreate(NULL, 1);
+        pTmpReg = RegionCreate(NULL, 1);
+        if (!pReg || !pTmpReg)
+            return NullRegion;
+
+        pending = True;
+        while (pending) {
+            XIfEvent(xnestDisplay, &event, xnestBitBlitPredicate, NULL);
+
+            switch (event.type) {
+            case NoExpose:
+                pending = False;
+                break;
+
+            case GraphicsExpose:
+                Box.x1 = event.xgraphicsexpose.x;
+                Box.y1 = event.xgraphicsexpose.y;
+                Box.x2 = event.xgraphicsexpose.x + event.xgraphicsexpose.width;
+                Box.y2 = event.xgraphicsexpose.y + event.xgraphicsexpose.height;
+                RegionReset(pTmpReg, &Box);
+                RegionAppend(pReg, pTmpReg);
+                pending = event.xgraphicsexpose.count;
+                break;
+            }
+        }
+
+        RegionDestroy(pTmpReg);
+        RegionValidate(pReg, &overlap);
+        return pReg;
+    }
+}
+
+RegionPtr
+xnestCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
+              GCPtr pGC, int srcx, int srcy, int width, int height,
+              int dstx, int dsty)
+{
+    XCopyArea(xnestDisplay,
+              xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),
+              xnestGC(pGC), srcx, srcy, width, height, dstx, dsty);
+
+    return xnestBitBlitHelper(pGC);
+}
+
+RegionPtr
+xnestCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
+               GCPtr pGC, int srcx, int srcy, int width, int height,
+               int dstx, int dsty, unsigned long plane)
+{
+    XCopyPlane(xnestDisplay,
+               xnestDrawable(pSrcDrawable), xnestDrawable(pDstDrawable),
+               xnestGC(pGC), srcx, srcy, width, height, dstx, dsty, plane);
+
+    return xnestBitBlitHelper(pGC);
+}
+
+void
+xnestPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
+               DDXPointPtr pPoints)
+{
+    XDrawPoints(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                (XPoint *) pPoints, nPoints, mode);
+}
+
+void
+xnestPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
+               DDXPointPtr pPoints)
+{
+    XDrawLines(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+               (XPoint *) pPoints, nPoints, mode);
+}
+
+void
+xnestPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,
+                 xSegment * pSegments)
+{
+    XDrawSegments(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                  (XSegment *) pSegments, nSegments);
+}
+
+void
+xnestPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
+                   xRectangle *pRectangles)
+{
+    XDrawRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                    (XRectangle *) pRectangles, nRectangles);
+}
+
+void
+xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc * pArcs)
+{
+    XDrawArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+              (XArc *) pArcs, nArcs);
+}
+
+void
+xnestFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape, int mode,
+                 int nPoints, DDXPointPtr pPoints)
+{
+    XFillPolygon(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                 (XPoint *) pPoints, nPoints, shape, mode);
+}
+
+void
+xnestPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
+                  xRectangle *pRectangles)
+{
+    XFillRectangles(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                    (XRectangle *) pRectangles, nRectangles);
+}
+
+void
+xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc * pArcs)
+{
+    XFillArcs(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+              (XArc *) pArcs, nArcs);
+}
+
+int
+xnestPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
+               char *string)
+{
+    int width;
+
+    XDrawString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                x, y, string, count);
+
+    width = XTextWidth(xnestFontStruct(pGC->font), string, count);
+
+    return width + x;
+}
+
+int
+xnestPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
+                unsigned short *string)
+{
+    int width;
+
+    XDrawString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                  x, y, (XChar2b *) string, count);
+
+    width = XTextWidth16(xnestFontStruct(pGC->font), (XChar2b *) string, count);
+
+    return width + x;
+}
+
+void
+xnestImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
+                char *string)
+{
+    XDrawImageString(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                     x, y, string, count);
+}
+
+void
+xnestImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
+                 unsigned short *string)
+{
+    XDrawImageString16(xnestDisplay, xnestDrawable(pDrawable), xnestGC(pGC),
+                       x, y, (XChar2b *) string, count);
+}
+
+void
+xnestImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                   unsigned int nGlyphs, CharInfoPtr * pCharInfo,
+                   pointer pGlyphBase)
+{
+    ErrorF("xnest warning: function xnestImageGlyphBlt not implemented\n");
+}
+
+void
+xnestPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                  unsigned int nGlyphs, CharInfoPtr * pCharInfo,
+                  pointer pGlyphBase)
+{
+    ErrorF("xnest warning: function xnestPolyGlyphBlt not implemented\n");
+}
+
+void
+xnestPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDst,
+                int width, int height, int x, int y)
+{
+    /* only works for solid bitmaps */
+    if (pGC->fillStyle == FillSolid) {
+        XSetStipple(xnestDisplay, xnestGC(pGC), xnestPixmap(pBitmap));
+        XSetTSOrigin(xnestDisplay, xnestGC(pGC), x, y);
+        XSetFillStyle(xnestDisplay, xnestGC(pGC), FillStippled);
+        XFillRectangle(xnestDisplay, xnestDrawable(pDst),
+                       xnestGC(pGC), x, y, width, height);
+        XSetFillStyle(xnestDisplay, xnestGC(pGC), FillSolid);
+    }
+    else
+        ErrorF("xnest warning: function xnestPushPixels not implemented\n");
+}
diff --git a/xorg-server/hw/xnest/GCOps.h b/xorg-server/hw/xnest/GCOps.h
index ca4cf33f7..b1cad110c 100644
--- a/xorg-server/hw/xnest/GCOps.h
+++ b/xorg-server/hw/xnest/GCOps.h
@@ -16,53 +16,53 @@ is" without express or implied warranty.
 #define XNESTGCOPS_H
 
 void xnestFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans,
-		    xPoint *pPoints, int *pWidths, int fSorted);
+                    xPoint * pPoints, int *pWidths, int fSorted);
 void xnestSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,
-		   xPoint *pPoints, int *pWidths, int nSpans, int fSorted);
+                   xPoint * pPoints, int *pWidths, int nSpans, int fSorted);
 void xnestGetSpans(DrawablePtr pDrawable, int maxWidth, DDXPointPtr pPoints,
-		   int *pWidths, int nSpans, char *pBuffer);
+                   int *pWidths, int nSpans, char *pBuffer);
 void xnestQueryBestSize(int class, unsigned short *pWidth,
-			unsigned short *pHeight, ScreenPtr pScreen);
+                        unsigned short *pHeight, ScreenPtr pScreen);
 void xnestPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
-		   int w, int h, int leftPad, int format, char *pImage);
+                   int w, int h, int leftPad, int format, char *pImage);
 void xnestGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
-		   unsigned int format, unsigned long planeMask,
-		   char *pImage);
+                   unsigned int format, unsigned long planeMask, char *pImage);
 RegionPtr xnestCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-			GCPtr pGC, int srcx, int srcy, int width, int height,
-			int dstx, int dsty);
+                        GCPtr pGC, int srcx, int srcy, int width, int height,
+                        int dstx, int dsty);
 RegionPtr xnestCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-			 GCPtr pGC, int srcx, int srcy, int width, int height,
-			 int dstx, int dsty, unsigned long plane);
+                         GCPtr pGC, int srcx, int srcy, int width, int height,
+                         int dstx, int dsty, unsigned long plane);
 void xnestPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
-		    DDXPointPtr  pPoints);
+                    DDXPointPtr pPoints);
 void xnestPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int nPoints,
-		    DDXPointPtr pPoints);
+                    DDXPointPtr pPoints);
 void xnestPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,
-		      xSegment *pSegments);
+                      xSegment * pSegments);
 void xnestPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
-			xRectangle *pRectangles);
-void xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs);
+                        xRectangle *pRectangles);
+void xnestPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc * pArcs);
 void xnestFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape, int mode,
-		      int nPoints, DDXPointPtr pPoints);
+                      int nPoints, DDXPointPtr pPoints);
 void xnestPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRectangles,
-		       xRectangle *pRectangles);
-void xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs, xArc *pArcs);
+                       xRectangle *pRectangles);
+void xnestPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs,
+                      xArc * pArcs);
 int xnestPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		   char *string);
+                   char *string);
 int xnestPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		    unsigned short *string);
+                    unsigned short *string);
 void xnestImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		    char *string);
+                     char *string);
 void xnestImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count,
-		    unsigned short *string);
+                      unsigned short *string);
 void xnestImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-			unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-			pointer pGlyphBase);
+                        unsigned int nGlyphs, CharInfoPtr * pCharInfo,
+                        pointer pGlyphBase);
 void xnestPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-		       unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-		       pointer pGlyphBase);
+                       unsigned int nGlyphs, CharInfoPtr * pCharInfo,
+                       pointer pGlyphBase);
 void xnestPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDrawable,
-		     int width, int height, int x, int y);
+                     int width, int height, int x, int y);
 
-#endif /* XNESTGCOPS_H */
+#endif                          /* XNESTGCOPS_H */
diff --git a/xorg-server/hw/xnest/Init.c b/xorg-server/hw/xnest/Init.c
index af57518ba..0909826d9 100644
--- a/xorg-server/hw/xnest/Init.c
+++ b/xorg-server/hw/xnest/Init.c
@@ -46,84 +46,86 @@ is" without express or implied warranty.
 Bool xnestDoFullGeneration = True;
 
 void
-InitOutput(ScreenInfo *screenInfo, int argc, char *argv[])
+InitOutput(ScreenInfo * screenInfo, int argc, char *argv[])
 {
-  int i, j;
-
-  xnestOpenDisplay(argc, argv);
-  
-  screenInfo->imageByteOrder = ImageByteOrder(xnestDisplay);
-  screenInfo->bitmapScanlineUnit = BitmapUnit(xnestDisplay);
-  screenInfo->bitmapScanlinePad = BitmapPad(xnestDisplay);
-  screenInfo->bitmapBitOrder = BitmapBitOrder(xnestDisplay);
-  
-  screenInfo->numPixmapFormats = 0;
-  for (i = 0; i < xnestNumPixmapFormats; i++) 
-    for (j = 0; j < xnestNumDepths; j++)
-      if ((xnestPixmapFormats[i].depth == 1) ||
-          (xnestPixmapFormats[i].depth == xnestDepths[j])) {
-	screenInfo->formats[screenInfo->numPixmapFormats].depth = 
-	  xnestPixmapFormats[i].depth;
-	screenInfo->formats[screenInfo->numPixmapFormats].bitsPerPixel = 
-	  xnestPixmapFormats[i].bits_per_pixel;
-	screenInfo->formats[screenInfo->numPixmapFormats].scanlinePad = 
-	  xnestPixmapFormats[i].scanline_pad;
-	screenInfo->numPixmapFormats++;
-	break;
-      }
-  
-  xnestFontPrivateIndex = AllocateFontPrivateIndex();
-  
-  if (!xnestNumScreens) xnestNumScreens = 1;
-
-  for (i = 0; i < xnestNumScreens; i++)
-    AddScreen(xnestOpenScreen, argc, argv);
-
-  xnestNumScreens = screenInfo->numScreens;
-
-  xnestDoFullGeneration = xnestFullGeneration;
+    int i, j;
+
+    xnestOpenDisplay(argc, argv);
+
+    screenInfo->imageByteOrder = ImageByteOrder(xnestDisplay);
+    screenInfo->bitmapScanlineUnit = BitmapUnit(xnestDisplay);
+    screenInfo->bitmapScanlinePad = BitmapPad(xnestDisplay);
+    screenInfo->bitmapBitOrder = BitmapBitOrder(xnestDisplay);
+
+    screenInfo->numPixmapFormats = 0;
+    for (i = 0; i < xnestNumPixmapFormats; i++)
+        for (j = 0; j < xnestNumDepths; j++)
+            if ((xnestPixmapFormats[i].depth == 1) ||
+                (xnestPixmapFormats[i].depth == xnestDepths[j])) {
+                screenInfo->formats[screenInfo->numPixmapFormats].depth =
+                    xnestPixmapFormats[i].depth;
+                screenInfo->formats[screenInfo->numPixmapFormats].bitsPerPixel =
+                    xnestPixmapFormats[i].bits_per_pixel;
+                screenInfo->formats[screenInfo->numPixmapFormats].scanlinePad =
+                    xnestPixmapFormats[i].scanline_pad;
+                screenInfo->numPixmapFormats++;
+                break;
+            }
+
+    xnestFontPrivateIndex = AllocateFontPrivateIndex();
+
+    if (!xnestNumScreens)
+        xnestNumScreens = 1;
+
+    for (i = 0; i < xnestNumScreens; i++)
+        AddScreen(xnestOpenScreen, argc, argv);
+
+    xnestNumScreens = screenInfo->numScreens;
+
+    xnestDoFullGeneration = xnestFullGeneration;
 }
 
 void
 InitInput(int argc, char *argv[])
 {
-  int rc;
-  rc = AllocDevicePair(serverClient, "Xnest",
-                       &xnestPointerDevice,
-                       &xnestKeyboardDevice,
-                       xnestPointerProc,
-                       xnestKeyboardProc,
-                       FALSE);
+    int rc;
+
+    rc = AllocDevicePair(serverClient, "Xnest",
+                         &xnestPointerDevice,
+                         &xnestKeyboardDevice,
+                         xnestPointerProc, xnestKeyboardProc, FALSE);
 
-  if (rc != Success)
-      FatalError("Failed to init Xnest default devices.\n");
+    if (rc != Success)
+        FatalError("Failed to init Xnest default devices.\n");
 
-  mieqInit();
+    mieqInit();
 
-  AddEnabledDevice(XConnectionNumber(xnestDisplay));
+    AddEnabledDevice(XConnectionNumber(xnestDisplay));
 
-  RegisterBlockAndWakeupHandlers(xnestBlockHandler, xnestWakeupHandler, NULL);
+    RegisterBlockAndWakeupHandlers(xnestBlockHandler, xnestWakeupHandler, NULL);
 }
 
 void
 CloseInput(void)
 {
-  mieqFini();
+    mieqFini();
 }
 
 /*
  * DDX - specific abort routine.  Called by AbortServer().
  */
-void AbortDDX(enum ExitCode error)
+void
+AbortDDX(enum ExitCode error)
 {
-  xnestDoFullGeneration = True;
-  xnestCloseDisplay();
+    xnestDoFullGeneration = True;
+    xnestCloseDisplay();
 }
 
 /* Called by GiveUp(). */
-void ddxGiveUp(enum ExitCode error)
+void
+ddxGiveUp(enum ExitCode error)
 {
-  AbortDDX(error);
+    AbortDDX(error);
 }
 
 #ifdef __APPLE__
@@ -133,18 +135,21 @@ DarwinHandleGUI(int argc, char *argv[])
 }
 #endif
 
-void OsVendorInit(void)
+void
+OsVendorInit(void)
 {
     return;
 }
 
-void OsVendorFatalError(void)
+void
+OsVendorFatalError(void)
 {
     return;
 }
 
 #if defined(DDXBEFORERESET)
-void ddxBeforeReset(void)
+void
+ddxBeforeReset(void)
 {
     return;
 }
diff --git a/xorg-server/hw/xnest/Keyboard.c b/xorg-server/hw/xnest/Keyboard.c
index 5ef376b91..d013dc91e 100644
--- a/xorg-server/hw/xnest/Keyboard.c
+++ b/xorg-server/hw/xnest/Keyboard.c
@@ -38,231 +38,230 @@ is" without express or implied warranty.
 #include <X11/extensions/XKBconfig.h>
 
 extern Bool
-XkbQueryExtension(
-	Display *		/* dpy */,
-	int *			/* opcodeReturn */,
-	int *			/* eventBaseReturn */,
-	int *			/* errorBaseReturn */,
-	int *			/* majorRtrn */,
-	int *			/* minorRtrn */
-);
-
-extern	XkbDescPtr XkbGetKeyboard(
-	Display *		/* dpy */,
-	unsigned int		/* which */,
-	unsigned int		/* deviceSpec */
-);
-
-extern	Status	XkbGetControls(
-	Display *		/* dpy */,
-	unsigned long		/* which */,
-	XkbDescPtr		/* desc */
-);
+ XkbQueryExtension(Display * /* dpy */ ,
+                   int * /* opcodeReturn */ ,
+                   int * /* eventBaseReturn */ ,
+                   int * /* errorBaseReturn */ ,
+                   int * /* majorRtrn */ ,
+                   int *        /* minorRtrn */
+    );
+
+extern XkbDescPtr XkbGetKeyboard(Display * /* dpy */ ,
+                                 unsigned int /* which */ ,
+                                 unsigned int   /* deviceSpec */
+    );
+
+extern Status XkbGetControls(Display * /* dpy */ ,
+                             unsigned long /* which */ ,
+                             XkbDescPtr /* desc */
+    );
 
 DeviceIntPtr xnestKeyboardDevice = NULL;
 
 void
 xnestBell(int volume, DeviceIntPtr pDev, pointer ctrl, int cls)
 {
-  XBell(xnestDisplay, volume);
+    XBell(xnestDisplay, volume);
 }
 
 void
 DDXRingBell(int volume, int pitch, int duration)
 {
-  XBell(xnestDisplay, volume);
+    XBell(xnestDisplay, volume);
 }
 
 void
-xnestChangeKeyboardControl(DeviceIntPtr pDev, KeybdCtrl *ctrl)
+xnestChangeKeyboardControl(DeviceIntPtr pDev, KeybdCtrl * ctrl)
 {
 #if 0
-  unsigned long value_mask;
-  XKeyboardControl values;
-  int i;
-
-  value_mask = KBKeyClickPercent |
-               KBBellPercent |
-	       KBBellPitch |
-	       KBBellDuration |
-	       KBAutoRepeatMode;
-
-  values.key_click_percent = ctrl->click;
-  values.bell_percent = ctrl->bell;
-  values.bell_pitch = ctrl->bell_pitch;
-  values.bell_duration = ctrl->bell_duration;
-  values.auto_repeat_mode = ctrl->autoRepeat ? 
-                             AutoRepeatModeOn : AutoRepeatModeOff;
-
-  XChangeKeyboardControl(xnestDisplay, value_mask, &values);
-
-  /*
-  value_mask = KBKey | KBAutoRepeatMode;
-  At this point, we need to walk through the vector and compare it
-  to the current server vector.  If there are differences, report them.
-  */
-
-  value_mask = KBLed | KBLedMode;
-  for (i = 1; i <= 32; i++) {
-    values.led = i;
-    values.led_mode = (ctrl->leds & (1 << (i - 1))) ? LedModeOn : LedModeOff;
+    unsigned long value_mask;
+    XKeyboardControl values;
+    int i;
+
+    value_mask = KBKeyClickPercent |
+        KBBellPercent | KBBellPitch | KBBellDuration | KBAutoRepeatMode;
+
+    values.key_click_percent = ctrl->click;
+    values.bell_percent = ctrl->bell;
+    values.bell_pitch = ctrl->bell_pitch;
+    values.bell_duration = ctrl->bell_duration;
+    values.auto_repeat_mode = ctrl->autoRepeat ?
+        AutoRepeatModeOn : AutoRepeatModeOff;
+
     XChangeKeyboardControl(xnestDisplay, value_mask, &values);
-  }
+
+    /*
+       value_mask = KBKey | KBAutoRepeatMode;
+       At this point, we need to walk through the vector and compare it
+       to the current server vector.  If there are differences, report them.
+     */
+
+    value_mask = KBLed | KBLedMode;
+    for (i = 1; i <= 32; i++) {
+        values.led = i;
+        values.led_mode =
+            (ctrl->leds & (1 << (i - 1))) ? LedModeOn : LedModeOff;
+        XChangeKeyboardControl(xnestDisplay, value_mask, &values);
+    }
 #endif
 }
 
 int
 xnestKeyboardProc(DeviceIntPtr pDev, int onoff)
 {
-  XModifierKeymap *modifier_keymap;
-  KeySym *keymap;
-  int mapWidth;
-  int min_keycode, max_keycode;
-  KeySymsRec keySyms;
-  CARD8 modmap[MAP_LENGTH];
-  int i, j;
-  XKeyboardState values;
-  XkbDescPtr xkb;
-  int op, event, error, major, minor;
-
-  switch (onoff)
-    {
-    case DEVICE_INIT: 
-      XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode);
+    XModifierKeymap *modifier_keymap;
+    KeySym *keymap;
+    int mapWidth;
+    int min_keycode, max_keycode;
+    KeySymsRec keySyms;
+    CARD8 modmap[MAP_LENGTH];
+    int i, j;
+    XKeyboardState values;
+    XkbDescPtr xkb;
+    int op, event, error, major, minor;
+
+    switch (onoff) {
+    case DEVICE_INIT:
+        XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode);
 #ifdef _XSERVER64
-      {
-	KeySym64 *keymap64;
-	int len;
-	keymap64 = XGetKeyboardMapping(xnestDisplay,
-				     min_keycode,
-				     max_keycode - min_keycode + 1,
-				     &mapWidth);
-	len = (max_keycode - min_keycode + 1) * mapWidth;
-	keymap = (KeySym *)malloc(len * sizeof(KeySym));
-	for(i = 0; i < len; ++i)
-	  keymap[i] = keymap64[i];
-	XFree(keymap64);
-      }
+        {
+            KeySym64 *keymap64;
+            int len;
+
+            keymap64 = XGetKeyboardMapping(xnestDisplay,
+                                           min_keycode,
+                                           max_keycode - min_keycode + 1,
+                                           &mapWidth);
+            len = (max_keycode - min_keycode + 1) * mapWidth;
+            keymap = (KeySym *) malloc(len * sizeof(KeySym));
+            for (i = 0; i < len; ++i)
+                keymap[i] = keymap64[i];
+            XFree(keymap64);
+        }
 #else
-      keymap = XGetKeyboardMapping(xnestDisplay, 
-				   min_keycode,
-				   max_keycode - min_keycode + 1,
-				   &mapWidth);
+        keymap = XGetKeyboardMapping(xnestDisplay,
+                                     min_keycode,
+                                     max_keycode - min_keycode + 1, &mapWidth);
 #endif
 
-      memset(modmap, 0, sizeof(modmap));
-      modifier_keymap = XGetModifierMapping(xnestDisplay);
-      for (j = 0; j < 8; j++)
-            for(i = 0; i < modifier_keymap->max_keypermod; i++) {
-                  CARD8 keycode;
-                  if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap->max_keypermod + i]))
-                      modmap[keycode] |= 1<<j;
-      }
-      XFreeModifiermap(modifier_keymap);
-
-      keySyms.minKeyCode = min_keycode;
-      keySyms.maxKeyCode = max_keycode;
-      keySyms.mapWidth = mapWidth;
-      keySyms.map = keymap;
-
-      if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) {
-          ErrorF("Unable to initialize XKEYBOARD extension.\n");
-	  goto XkbError;
-      }
-      xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd);
-      if (xkb == NULL || xkb->geom == NULL) {
-	  ErrorF("Couldn't get keyboard.\n");
-          goto XkbError;
-      }
-      XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb);
-
-      InitKeyboardDeviceStruct(pDev, NULL,
-                               xnestBell, xnestChangeKeyboardControl);
-
-      XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode,
-                            keySyms.maxKeyCode - keySyms.minKeyCode + 1,
-                            modmap, serverClient);
-
-      XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls);
-      XkbFreeKeyboard(xkb, 0, False);
-      free(keymap);
-      break;
-    case DEVICE_ON: 
-      xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK;
-      for (i = 0; i < xnestNumScreens; i++)
-	XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
-      break;
-    case DEVICE_OFF: 
-      xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK;
-      for (i = 0; i < xnestNumScreens; i++)
-	XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
-      break;
-    case DEVICE_CLOSE: 
-      break;
+        memset(modmap, 0, sizeof(modmap));
+        modifier_keymap = XGetModifierMapping(xnestDisplay);
+        for (j = 0; j < 8; j++)
+            for (i = 0; i < modifier_keymap->max_keypermod; i++) {
+                CARD8 keycode;
+
+                if ((keycode =
+                     modifier_keymap->modifiermap[j *
+                                                  modifier_keymap->
+                                                  max_keypermod + i]))
+                    modmap[keycode] |= 1 << j;
+            }
+        XFreeModifiermap(modifier_keymap);
+
+        keySyms.minKeyCode = min_keycode;
+        keySyms.maxKeyCode = max_keycode;
+        keySyms.mapWidth = mapWidth;
+        keySyms.map = keymap;
+
+        if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor)
+            == 0) {
+            ErrorF("Unable to initialize XKEYBOARD extension.\n");
+            goto XkbError;
+        }
+        xkb =
+            XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask,
+                           XkbUseCoreKbd);
+        if (xkb == NULL || xkb->geom == NULL) {
+            ErrorF("Couldn't get keyboard.\n");
+            goto XkbError;
+        }
+        XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb);
+
+        InitKeyboardDeviceStruct(pDev, NULL,
+                                 xnestBell, xnestChangeKeyboardControl);
+
+        XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode,
+                              keySyms.maxKeyCode - keySyms.minKeyCode + 1,
+                              modmap, serverClient);
+
+        XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls);
+        XkbFreeKeyboard(xkb, 0, False);
+        free(keymap);
+        break;
+    case DEVICE_ON:
+        xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK;
+        for (i = 0; i < xnestNumScreens; i++)
+            XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
+        break;
+    case DEVICE_OFF:
+        xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK;
+        for (i = 0; i < xnestNumScreens; i++)
+            XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
+        break;
+    case DEVICE_CLOSE:
+        break;
     }
-  return Success;
-
-XkbError:
-  XGetKeyboardControl(xnestDisplay, &values);
-  memmove((char *)defaultKeyboardControl.autoRepeats,
-          (char *)values.auto_repeats,
-          sizeof(values.auto_repeats));
-
-  InitKeyboardDeviceStruct(pDev, NULL,
-                           xnestBell, xnestChangeKeyboardControl);
-  free(keymap);
-  return Success;
+    return Success;
+
+ XkbError:
+    XGetKeyboardControl(xnestDisplay, &values);
+    memmove((char *) defaultKeyboardControl.autoRepeats,
+            (char *) values.auto_repeats, sizeof(values.auto_repeats));
+
+    InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl);
+    free(keymap);
+    return Success;
 }
 
 Bool
 LegalModifier(unsigned int key, DeviceIntPtr pDev)
 {
-  return TRUE;
+    return TRUE;
 }
 
 void
 xnestUpdateModifierState(unsigned int state)
 {
-  DeviceIntPtr pDev = xnestKeyboardDevice;
-  KeyClassPtr keyc = pDev->key;
-  int i;
-  CARD8 mask;
-  int xkb_state;
-
-  if (!pDev)
-      return;
-
-  xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);
-  state = state & 0xff;
-
-  if (xkb_state == state)
-    return;
-
-  for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {
-    int key;
-
-    /* Modifier is down, but shouldn't be
-     */
-    if ((xkb_state & mask) && !(state & mask)) {
-      int count = keyc->modifierKeyCount[i];
-
-      for (key = 0; key < MAP_LENGTH; key++)
-	if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
-	  if (key_is_down(pDev, key, KEY_PROCESSED))
-	    xnestQueueKeyEvent(KeyRelease, key);
-
-	  if (--count == 0)
-	    break;
-	}
+    DeviceIntPtr pDev = xnestKeyboardDevice;
+    KeyClassPtr keyc = pDev->key;
+    int i;
+    CARD8 mask;
+    int xkb_state;
+
+    if (!pDev)
+        return;
+
+    xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);
+    state = state & 0xff;
+
+    if (xkb_state == state)
+        return;
+
+    for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {
+        int key;
+
+        /* Modifier is down, but shouldn't be
+         */
+        if ((xkb_state & mask) && !(state & mask)) {
+            int count = keyc->modifierKeyCount[i];
+
+            for (key = 0; key < MAP_LENGTH; key++)
+                if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+                    if (key_is_down(pDev, key, KEY_PROCESSED))
+                        xnestQueueKeyEvent(KeyRelease, key);
+
+                    if (--count == 0)
+                        break;
+                }
+        }
+
+        /* Modifier shoud be down, but isn't
+         */
+        if (!(xkb_state & mask) && (state & mask))
+            for (key = 0; key < MAP_LENGTH; key++)
+                if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+                    xnestQueueKeyEvent(KeyPress, key);
+                    break;
+                }
     }
-
-    /* Modifier shoud be down, but isn't
-     */
-    if (!(xkb_state & mask) && (state & mask))
-      for (key = 0; key < MAP_LENGTH; key++)
-	if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
-	  xnestQueueKeyEvent(KeyPress, key);
-	  break;
-	}
-  }
 }
diff --git a/xorg-server/hw/xnest/Pointer.c b/xorg-server/hw/xnest/Pointer.c
index fdc6181e9..a2ee90064 100644
--- a/xorg-server/hw/xnest/Pointer.c
+++ b/xorg-server/hw/xnest/Pointer.c
@@ -34,64 +34,63 @@ is" without express or implied warranty.
 #include "Args.h"
 
 #include "xserver-properties.h"
-#include "exevents.h" /* For XIGetKnownProperty */
+#include "exevents.h"           /* For XIGetKnownProperty */
 
 DeviceIntPtr xnestPointerDevice = NULL;
 
 void
-xnestChangePointerControl(DeviceIntPtr pDev, PtrCtrl *ctrl)
+xnestChangePointerControl(DeviceIntPtr pDev, PtrCtrl * ctrl)
 {
-  XChangePointerControl(xnestDisplay, True, True, 
-			ctrl->num, ctrl->den, ctrl->threshold); 
+    XChangePointerControl(xnestDisplay, True, True,
+                          ctrl->num, ctrl->den, ctrl->threshold);
 }
 
 int
 xnestPointerProc(DeviceIntPtr pDev, int onoff)
 {
-  CARD8 map[MAXBUTTONS];
-  Atom btn_labels[MAXBUTTONS] = {0};
-  Atom axes_labels[2] = {0};
-  int nmap;
-  int i;
+    CARD8 map[MAXBUTTONS];
+    Atom btn_labels[MAXBUTTONS] = { 0 };
+    Atom axes_labels[2] = { 0 };
+    int nmap;
+    int i;
 
-  switch (onoff)
-    {
-    case DEVICE_INIT: 
-      nmap = XGetPointerMapping(xnestDisplay, map, MAXBUTTONS);
-      for (i = 0; i <= nmap; i++)
-	map[i] = i; /* buttons are already mapped */
+    switch (onoff) {
+    case DEVICE_INIT:
+        nmap = XGetPointerMapping(xnestDisplay, map, MAXBUTTONS);
+        for (i = 0; i <= nmap; i++)
+            map[i] = i;         /* buttons are already mapped */
 
-      btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
-      btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
-      btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
-      btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
-      btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
-      btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
-      btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+        btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
+        btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
+        btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
+        btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
+        btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+        btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+        btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
 
-      axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
-      axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
+        axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
+        axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
 
-      XGetPointerControl(xnestDisplay,
-                         &defaultPointerControl.num,
-                         &defaultPointerControl.den,
-                         &defaultPointerControl.threshold);
-      InitPointerDeviceStruct(&pDev->public, map, nmap, btn_labels,
-			      xnestChangePointerControl,
-			      GetMotionHistorySize(), 2, axes_labels);
-      break;
-    case DEVICE_ON: 
-      xnestEventMask |= XNEST_POINTER_EVENT_MASK;
-      for (i = 0; i < xnestNumScreens; i++)
-	XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
-      break;
-    case DEVICE_OFF: 
-      xnestEventMask &= ~XNEST_POINTER_EVENT_MASK;
-      for (i = 0; i < xnestNumScreens; i++)
-	XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
-      break;
-    case DEVICE_CLOSE: 
-      break;
+        XGetPointerControl(xnestDisplay,
+                           &defaultPointerControl.num,
+                           &defaultPointerControl.den,
+                           &defaultPointerControl.threshold);
+        InitPointerDeviceStruct(&pDev->public, map, nmap, btn_labels,
+                                xnestChangePointerControl,
+                                GetMotionHistorySize(), 2, axes_labels);
+        break;
+    case DEVICE_ON:
+        xnestEventMask |= XNEST_POINTER_EVENT_MASK;
+        for (i = 0; i < xnestNumScreens; i++)
+            XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
+        break;
+    case DEVICE_OFF:
+        xnestEventMask &= ~XNEST_POINTER_EVENT_MASK;
+        for (i = 0; i < xnestNumScreens; i++)
+            XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask);
+        break;
+    case DEVICE_CLOSE:
+        break;
     }
-  return Success;
+    return Success;
 }
diff --git a/xorg-server/hw/xnest/Screen.c b/xorg-server/hw/xnest/Screen.c
index c4ab464cb..dd76cb801 100644
--- a/xorg-server/hw/xnest/Screen.c
+++ b/xorg-server/hw/xnest/Screen.c
@@ -1,422 +1,428 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "scrnintstr.h"

-#include "dix.h"

-#include "mi.h"

-#include "mibstore.h"

-#include "micmap.h"

-#include "colormapst.h"

-#include "resource.h"

-

-#include "Xnest.h"

-

-#include "Display.h"

-#include "Screen.h"

-#include "XNGC.h"

-#include "GCOps.h"

-#include "Drawable.h"

-#include "XNFont.h"

-#include "Color.h"

-#include "XNCursor.h"

-#include "Visual.h"

-#include "Events.h"

-#include "Init.h"

-#include "mipointer.h"

-#include "Args.h"

-#include "mipointrst.h"

-

-Window xnestDefaultWindows[MAXSCREENS];

-Window xnestScreenSaverWindows[MAXSCREENS];

-DevPrivateKeyRec xnestCursorScreenKeyRec;

-

-ScreenPtr

-xnestScreen(Window window)

-{

-  int i;

-  

-  for (i = 0; i < xnestNumScreens; i++)

-    if (xnestDefaultWindows[i] == window) 

-      return screenInfo.screens[i];

-

-  return NULL;

-}

-

-static int

-offset(unsigned long mask)

-{

-  int count;

-  

-  for (count = 0; !(mask & 1) && count < 32; count++)

-    mask >>= 1;

-  

-  return count;

-}

-

-static Bool

-xnestSaveScreen(ScreenPtr pScreen, int what)

-{

-  if (xnestSoftwareScreenSaver)

-    return False;

-  else {

-    switch (what) {

-    case SCREEN_SAVER_ON:

-      XMapRaised(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);

-      xnestSetScreenSaverColormapWindow(pScreen);

-      break;

-      

-    case SCREEN_SAVER_OFF:

-      XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);

-      xnestSetInstalledColormapWindows(pScreen);

-      break;

-      

-    case SCREEN_SAVER_FORCER:

-      lastEventTime = GetTimeInMillis();

-      XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);

-      xnestSetInstalledColormapWindows(pScreen);

-      break;

-      

-    case SCREEN_SAVER_CYCLE:

-      XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);

-      xnestSetInstalledColormapWindows(pScreen);

-      break;

-    }

-    return True;

-  }

-}

-

-static Bool

-xnestCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)

-{

-    return FALSE;

-}

-

-static void

-xnestCrossScreen(ScreenPtr pScreen, Bool entering)

-{

-}

-

-static miPointerScreenFuncRec xnestPointerCursorFuncs =

-{

-    xnestCursorOffScreen,

-    xnestCrossScreen,

-    miPointerWarpCursor

-};

-

-static miPointerSpriteFuncRec xnestPointerSpriteFuncs = 

-{

-    xnestRealizeCursor,

-    xnestUnrealizeCursor,

-    xnestSetCursor,

-    xnestMoveCursor,

-    xnestDeviceCursorInitialize,

-    xnestDeviceCursorCleanup

-};

-

-Bool

-xnestOpenScreen(int index, ScreenPtr pScreen, int argc, char *argv[])

-{

-  VisualPtr visuals;

-  DepthPtr depths;

-  int numVisuals, numDepths;

-  int i, j, depthIndex;

-  unsigned long valuemask;

-  XSetWindowAttributes attributes;

-  XWindowAttributes gattributes;

-  XSizeHints sizeHints;

-  VisualID defaultVisual;

-  int rootDepth;

-  miPointerScreenPtr PointPriv;

-

-  if (!dixRegisterPrivateKey(&xnestWindowPrivateKeyRec, PRIVATE_WINDOW, sizeof(xnestPrivWin)))

-      return FALSE;

-  if (!dixRegisterPrivateKey(&xnestGCPrivateKeyRec, PRIVATE_GC, sizeof(xnestPrivGC)))

-    return FALSE;

-  if (!dixRegisterPrivateKey(&xnestPixmapPrivateKeyRec, PRIVATE_PIXMAP, sizeof (xnestPrivPixmap)))

-      return FALSE;

-  if (!dixRegisterPrivateKey(&xnestColormapPrivateKeyRec, PRIVATE_COLORMAP, sizeof (xnestPrivColormap)))

-      return FALSE;

-  if (!dixRegisterPrivateKey(&xnestCursorScreenKeyRec, PRIVATE_SCREEN, 0))

-      return FALSE;

-

-  visuals = (VisualPtr)malloc(xnestNumVisuals * sizeof(VisualRec));

-  numVisuals = 0;

-

-  depths = (DepthPtr)malloc(MAXDEPTH * sizeof(DepthRec));

-  depths[0].depth = 1;

-  depths[0].numVids = 0;

-  depths[0].vids = (VisualID *)malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));

-  numDepths = 1;

-

-  for (i = 0; i < xnestNumVisuals; i++) {

-    visuals[numVisuals].class = xnestVisuals[i].class;

-    visuals[numVisuals].bitsPerRGBValue = xnestVisuals[i].bits_per_rgb;

-    visuals[numVisuals].ColormapEntries = xnestVisuals[i].colormap_size;

-    visuals[numVisuals].nplanes = xnestVisuals[i].depth;

-    visuals[numVisuals].redMask = xnestVisuals[i].red_mask;

-    visuals[numVisuals].greenMask = xnestVisuals[i].green_mask;

-    visuals[numVisuals].blueMask = xnestVisuals[i].blue_mask;

-    visuals[numVisuals].offsetRed = offset(xnestVisuals[i].red_mask);

-    visuals[numVisuals].offsetGreen = offset(xnestVisuals[i].green_mask);

-    visuals[numVisuals].offsetBlue = offset(xnestVisuals[i].blue_mask);

-

-    /* Check for and remove duplicates. */

-    for (j = 0; j < numVisuals; j++) {

-      if (visuals[numVisuals].class           == visuals[j].class           &&

-	  visuals[numVisuals].bitsPerRGBValue == visuals[j].bitsPerRGBValue &&

-	  visuals[numVisuals].ColormapEntries == visuals[j].ColormapEntries &&

-	  visuals[numVisuals].nplanes         == visuals[j].nplanes         &&

-	  visuals[numVisuals].redMask         == visuals[j].redMask         &&

-	  visuals[numVisuals].greenMask       == visuals[j].greenMask       &&

-	  visuals[numVisuals].blueMask        == visuals[j].blueMask        &&

-	  visuals[numVisuals].offsetRed       == visuals[j].offsetRed       &&

-	  visuals[numVisuals].offsetGreen     == visuals[j].offsetGreen     &&

-	  visuals[numVisuals].offsetBlue      == visuals[j].offsetBlue)

-	break;

-    }

-    if (j < numVisuals)

-      break;

-

-    visuals[numVisuals].vid = FakeClientID(0);

-

-    depthIndex = UNDEFINED;

-    for (j = 0; j < numDepths; j++)

-      if (depths[j].depth == xnestVisuals[i].depth) {

-	depthIndex = j;

-	break;

-      }

-    

-    if (depthIndex == UNDEFINED) {

-      depthIndex = numDepths;

-      depths[depthIndex].depth = xnestVisuals[i].depth;

-      depths[depthIndex].numVids = 0;

-      depths[depthIndex].vids = 

-	(VisualID *)malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));

-      numDepths++;

-    }

-    if (depths[depthIndex].numVids >= MAXVISUALSPERDEPTH) {

-	FatalError("Visual table overflow");

-    }

-    depths[depthIndex].vids[depths[depthIndex].numVids] = 

-      visuals[numVisuals].vid;

-    depths[depthIndex].numVids++;

-    

-    numVisuals++;

-  }

-  visuals = (VisualPtr)realloc(visuals, numVisuals * sizeof(VisualRec));

-

-  defaultVisual = visuals[xnestDefaultVisualIndex].vid;

-  rootDepth = visuals[xnestDefaultVisualIndex].nplanes;

-

-  if (xnestParentWindow != 0) {

-    XGetWindowAttributes(xnestDisplay, xnestParentWindow, &gattributes);

-    xnestWidth = gattributes.width;

-    xnestHeight = gattributes.height;

-  }

-

-  /* myNum */

-  /* id */

-  miScreenInit(pScreen, NULL, xnestWidth, xnestHeight, 1, 1, xnestWidth,

-	       rootDepth,

-	       numDepths, depths,

-	       defaultVisual, /* root visual */

-	       numVisuals, visuals);

-

-  pScreen->defColormap = (Colormap) FakeClientID(0);

-  pScreen->minInstalledCmaps = MINCMAPS;

-  pScreen->maxInstalledCmaps = MAXCMAPS;

-  pScreen->backingStoreSupport = NotUseful;

-  pScreen->saveUnderSupport = NotUseful;

-  pScreen->whitePixel = xnestWhitePixel;

-  pScreen->blackPixel = xnestBlackPixel;

-  /* GCperDepth */

-  /* PixmapPerDepth */

-  pScreen->devPrivate = NULL;

-  /* WindowPrivateLen */

-  /* WindowPrivateSizes */

-  /* totalWindowSize */

-  /* GCPrivateLen */

-  /* GCPrivateSizes */

-  /* totalGCSize */

-

-  /* Random screen procedures */

-

-  pScreen->QueryBestSize = xnestQueryBestSize;

-  pScreen->SaveScreen = xnestSaveScreen;

-  pScreen->GetImage = xnestGetImage;

-  pScreen->GetSpans = xnestGetSpans;

-  pScreen->SourceValidate = NULL;

-

-  /* Window Procedures */

-  

-  pScreen->CreateWindow = xnestCreateWindow;

-  pScreen->DestroyWindow = xnestDestroyWindow;

-  pScreen->PositionWindow = xnestPositionWindow;

-  pScreen->ChangeWindowAttributes = xnestChangeWindowAttributes;

-  pScreen->RealizeWindow = xnestRealizeWindow;

-  pScreen->UnrealizeWindow = xnestUnrealizeWindow;

-  pScreen->PostValidateTree = NULL;

-  pScreen->WindowExposures = xnestWindowExposures;

-  pScreen->CopyWindow = xnestCopyWindow;

-  pScreen->ClipNotify = xnestClipNotify;

-

-  /* Pixmap procedures */

-

-  pScreen->CreatePixmap = xnestCreatePixmap;

-  pScreen->DestroyPixmap = xnestDestroyPixmap;

-

-  /* Font procedures */

-

-  pScreen->RealizeFont = xnestRealizeFont;

-  pScreen->UnrealizeFont = xnestUnrealizeFont;

-

-  /* GC procedures */

-  

-  pScreen->CreateGC = xnestCreateGC;

-

-  /* Colormap procedures */

-

-  pScreen->CreateColormap = xnestCreateColormap;

-  pScreen->DestroyColormap = xnestDestroyColormap;

-  pScreen->InstallColormap = xnestInstallColormap;

-  pScreen->UninstallColormap = xnestUninstallColormap;

-  pScreen->ListInstalledColormaps = xnestListInstalledColormaps;

-  pScreen->StoreColors = xnestStoreColors;

-  pScreen->ResolveColor = xnestResolveColor;

-

-   pScreen->BitmapToRegion = xnestPixmapToRegion;

-

-  /* OS layer procedures */

-

-  pScreen->BlockHandler = (ScreenBlockHandlerProcPtr)NoopDDA;

-  pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr)NoopDDA;

-  pScreen->blockData = NULL;

-  pScreen->wakeupData = NULL;

-

-  miDCInitialize(pScreen, &xnestPointerCursorFuncs); /* init SW rendering */

-  PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);

-  xnestCursorFuncs.spriteFuncs = PointPriv->spriteFuncs;

-  dixSetPrivate(&pScreen->devPrivates, xnestCursorScreenKey, &xnestCursorFuncs);

-  PointPriv->spriteFuncs = &xnestPointerSpriteFuncs;

-

-  pScreen->mmWidth = xnestWidth * DisplayWidthMM(xnestDisplay, 

-		       DefaultScreen(xnestDisplay)) / 

-			 DisplayWidth(xnestDisplay, 

-			   DefaultScreen(xnestDisplay));

-  pScreen->mmHeight = xnestHeight * DisplayHeightMM(xnestDisplay, 

-		        DefaultScreen(xnestDisplay)) /

-			  DisplayHeight(xnestDisplay, 

-			    DefaultScreen(xnestDisplay));

-

-  /* overwrite miCloseScreen with our own */

-  pScreen->CloseScreen = xnestCloseScreen;

-

-  if (!miScreenDevPrivateInit(pScreen, xnestWidth, NULL))

-      return FALSE;

-

-  /* overwrite miSetShape with our own */

-  pScreen->SetShape = xnestSetShape;

-

-  /* devPrivates */

-

-#define POSITION_OFFSET (pScreen->myNum * (xnestWidth + xnestHeight) / 32)

-    

-  if (xnestDoFullGeneration) {

-

-    valuemask = CWBackPixel | CWEventMask | CWColormap;

-    attributes.background_pixel = xnestWhitePixel;

-    attributes.event_mask = xnestEventMask;

-    attributes.colormap = xnestDefaultVisualColormap(xnestDefaultVisual(pScreen));

-    

-    if (xnestParentWindow != 0) {

-      xnestDefaultWindows[pScreen->myNum] = xnestParentWindow;

-      XSelectInput (xnestDisplay, xnestDefaultWindows[pScreen->myNum],

-		    xnestEventMask);

-    } else

-      xnestDefaultWindows[pScreen->myNum] = 

-	XCreateWindow(xnestDisplay, 

-		      DefaultRootWindow(xnestDisplay),

-		      xnestX + POSITION_OFFSET,

-		      xnestY + POSITION_OFFSET,

-		      xnestWidth, xnestHeight,

-		      xnestBorderWidth,

-		      pScreen->rootDepth,

-		      InputOutput,

-		      xnestDefaultVisual(pScreen),

-		      valuemask, &attributes);

-

-    if (!xnestWindowName)

-      xnestWindowName = argv[0];

-    

-    sizeHints.flags = PPosition | PSize | PMaxSize;

-    sizeHints.x = xnestX + POSITION_OFFSET;

-    sizeHints.y = xnestY + POSITION_OFFSET;

-    sizeHints.width = sizeHints.max_width = xnestWidth;

-    sizeHints.height = sizeHints.max_height = xnestHeight;

-    if (xnestUserGeometry & XValue || xnestUserGeometry & YValue)

-      sizeHints.flags |= USPosition;

-    if (xnestUserGeometry & WidthValue || xnestUserGeometry & HeightValue)

-      sizeHints.flags |= USSize;

-    XSetStandardProperties(xnestDisplay, 

-			   xnestDefaultWindows[pScreen->myNum], 

-			   xnestWindowName, 

-			   xnestWindowName, 

-			   xnestIconBitmap,

-			   argv, argc, &sizeHints);

-    

-    XMapWindow(xnestDisplay, xnestDefaultWindows[pScreen->myNum]);

-

-    valuemask = CWBackPixmap | CWColormap;

-    attributes.background_pixmap = xnestScreenSaverPixmap;

-    attributes.colormap = 

-      DefaultColormap(xnestDisplay, DefaultScreen(xnestDisplay));

-    xnestScreenSaverWindows[pScreen->myNum] =

-      XCreateWindow(xnestDisplay, 

-		    xnestDefaultWindows[pScreen->myNum],

-		    0, 0, xnestWidth, xnestHeight, 0,

-		    DefaultDepth(xnestDisplay, DefaultScreen(xnestDisplay)),

-		    InputOutput, 

-		    DefaultVisual(xnestDisplay, DefaultScreen(xnestDisplay)),

-		    valuemask, &attributes);

-  }

-  

-  if (!xnestCreateDefaultColormap(pScreen)) return False;

-  

-  return True;

-}

-

-Bool

-xnestCloseScreen(int index, ScreenPtr pScreen)

-{

-  int i;

-  

-  for (i = 0; i < pScreen->numDepths; i++)

-    free(pScreen->allowedDepths[i].vids);

-  free(pScreen->allowedDepths);

-  free(pScreen->visuals);

-  free(pScreen->devPrivate);

-

-  /*

-    If xnestDoFullGeneration all x resources will be destroyed upon closing

-    the display connection.  There is no need to generate extra protocol.

-    */

-

-  return True;

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "scrnintstr.h"
+#include "dix.h"
+#include "mi.h"
+#include "mibstore.h"
+#include "micmap.h"
+#include "colormapst.h"
+#include "resource.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "Screen.h"
+#include "XNGC.h"
+#include "GCOps.h"
+#include "Drawable.h"
+#include "XNFont.h"
+#include "Color.h"
+#include "XNCursor.h"
+#include "Visual.h"
+#include "Events.h"
+#include "Init.h"
+#include "mipointer.h"
+#include "Args.h"
+#include "mipointrst.h"
+
+Window xnestDefaultWindows[MAXSCREENS];
+Window xnestScreenSaverWindows[MAXSCREENS];
+DevPrivateKeyRec xnestCursorScreenKeyRec;
+
+ScreenPtr
+xnestScreen(Window window)
+{
+    int i;
+
+    for (i = 0; i < xnestNumScreens; i++)
+        if (xnestDefaultWindows[i] == window)
+            return screenInfo.screens[i];
+
+    return NULL;
+}
+
+static int
+offset(unsigned long mask)
+{
+    int count;
+
+    for (count = 0; !(mask & 1) && count < 32; count++)
+        mask >>= 1;
+
+    return count;
+}
+
+static Bool
+xnestSaveScreen(ScreenPtr pScreen, int what)
+{
+    if (xnestSoftwareScreenSaver)
+        return False;
+    else {
+        switch (what) {
+        case SCREEN_SAVER_ON:
+            XMapRaised(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);
+            xnestSetScreenSaverColormapWindow(pScreen);
+            break;
+
+        case SCREEN_SAVER_OFF:
+            XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);
+            xnestSetInstalledColormapWindows(pScreen);
+            break;
+
+        case SCREEN_SAVER_FORCER:
+            lastEventTime = GetTimeInMillis();
+            XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);
+            xnestSetInstalledColormapWindows(pScreen);
+            break;
+
+        case SCREEN_SAVER_CYCLE:
+            XUnmapWindow(xnestDisplay, xnestScreenSaverWindows[pScreen->myNum]);
+            xnestSetInstalledColormapWindows(pScreen);
+            break;
+        }
+        return True;
+    }
+}
+
+static Bool
+xnestCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
+{
+    return FALSE;
+}
+
+static void
+xnestCrossScreen(ScreenPtr pScreen, Bool entering)
+{
+}
+
+static miPointerScreenFuncRec xnestPointerCursorFuncs = {
+    xnestCursorOffScreen,
+    xnestCrossScreen,
+    miPointerWarpCursor
+};
+
+static miPointerSpriteFuncRec xnestPointerSpriteFuncs = {
+    xnestRealizeCursor,
+    xnestUnrealizeCursor,
+    xnestSetCursor,
+    xnestMoveCursor,
+    xnestDeviceCursorInitialize,
+    xnestDeviceCursorCleanup
+};
+
+Bool
+xnestOpenScreen(int index, ScreenPtr pScreen, int argc, char *argv[])
+{
+    VisualPtr visuals;
+    DepthPtr depths;
+    int numVisuals, numDepths;
+    int i, j, depthIndex;
+    unsigned long valuemask;
+    XSetWindowAttributes attributes;
+    XWindowAttributes gattributes;
+    XSizeHints sizeHints;
+    VisualID defaultVisual;
+    int rootDepth;
+    miPointerScreenPtr PointPriv;
+
+    if (!dixRegisterPrivateKey
+        (&xnestWindowPrivateKeyRec, PRIVATE_WINDOW, sizeof(xnestPrivWin)))
+        return FALSE;
+    if (!dixRegisterPrivateKey
+        (&xnestGCPrivateKeyRec, PRIVATE_GC, sizeof(xnestPrivGC)))
+        return FALSE;
+    if (!dixRegisterPrivateKey
+        (&xnestPixmapPrivateKeyRec, PRIVATE_PIXMAP, sizeof(xnestPrivPixmap)))
+        return FALSE;
+    if (!dixRegisterPrivateKey
+        (&xnestColormapPrivateKeyRec, PRIVATE_COLORMAP,
+         sizeof(xnestPrivColormap)))
+        return FALSE;
+    if (!dixRegisterPrivateKey(&xnestCursorScreenKeyRec, PRIVATE_SCREEN, 0))
+        return FALSE;
+
+    visuals = (VisualPtr) malloc(xnestNumVisuals * sizeof(VisualRec));
+    numVisuals = 0;
+
+    depths = (DepthPtr) malloc(MAXDEPTH * sizeof(DepthRec));
+    depths[0].depth = 1;
+    depths[0].numVids = 0;
+    depths[0].vids = (VisualID *) malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
+    numDepths = 1;
+
+    for (i = 0; i < xnestNumVisuals; i++) {
+        visuals[numVisuals].class = xnestVisuals[i].class;
+        visuals[numVisuals].bitsPerRGBValue = xnestVisuals[i].bits_per_rgb;
+        visuals[numVisuals].ColormapEntries = xnestVisuals[i].colormap_size;
+        visuals[numVisuals].nplanes = xnestVisuals[i].depth;
+        visuals[numVisuals].redMask = xnestVisuals[i].red_mask;
+        visuals[numVisuals].greenMask = xnestVisuals[i].green_mask;
+        visuals[numVisuals].blueMask = xnestVisuals[i].blue_mask;
+        visuals[numVisuals].offsetRed = offset(xnestVisuals[i].red_mask);
+        visuals[numVisuals].offsetGreen = offset(xnestVisuals[i].green_mask);
+        visuals[numVisuals].offsetBlue = offset(xnestVisuals[i].blue_mask);
+
+        /* Check for and remove duplicates. */
+        for (j = 0; j < numVisuals; j++) {
+            if (visuals[numVisuals].class == visuals[j].class &&
+                visuals[numVisuals].bitsPerRGBValue ==
+                visuals[j].bitsPerRGBValue &&
+                visuals[numVisuals].ColormapEntries ==
+                visuals[j].ColormapEntries &&
+                visuals[numVisuals].nplanes == visuals[j].nplanes &&
+                visuals[numVisuals].redMask == visuals[j].redMask &&
+                visuals[numVisuals].greenMask == visuals[j].greenMask &&
+                visuals[numVisuals].blueMask == visuals[j].blueMask &&
+                visuals[numVisuals].offsetRed == visuals[j].offsetRed &&
+                visuals[numVisuals].offsetGreen == visuals[j].offsetGreen &&
+                visuals[numVisuals].offsetBlue == visuals[j].offsetBlue)
+                break;
+        }
+        if (j < numVisuals)
+            break;
+
+        visuals[numVisuals].vid = FakeClientID(0);
+
+        depthIndex = UNDEFINED;
+        for (j = 0; j < numDepths; j++)
+            if (depths[j].depth == xnestVisuals[i].depth) {
+                depthIndex = j;
+                break;
+            }
+
+        if (depthIndex == UNDEFINED) {
+            depthIndex = numDepths;
+            depths[depthIndex].depth = xnestVisuals[i].depth;
+            depths[depthIndex].numVids = 0;
+            depths[depthIndex].vids =
+                (VisualID *) malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
+            numDepths++;
+        }
+        if (depths[depthIndex].numVids >= MAXVISUALSPERDEPTH) {
+            FatalError("Visual table overflow");
+        }
+        depths[depthIndex].vids[depths[depthIndex].numVids] =
+            visuals[numVisuals].vid;
+        depths[depthIndex].numVids++;
+
+        numVisuals++;
+    }
+    visuals = (VisualPtr) realloc(visuals, numVisuals * sizeof(VisualRec));
+
+    defaultVisual = visuals[xnestDefaultVisualIndex].vid;
+    rootDepth = visuals[xnestDefaultVisualIndex].nplanes;
+
+    if (xnestParentWindow != 0) {
+        XGetWindowAttributes(xnestDisplay, xnestParentWindow, &gattributes);
+        xnestWidth = gattributes.width;
+        xnestHeight = gattributes.height;
+    }
+
+    /* myNum */
+    /* id */
+    miScreenInit(pScreen, NULL, xnestWidth, xnestHeight, 1, 1, xnestWidth, rootDepth, numDepths, depths, defaultVisual, /* root visual */
+                 numVisuals, visuals);
+
+    pScreen->defColormap = (Colormap) FakeClientID(0);
+    pScreen->minInstalledCmaps = MINCMAPS;
+    pScreen->maxInstalledCmaps = MAXCMAPS;
+    pScreen->backingStoreSupport = NotUseful;
+    pScreen->saveUnderSupport = NotUseful;
+    pScreen->whitePixel = xnestWhitePixel;
+    pScreen->blackPixel = xnestBlackPixel;
+    /* GCperDepth */
+    /* PixmapPerDepth */
+    pScreen->devPrivate = NULL;
+    /* WindowPrivateLen */
+    /* WindowPrivateSizes */
+    /* totalWindowSize */
+    /* GCPrivateLen */
+    /* GCPrivateSizes */
+    /* totalGCSize */
+
+    /* Random screen procedures */
+
+    pScreen->QueryBestSize = xnestQueryBestSize;
+    pScreen->SaveScreen = xnestSaveScreen;
+    pScreen->GetImage = xnestGetImage;
+    pScreen->GetSpans = xnestGetSpans;
+    pScreen->SourceValidate = NULL;
+
+    /* Window Procedures */
+
+    pScreen->CreateWindow = xnestCreateWindow;
+    pScreen->DestroyWindow = xnestDestroyWindow;
+    pScreen->PositionWindow = xnestPositionWindow;
+    pScreen->ChangeWindowAttributes = xnestChangeWindowAttributes;
+    pScreen->RealizeWindow = xnestRealizeWindow;
+    pScreen->UnrealizeWindow = xnestUnrealizeWindow;
+    pScreen->PostValidateTree = NULL;
+    pScreen->WindowExposures = xnestWindowExposures;
+    pScreen->CopyWindow = xnestCopyWindow;
+    pScreen->ClipNotify = xnestClipNotify;
+
+    /* Pixmap procedures */
+
+    pScreen->CreatePixmap = xnestCreatePixmap;
+    pScreen->DestroyPixmap = xnestDestroyPixmap;
+
+    /* Font procedures */
+
+    pScreen->RealizeFont = xnestRealizeFont;
+    pScreen->UnrealizeFont = xnestUnrealizeFont;
+
+    /* GC procedures */
+
+    pScreen->CreateGC = xnestCreateGC;
+
+    /* Colormap procedures */
+
+    pScreen->CreateColormap = xnestCreateColormap;
+    pScreen->DestroyColormap = xnestDestroyColormap;
+    pScreen->InstallColormap = xnestInstallColormap;
+    pScreen->UninstallColormap = xnestUninstallColormap;
+    pScreen->ListInstalledColormaps = xnestListInstalledColormaps;
+    pScreen->StoreColors = xnestStoreColors;
+    pScreen->ResolveColor = xnestResolveColor;
+
+    pScreen->BitmapToRegion = xnestPixmapToRegion;
+
+    /* OS layer procedures */
+
+    pScreen->BlockHandler = (ScreenBlockHandlerProcPtr) NoopDDA;
+    pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr) NoopDDA;
+    pScreen->blockData = NULL;
+    pScreen->wakeupData = NULL;
+
+    miDCInitialize(pScreen, &xnestPointerCursorFuncs);  /* init SW rendering */
+    PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);
+    xnestCursorFuncs.spriteFuncs = PointPriv->spriteFuncs;
+    dixSetPrivate(&pScreen->devPrivates, xnestCursorScreenKey,
+                  &xnestCursorFuncs);
+    PointPriv->spriteFuncs = &xnestPointerSpriteFuncs;
+
+    pScreen->mmWidth = xnestWidth * DisplayWidthMM(xnestDisplay,
+                                                   DefaultScreen(xnestDisplay))
+        / DisplayWidth(xnestDisplay, DefaultScreen(xnestDisplay));
+    pScreen->mmHeight =
+        xnestHeight * DisplayHeightMM(xnestDisplay,
+                                      DefaultScreen(xnestDisplay)) /
+        DisplayHeight(xnestDisplay, DefaultScreen(xnestDisplay));
+
+    /* overwrite miCloseScreen with our own */
+    pScreen->CloseScreen = xnestCloseScreen;
+
+    if (!miScreenDevPrivateInit(pScreen, xnestWidth, NULL))
+        return FALSE;
+
+    /* overwrite miSetShape with our own */
+    pScreen->SetShape = xnestSetShape;
+
+    /* devPrivates */
+
+#define POSITION_OFFSET (pScreen->myNum * (xnestWidth + xnestHeight) / 32)
+
+    if (xnestDoFullGeneration) {
+
+        valuemask = CWBackPixel | CWEventMask | CWColormap;
+        attributes.background_pixel = xnestWhitePixel;
+        attributes.event_mask = xnestEventMask;
+        attributes.colormap =
+            xnestDefaultVisualColormap(xnestDefaultVisual(pScreen));
+
+        if (xnestParentWindow != 0) {
+            xnestDefaultWindows[pScreen->myNum] = xnestParentWindow;
+            XSelectInput(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
+                         xnestEventMask);
+        }
+        else
+            xnestDefaultWindows[pScreen->myNum] =
+                XCreateWindow(xnestDisplay,
+                              DefaultRootWindow(xnestDisplay),
+                              xnestX + POSITION_OFFSET,
+                              xnestY + POSITION_OFFSET,
+                              xnestWidth, xnestHeight,
+                              xnestBorderWidth,
+                              pScreen->rootDepth,
+                              InputOutput,
+                              xnestDefaultVisual(pScreen),
+                              valuemask, &attributes);
+
+        if (!xnestWindowName)
+            xnestWindowName = argv[0];
+
+        sizeHints.flags = PPosition | PSize | PMaxSize;
+        sizeHints.x = xnestX + POSITION_OFFSET;
+        sizeHints.y = xnestY + POSITION_OFFSET;
+        sizeHints.width = sizeHints.max_width = xnestWidth;
+        sizeHints.height = sizeHints.max_height = xnestHeight;
+        if (xnestUserGeometry & XValue || xnestUserGeometry & YValue)
+            sizeHints.flags |= USPosition;
+        if (xnestUserGeometry & WidthValue || xnestUserGeometry & HeightValue)
+            sizeHints.flags |= USSize;
+        XSetStandardProperties(xnestDisplay,
+                               xnestDefaultWindows[pScreen->myNum],
+                               xnestWindowName,
+                               xnestWindowName,
+                               xnestIconBitmap, argv, argc, &sizeHints);
+
+        XMapWindow(xnestDisplay, xnestDefaultWindows[pScreen->myNum]);
+
+        valuemask = CWBackPixmap | CWColormap;
+        attributes.background_pixmap = xnestScreenSaverPixmap;
+        attributes.colormap =
+            DefaultColormap(xnestDisplay, DefaultScreen(xnestDisplay));
+        xnestScreenSaverWindows[pScreen->myNum] =
+            XCreateWindow(xnestDisplay,
+                          xnestDefaultWindows[pScreen->myNum],
+                          0, 0, xnestWidth, xnestHeight, 0,
+                          DefaultDepth(xnestDisplay,
+                                       DefaultScreen(xnestDisplay)),
+                          InputOutput, DefaultVisual(xnestDisplay,
+                                                     DefaultScreen
+                                                     (xnestDisplay)), valuemask,
+                          &attributes);
+    }
+
+    if (!xnestCreateDefaultColormap(pScreen))
+        return False;
+
+    return True;
+}
+
+Bool
+xnestCloseScreen(int index, ScreenPtr pScreen)
+{
+    int i;
+
+    for (i = 0; i < pScreen->numDepths; i++)
+        free(pScreen->allowedDepths[i].vids);
+    free(pScreen->allowedDepths);
+    free(pScreen->visuals);
+    free(pScreen->devPrivate);
+
+    /*
+       If xnestDoFullGeneration all x resources will be destroyed upon closing
+       the display connection.  There is no need to generate extra protocol.
+     */
+
+    return True;
+}
diff --git a/xorg-server/hw/xnest/Window.c b/xorg-server/hw/xnest/Window.c
index 7ef3d8b96..e2b21b58e 100644
--- a/xorg-server/hw/xnest/Window.c
+++ b/xorg-server/hw/xnest/Window.c
@@ -1,519 +1,517 @@
-/*

-

-Copyright 1993 by Davor Matic

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation.  Davor Matic makes no representations about

-the suitability of this software for any purpose.  It is provided "as

-is" without express or implied warranty.

-

-*/

-

-#ifdef HAVE_XNEST_CONFIG_H

-#include <xnest-config.h>

-#endif

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "gcstruct.h"

-#include "window.h"

-#include "windowstr.h"

-#include "pixmapstr.h"

-#include "colormapst.h"

-#include "scrnintstr.h"

-#include "region.h"

-

-#include "mi.h"

-

-#include "Xnest.h"

-

-#include "Display.h"

-#include "Screen.h"

-#include "XNGC.h"

-#include "Drawable.h"

-#include "Color.h"

-#include "Visual.h"

-#include "Events.h"

-#include "Args.h"

-

-DevPrivateKeyRec xnestWindowPrivateKeyRec;

-

-static int

-xnestFindWindowMatch(WindowPtr pWin, pointer ptr)

-{

-  xnestWindowMatch *wm = (xnestWindowMatch *)ptr;

-  if (wm->window == xnestWindow(pWin)) {

-    wm->pWin = pWin;

-    return WT_STOPWALKING;

-  }

-  else

-    return WT_WALKCHILDREN;

-}

-

-WindowPtr

-xnestWindowPtr(Window window)

-{

-  xnestWindowMatch wm;

-  int i;

-

-  wm.pWin = NullWindow;

-  wm.window = window;

-

-  for (i = 0; i < xnestNumScreens; i++) {

-    WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);

-    if (wm.pWin) break;

-  }

-  

-  return wm.pWin;

-}

-    

-Bool

-xnestCreateWindow(WindowPtr pWin)

-{

-  unsigned long mask;

-  XSetWindowAttributes attributes;

-  Visual *visual;

-  ColormapPtr pCmap;

-

-  if (pWin->drawable.class == InputOnly) {

-    mask = 0L;

-    visual = CopyFromParent;

-  }

-  else {

-    mask = CWEventMask | CWBackingStore;

-    attributes.event_mask = ExposureMask;

-    attributes.backing_store = NotUseful;

-    

-    if (pWin->parent) {

-      if (pWin->optional && pWin->optional->visual != wVisual(pWin->parent)) {

-	visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));

-	mask |= CWColormap;

-	if (pWin->optional->colormap) {

-	  dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),

-				  RT_COLORMAP, serverClient, DixUseAccess);

-	  attributes.colormap = xnestColormap(pCmap);

-	}

-	else

-	  attributes.colormap = xnestDefaultVisualColormap(visual);

-      }

-      else 

-	visual = CopyFromParent;

-    }

-    else { /* root windows have their own colormaps at creation time */

-      visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));      

-      dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin),

-			      RT_COLORMAP, serverClient, DixUseAccess);

-      mask |= CWColormap;

-      attributes.colormap = xnestColormap(pCmap);

-    }

-  }

-  

-  xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,

-						xnestWindowParent(pWin),

-						pWin->origin.x - 

-						wBorderWidth(pWin),

-						pWin->origin.y - 

-						wBorderWidth(pWin),

-						pWin->drawable.width,

-						pWin->drawable.height,

-						pWin->borderWidth,

-						pWin->drawable.depth, 

-						pWin->drawable.class,

-						visual,

-						mask, &attributes);

-  xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);

-  xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);

-  xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);

-  xnestWindowPriv(pWin)->width = pWin->drawable.width;

-  xnestWindowPriv(pWin)->height = pWin->drawable.height;

-  xnestWindowPriv(pWin)->border_width = pWin->borderWidth;

-  xnestWindowPriv(pWin)->sibling_above = None;

-  if (pWin->nextSib)

-    xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);

-  xnestWindowPriv(pWin)->bounding_shape = 

-    RegionCreate(NULL, 1);

-  xnestWindowPriv(pWin)->clip_shape = 

-    RegionCreate(NULL, 1);

-

-  if (!pWin->parent) /* only the root window will have the right colormap */

-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

-  

-  return True;

-}

-

-Bool

-xnestDestroyWindow(WindowPtr pWin)

-{

-  if (pWin->nextSib)

-    xnestWindowPriv(pWin->nextSib)->sibling_above = 

-      xnestWindowPriv(pWin)->sibling_above;

-  RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);

-  RegionDestroy(xnestWindowPriv(pWin)->clip_shape);

-  XDestroyWindow(xnestDisplay, xnestWindow(pWin));

-  xnestWindowPriv(pWin)->window = None;

-

-  if (pWin->optional && pWin->optional->colormap && pWin->parent)

-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

-

-  return True;

-}

-

-Bool

-xnestPositionWindow(WindowPtr pWin, int x, int y)

-{

-  xnestConfigureWindow(pWin, 

-		       CWParent |

-		       CWX | CWY | 

-		       CWWidth | CWHeight | 

-		       CWBorderWidth);

-  

-  return True;

-}

-

-void

-xnestConfigureWindow(WindowPtr pWin, unsigned int mask)

-{

-  unsigned int valuemask;

-  XWindowChanges values;

-

-  if (mask & CWParent &&

-      xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {

-    XReparentWindow(xnestDisplay, xnestWindow(pWin), 

-		    xnestWindowParent(pWin), 

-		    pWin->origin.x - wBorderWidth(pWin),

-		    pWin->origin.y - wBorderWidth(pWin));

-    xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);

-    xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);

-    xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);

-    xnestWindowPriv(pWin)->sibling_above = None;

-    if (pWin->nextSib)

-      xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);

-  }

-  

-  valuemask = 0;

-  

-  if (mask & CWX &&

-      xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {

-    valuemask |= CWX;

-    values.x =

-      xnestWindowPriv(pWin)->x = 

-	pWin->origin.x - wBorderWidth(pWin);

-  }

-

-  if (mask & CWY &&

-      xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {

-    valuemask |= CWY;

-    values.y =

-      xnestWindowPriv(pWin)->y = 

-	pWin->origin.y - wBorderWidth(pWin);

-  }

-

-  if (mask & CWWidth &&

-      xnestWindowPriv(pWin)->width != pWin->drawable.width) {

-    valuemask |= CWWidth;

-    values.width = 

-      xnestWindowPriv(pWin)->width = 

-	pWin->drawable.width;

-  }

-  

-  if (mask & CWHeight &&

-      xnestWindowPriv(pWin)->height != pWin->drawable.height) {

-    valuemask |= CWHeight;

-    values.height = 

-      xnestWindowPriv(pWin)->height = 

-	pWin->drawable.height;

-  }

-  

-  if (mask & CWBorderWidth &&

-      xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {

-    valuemask |= CWBorderWidth;

-    values.border_width = 

-      xnestWindowPriv(pWin)->border_width = 

-	pWin->borderWidth;

-  }

- 

-  if (valuemask)

-    XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);  

-  

-  if (mask & CWStackingOrder &&

-      xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {

-    WindowPtr pSib;

-    

-    /* find the top sibling */

-    for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);

-    

-    /* the top sibling */

-    valuemask = CWStackMode;

-    values.stack_mode = Above;

-    XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values); 

-    xnestWindowPriv(pSib)->sibling_above = None;

-

-    /* the rest of siblings */

-    for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {

-      valuemask = CWSibling | CWStackMode;

-      values.sibling = xnestWindowSiblingAbove(pSib);

-      values.stack_mode = Below;

-      XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);

-      xnestWindowPriv(pSib)->sibling_above = xnestWindowSiblingAbove(pSib);

-    }

-  }

-}

-

-Bool

-xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)

-{

-  XSetWindowAttributes attributes;

-  

-  if (mask & CWBackPixmap)

-    switch (pWin->backgroundState) {

-    case None:

-      attributes.background_pixmap = None;

-      break;

-      

-    case ParentRelative:

-      attributes.background_pixmap = ParentRelative;

-      break;

-      

-    case BackgroundPixmap:

-      attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);

-      break;

-

-    case BackgroundPixel:

-      mask &= ~CWBackPixmap;  

-      break;

-    }

-

-  if (mask & CWBackPixel) {

-    if (pWin->backgroundState == BackgroundPixel)

-      attributes.background_pixel = xnestPixel(pWin->background.pixel);

-    else

-      mask &= ~CWBackPixel;

-  }

-  

-  if (mask & CWBorderPixmap) {

-    if (pWin->borderIsPixel)

-      mask &= ~CWBorderPixmap;

-    else

-      attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);

-  }

-  

-  if (mask & CWBorderPixel) {

-    if (pWin->borderIsPixel)

-      attributes.border_pixel = xnestPixel(pWin->border.pixel);

-    else

-      mask &= ~CWBorderPixel;

-  }

-  

-  if (mask & CWBitGravity) 

-    attributes.bit_gravity = pWin->bitGravity;

-  

-  if (mask & CWWinGravity) /* dix does this for us */

-    mask &= ~CWWinGravity;

-

-  if (mask & CWBackingStore) /* this is really not useful */

-    mask &= ~CWBackingStore;

-

-  if (mask & CWBackingPlanes) /* this is really not useful */

-    mask &= ~CWBackingPlanes;

-

-  if (mask & CWBackingPixel) /* this is really not useful */ 

-    mask &= ~CWBackingPixel;

-

-  if (mask & CWOverrideRedirect)

-    attributes.override_redirect = pWin->overrideRedirect;

-

-  if (mask & CWSaveUnder) /* this is really not useful */

-    mask &= ~CWSaveUnder;

-

-  if (mask & CWEventMask) /* events are handled elsewhere */

-    mask &= ~CWEventMask;

-

-  if (mask & CWDontPropagate) /* events are handled elsewhere */

-    mask &= ~CWDontPropagate; 

-

-  if (mask & CWColormap) {

-    ColormapPtr pCmap;

-    

-    dixLookupResourceByType((pointer *)&pCmap, wColormap(pWin), RT_COLORMAP,

-			    serverClient, DixUseAccess);

-

-    attributes.colormap = xnestColormap(pCmap);

-

-    xnestSetInstalledColormapWindows(pWin->drawable.pScreen);

-  }

-

-  if (mask & CWCursor) /* this is handeled in cursor code */

-    mask &= ~CWCursor;

-

-  if (mask)

-    XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),

-			    mask, &attributes);

-  

-  return True;

-}	  

-

-Bool

-xnestRealizeWindow(WindowPtr pWin)

-{

-  xnestConfigureWindow(pWin, CWStackingOrder);

-  xnestShapeWindow(pWin);

-  XMapWindow(xnestDisplay, xnestWindow(pWin));

-

-  return True;

-}

-

-Bool

-xnestUnrealizeWindow(WindowPtr pWin)

-{

-  XUnmapWindow(xnestDisplay, xnestWindow(pWin));

-

-  return True;

-}

-

-void

-xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)

-{

-}

-

-void

-xnestClipNotify(WindowPtr pWin, int dx, int dy)

-{

-  xnestConfigureWindow(pWin, CWStackingOrder); 

-  xnestShapeWindow(pWin);

-}

-

-static Bool

-xnestWindowExposurePredicate(Display *display, XEvent *event, XPointer ptr)

-{

-  return (event->type == Expose && event->xexpose.window == *(Window *)ptr);

-}

-

-void

-xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)

-{

-  XEvent event;

-  Window window;

-  BoxRec Box;

-  

-  XSync(xnestDisplay, False);

-  

-  window = xnestWindow(pWin);

-  

-  while (XCheckIfEvent(xnestDisplay, &event, 

-		       xnestWindowExposurePredicate, (char *)&window)) {

-    

-    Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;

-    Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;

-    Box.x2 = Box.x1 + event.xexpose.width;

-    Box.y2 = Box.y1 + event.xexpose.height;

-	

-    event.xexpose.type = ProcessedExpose;

-	

-    if (RegionContainsRect(pRgn, &Box) != rgnIN)

-      XPutBackEvent(xnestDisplay, &event);

-  }

-  

-  miWindowExposures(pWin, pRgn, other_exposed);

-}

-

-void

-xnestSetShape(WindowPtr pWin, int kind)

-{

-  xnestShapeWindow(pWin);

-  miSetShape(pWin, kind);

-}

-

-static Bool

-xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)

-{

-  BoxPtr pBox1, pBox2;

-  unsigned int n1, n2;

-

-  if (pReg1 == pReg2) return True;

-

-  if (pReg1 == NullRegion || pReg2 == NullRegion) return False;

-

-  pBox1 = RegionRects(pReg1);

-  n1 = RegionNumRects(pReg1);

-

-  pBox2 = RegionRects(pReg2);

-  n2 = RegionNumRects(pReg2);

-

-  if (n1 != n2) return False;

-

-  if (pBox1 == pBox2) return True;

-

-  if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec))) return False;

-

-  return True;

-}

-

-void

-xnestShapeWindow(WindowPtr pWin)

-{

-  Region reg;

-  BoxPtr pBox;

-  XRectangle rect;

-  int i;

-

-  if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,

-			wBoundingShape(pWin))) {

-    

-    if (wBoundingShape(pWin)) {

-      RegionCopy(xnestWindowPriv(pWin)->bounding_shape, wBoundingShape(pWin));

-      

-      reg = XCreateRegion();

-      pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);

-      for (i = 0; 

-	   i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);

-	   i++) {

-        rect.x = pBox[i].x1;

-        rect.y = pBox[i].y1;

-        rect.width = pBox[i].x2 - pBox[i].x1;

-        rect.height = pBox[i].y2 - pBox[i].y1;

-        XUnionRectWithRegion(&rect, reg, reg);

-      }

-      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),

-			  ShapeBounding, 0, 0, reg, ShapeSet);

-      XDestroyRegion(reg);

-    }

-    else {

-      RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);

-      

-      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),

-			ShapeBounding, 0, 0, None, ShapeSet);

-    }

-  }

-  

-  if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape,

-			wClipShape(pWin))) {

-    

-    if (wClipShape(pWin)) {

-      RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));

-      

-      reg = XCreateRegion();

-      pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);

-      for (i = 0; 

-	   i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape);

-	   i++) {

-        rect.x = pBox[i].x1;

-        rect.y = pBox[i].y1;

-        rect.width = pBox[i].x2 - pBox[i].x1;

-        rect.height = pBox[i].y2 - pBox[i].y1;

-        XUnionRectWithRegion(&rect, reg, reg);

-      }

-      XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),

-			  ShapeClip, 0, 0, reg, ShapeSet);

-      XDestroyRegion(reg);

-    }

-    else {

-      RegionEmpty(xnestWindowPriv(pWin)->clip_shape);

-      

-      XShapeCombineMask(xnestDisplay, xnestWindow(pWin),

-			ShapeClip, 0, 0, None, ShapeSet);

-    }

-  }

-}

+/*
+
+Copyright 1993 by Davor Matic
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.  Davor Matic makes no representations about
+the suitability of this software for any purpose.  It is provided "as
+is" without express or implied warranty.
+
+*/
+
+#ifdef HAVE_XNEST_CONFIG_H
+#include <xnest-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "gcstruct.h"
+#include "window.h"
+#include "windowstr.h"
+#include "pixmapstr.h"
+#include "colormapst.h"
+#include "scrnintstr.h"
+#include "region.h"
+
+#include "mi.h"
+
+#include "Xnest.h"
+
+#include "Display.h"
+#include "Screen.h"
+#include "XNGC.h"
+#include "Drawable.h"
+#include "Color.h"
+#include "Visual.h"
+#include "Events.h"
+#include "Args.h"
+
+DevPrivateKeyRec xnestWindowPrivateKeyRec;
+
+static int
+xnestFindWindowMatch(WindowPtr pWin, pointer ptr)
+{
+    xnestWindowMatch *wm = (xnestWindowMatch *) ptr;
+
+    if (wm->window == xnestWindow(pWin)) {
+        wm->pWin = pWin;
+        return WT_STOPWALKING;
+    }
+    else
+        return WT_WALKCHILDREN;
+}
+
+WindowPtr
+xnestWindowPtr(Window window)
+{
+    xnestWindowMatch wm;
+    int i;
+
+    wm.pWin = NullWindow;
+    wm.window = window;
+
+    for (i = 0; i < xnestNumScreens; i++) {
+        WalkTree(screenInfo.screens[i], xnestFindWindowMatch, (pointer) &wm);
+        if (wm.pWin)
+            break;
+    }
+
+    return wm.pWin;
+}
+
+Bool
+xnestCreateWindow(WindowPtr pWin)
+{
+    unsigned long mask;
+    XSetWindowAttributes attributes;
+    Visual *visual;
+    ColormapPtr pCmap;
+
+    if (pWin->drawable.class == InputOnly) {
+        mask = 0L;
+        visual = CopyFromParent;
+    }
+    else {
+        mask = CWEventMask | CWBackingStore;
+        attributes.event_mask = ExposureMask;
+        attributes.backing_store = NotUseful;
+
+        if (pWin->parent) {
+            if (pWin->optional &&
+                pWin->optional->visual != wVisual(pWin->parent)) {
+                visual =
+                    xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
+                mask |= CWColormap;
+                if (pWin->optional->colormap) {
+                    dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
+                                            RT_COLORMAP, serverClient,
+                                            DixUseAccess);
+                    attributes.colormap = xnestColormap(pCmap);
+                }
+                else
+                    attributes.colormap = xnestDefaultVisualColormap(visual);
+            }
+            else
+                visual = CopyFromParent;
+        }
+        else {                  /* root windows have their own colormaps at creation time */
+            visual = xnestVisualFromID(pWin->drawable.pScreen, wVisual(pWin));
+            dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
+                                    RT_COLORMAP, serverClient, DixUseAccess);
+            mask |= CWColormap;
+            attributes.colormap = xnestColormap(pCmap);
+        }
+    }
+
+    xnestWindowPriv(pWin)->window = XCreateWindow(xnestDisplay,
+                                                  xnestWindowParent(pWin),
+                                                  pWin->origin.x -
+                                                  wBorderWidth(pWin),
+                                                  pWin->origin.y -
+                                                  wBorderWidth(pWin),
+                                                  pWin->drawable.width,
+                                                  pWin->drawable.height,
+                                                  pWin->borderWidth,
+                                                  pWin->drawable.depth,
+                                                  pWin->drawable.class,
+                                                  visual, mask, &attributes);
+    xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
+    xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
+    xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
+    xnestWindowPriv(pWin)->width = pWin->drawable.width;
+    xnestWindowPriv(pWin)->height = pWin->drawable.height;
+    xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
+    xnestWindowPriv(pWin)->sibling_above = None;
+    if (pWin->nextSib)
+        xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
+    xnestWindowPriv(pWin)->bounding_shape = RegionCreate(NULL, 1);
+    xnestWindowPriv(pWin)->clip_shape = RegionCreate(NULL, 1);
+
+    if (!pWin->parent)          /* only the root window will have the right colormap */
+        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
+
+    return True;
+}
+
+Bool
+xnestDestroyWindow(WindowPtr pWin)
+{
+    if (pWin->nextSib)
+        xnestWindowPriv(pWin->nextSib)->sibling_above =
+            xnestWindowPriv(pWin)->sibling_above;
+    RegionDestroy(xnestWindowPriv(pWin)->bounding_shape);
+    RegionDestroy(xnestWindowPriv(pWin)->clip_shape);
+    XDestroyWindow(xnestDisplay, xnestWindow(pWin));
+    xnestWindowPriv(pWin)->window = None;
+
+    if (pWin->optional && pWin->optional->colormap && pWin->parent)
+        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
+
+    return True;
+}
+
+Bool
+xnestPositionWindow(WindowPtr pWin, int x, int y)
+{
+    xnestConfigureWindow(pWin,
+                         CWParent |
+                         CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
+
+    return True;
+}
+
+void
+xnestConfigureWindow(WindowPtr pWin, unsigned int mask)
+{
+    unsigned int valuemask;
+    XWindowChanges values;
+
+    if (mask & CWParent &&
+        xnestWindowPriv(pWin)->parent != xnestWindowParent(pWin)) {
+        XReparentWindow(xnestDisplay, xnestWindow(pWin),
+                        xnestWindowParent(pWin),
+                        pWin->origin.x - wBorderWidth(pWin),
+                        pWin->origin.y - wBorderWidth(pWin));
+        xnestWindowPriv(pWin)->parent = xnestWindowParent(pWin);
+        xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
+        xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
+        xnestWindowPriv(pWin)->sibling_above = None;
+        if (pWin->nextSib)
+            xnestWindowPriv(pWin->nextSib)->sibling_above = xnestWindow(pWin);
+    }
+
+    valuemask = 0;
+
+    if (mask & CWX &&
+        xnestWindowPriv(pWin)->x != pWin->origin.x - wBorderWidth(pWin)) {
+        valuemask |= CWX;
+        values.x =
+            xnestWindowPriv(pWin)->x = pWin->origin.x - wBorderWidth(pWin);
+    }
+
+    if (mask & CWY &&
+        xnestWindowPriv(pWin)->y != pWin->origin.y - wBorderWidth(pWin)) {
+        valuemask |= CWY;
+        values.y =
+            xnestWindowPriv(pWin)->y = pWin->origin.y - wBorderWidth(pWin);
+    }
+
+    if (mask & CWWidth && xnestWindowPriv(pWin)->width != pWin->drawable.width) {
+        valuemask |= CWWidth;
+        values.width = xnestWindowPriv(pWin)->width = pWin->drawable.width;
+    }
+
+    if (mask & CWHeight &&
+        xnestWindowPriv(pWin)->height != pWin->drawable.height) {
+        valuemask |= CWHeight;
+        values.height = xnestWindowPriv(pWin)->height = pWin->drawable.height;
+    }
+
+    if (mask & CWBorderWidth &&
+        xnestWindowPriv(pWin)->border_width != pWin->borderWidth) {
+        valuemask |= CWBorderWidth;
+        values.border_width =
+            xnestWindowPriv(pWin)->border_width = pWin->borderWidth;
+    }
+
+    if (valuemask)
+        XConfigureWindow(xnestDisplay, xnestWindow(pWin), valuemask, &values);
+
+    if (mask & CWStackingOrder &&
+        xnestWindowPriv(pWin)->sibling_above != xnestWindowSiblingAbove(pWin)) {
+        WindowPtr pSib;
+
+        /* find the top sibling */
+        for (pSib = pWin; pSib->prevSib != NullWindow; pSib = pSib->prevSib);
+
+        /* the top sibling */
+        valuemask = CWStackMode;
+        values.stack_mode = Above;
+        XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask, &values);
+        xnestWindowPriv(pSib)->sibling_above = None;
+
+        /* the rest of siblings */
+        for (pSib = pSib->nextSib; pSib != NullWindow; pSib = pSib->nextSib) {
+            valuemask = CWSibling | CWStackMode;
+            values.sibling = xnestWindowSiblingAbove(pSib);
+            values.stack_mode = Below;
+            XConfigureWindow(xnestDisplay, xnestWindow(pSib), valuemask,
+                             &values);
+            xnestWindowPriv(pSib)->sibling_above =
+                xnestWindowSiblingAbove(pSib);
+        }
+    }
+}
+
+Bool
+xnestChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
+{
+    XSetWindowAttributes attributes;
+
+    if (mask & CWBackPixmap)
+        switch (pWin->backgroundState) {
+        case None:
+            attributes.background_pixmap = None;
+            break;
+
+        case ParentRelative:
+            attributes.background_pixmap = ParentRelative;
+            break;
+
+        case BackgroundPixmap:
+            attributes.background_pixmap = xnestPixmap(pWin->background.pixmap);
+            break;
+
+        case BackgroundPixel:
+            mask &= ~CWBackPixmap;
+            break;
+        }
+
+    if (mask & CWBackPixel) {
+        if (pWin->backgroundState == BackgroundPixel)
+            attributes.background_pixel = xnestPixel(pWin->background.pixel);
+        else
+            mask &= ~CWBackPixel;
+    }
+
+    if (mask & CWBorderPixmap) {
+        if (pWin->borderIsPixel)
+            mask &= ~CWBorderPixmap;
+        else
+            attributes.border_pixmap = xnestPixmap(pWin->border.pixmap);
+    }
+
+    if (mask & CWBorderPixel) {
+        if (pWin->borderIsPixel)
+            attributes.border_pixel = xnestPixel(pWin->border.pixel);
+        else
+            mask &= ~CWBorderPixel;
+    }
+
+    if (mask & CWBitGravity)
+        attributes.bit_gravity = pWin->bitGravity;
+
+    if (mask & CWWinGravity)    /* dix does this for us */
+        mask &= ~CWWinGravity;
+
+    if (mask & CWBackingStore)  /* this is really not useful */
+        mask &= ~CWBackingStore;
+
+    if (mask & CWBackingPlanes) /* this is really not useful */
+        mask &= ~CWBackingPlanes;
+
+    if (mask & CWBackingPixel)  /* this is really not useful */
+        mask &= ~CWBackingPixel;
+
+    if (mask & CWOverrideRedirect)
+        attributes.override_redirect = pWin->overrideRedirect;
+
+    if (mask & CWSaveUnder)     /* this is really not useful */
+        mask &= ~CWSaveUnder;
+
+    if (mask & CWEventMask)     /* events are handled elsewhere */
+        mask &= ~CWEventMask;
+
+    if (mask & CWDontPropagate) /* events are handled elsewhere */
+        mask &= ~CWDontPropagate;
+
+    if (mask & CWColormap) {
+        ColormapPtr pCmap;
+
+        dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
+                                RT_COLORMAP, serverClient, DixUseAccess);
+
+        attributes.colormap = xnestColormap(pCmap);
+
+        xnestSetInstalledColormapWindows(pWin->drawable.pScreen);
+    }
+
+    if (mask & CWCursor)        /* this is handeled in cursor code */
+        mask &= ~CWCursor;
+
+    if (mask)
+        XChangeWindowAttributes(xnestDisplay, xnestWindow(pWin),
+                                mask, &attributes);
+
+    return True;
+}
+
+Bool
+xnestRealizeWindow(WindowPtr pWin)
+{
+    xnestConfigureWindow(pWin, CWStackingOrder);
+    xnestShapeWindow(pWin);
+    XMapWindow(xnestDisplay, xnestWindow(pWin));
+
+    return True;
+}
+
+Bool
+xnestUnrealizeWindow(WindowPtr pWin)
+{
+    XUnmapWindow(xnestDisplay, xnestWindow(pWin));
+
+    return True;
+}
+
+void
+xnestCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
+{
+}
+
+void
+xnestClipNotify(WindowPtr pWin, int dx, int dy)
+{
+    xnestConfigureWindow(pWin, CWStackingOrder);
+    xnestShapeWindow(pWin);
+}
+
+static Bool
+xnestWindowExposurePredicate(Display * display, XEvent * event, XPointer ptr)
+{
+    return (event->type == Expose && event->xexpose.window == *(Window *) ptr);
+}
+
+void
+xnestWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_exposed)
+{
+    XEvent event;
+    Window window;
+    BoxRec Box;
+
+    XSync(xnestDisplay, False);
+
+    window = xnestWindow(pWin);
+
+    while (XCheckIfEvent(xnestDisplay, &event,
+                         xnestWindowExposurePredicate, (char *) &window)) {
+
+        Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + event.xexpose.x;
+        Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + event.xexpose.y;
+        Box.x2 = Box.x1 + event.xexpose.width;
+        Box.y2 = Box.y1 + event.xexpose.height;
+
+        event.xexpose.type = ProcessedExpose;
+
+        if (RegionContainsRect(pRgn, &Box) != rgnIN)
+            XPutBackEvent(xnestDisplay, &event);
+    }
+
+    miWindowExposures(pWin, pRgn, other_exposed);
+}
+
+void
+xnestSetShape(WindowPtr pWin, int kind)
+{
+    xnestShapeWindow(pWin);
+    miSetShape(pWin, kind);
+}
+
+static Bool
+xnestRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
+{
+    BoxPtr pBox1, pBox2;
+    unsigned int n1, n2;
+
+    if (pReg1 == pReg2)
+        return True;
+
+    if (pReg1 == NullRegion || pReg2 == NullRegion)
+        return False;
+
+    pBox1 = RegionRects(pReg1);
+    n1 = RegionNumRects(pReg1);
+
+    pBox2 = RegionRects(pReg2);
+    n2 = RegionNumRects(pReg2);
+
+    if (n1 != n2)
+        return False;
+
+    if (pBox1 == pBox2)
+        return True;
+
+    if (memcmp(pBox1, pBox2, n1 * sizeof(BoxRec)))
+        return False;
+
+    return True;
+}
+
+void
+xnestShapeWindow(WindowPtr pWin)
+{
+    Region reg;
+    BoxPtr pBox;
+    XRectangle rect;
+    int i;
+
+    if (!xnestRegionEqual(xnestWindowPriv(pWin)->bounding_shape,
+                          wBoundingShape(pWin))) {
+
+        if (wBoundingShape(pWin)) {
+            RegionCopy(xnestWindowPriv(pWin)->bounding_shape,
+                       wBoundingShape(pWin));
+
+            reg = XCreateRegion();
+            pBox = RegionRects(xnestWindowPriv(pWin)->bounding_shape);
+            for (i = 0;
+                 i < RegionNumRects(xnestWindowPriv(pWin)->bounding_shape);
+                 i++) {
+                rect.x = pBox[i].x1;
+                rect.y = pBox[i].y1;
+                rect.width = pBox[i].x2 - pBox[i].x1;
+                rect.height = pBox[i].y2 - pBox[i].y1;
+                XUnionRectWithRegion(&rect, reg, reg);
+            }
+            XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
+                                ShapeBounding, 0, 0, reg, ShapeSet);
+            XDestroyRegion(reg);
+        }
+        else {
+            RegionEmpty(xnestWindowPriv(pWin)->bounding_shape);
+
+            XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
+                              ShapeBounding, 0, 0, None, ShapeSet);
+        }
+    }
+
+    if (!xnestRegionEqual(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin))) {
+
+        if (wClipShape(pWin)) {
+            RegionCopy(xnestWindowPriv(pWin)->clip_shape, wClipShape(pWin));
+
+            reg = XCreateRegion();
+            pBox = RegionRects(xnestWindowPriv(pWin)->clip_shape);
+            for (i = 0;
+                 i < RegionNumRects(xnestWindowPriv(pWin)->clip_shape); i++) {
+                rect.x = pBox[i].x1;
+                rect.y = pBox[i].y1;
+                rect.width = pBox[i].x2 - pBox[i].x1;
+                rect.height = pBox[i].y2 - pBox[i].y1;
+                XUnionRectWithRegion(&rect, reg, reg);
+            }
+            XShapeCombineRegion(xnestDisplay, xnestWindow(pWin),
+                                ShapeClip, 0, 0, reg, ShapeSet);
+            XDestroyRegion(reg);
+        }
+        else {
+            RegionEmpty(xnestWindowPriv(pWin)->clip_shape);
+
+            XShapeCombineMask(xnestDisplay, xnestWindow(pWin),
+                              ShapeClip, 0, 0, None, ShapeSet);
+        }
+    }
+}
diff --git a/xorg-server/hw/xnest/XNCursor.h b/xorg-server/hw/xnest/XNCursor.h
index 473b2017f..1a3c6f44e 100644
--- a/xorg-server/hw/xnest/XNCursor.h
+++ b/xorg-server/hw/xnest/XNCursor.h
@@ -22,11 +22,12 @@ typedef struct {
 } xnestCursorFuncRec, *xnestCursorFuncPtr;
 
 extern DevPrivateKeyRec xnestCursorScreenKeyRec;
+
 #define xnestCursorScreenKey (&xnestCursorScreenKeyRec)
 extern xnestCursorFuncRec xnestCursorFuncs;
 
 typedef struct {
-  Cursor cursor;
+    Cursor cursor;
 } xnestPrivCursor;
 
 #define xnestGetCursorPriv(pCursor, pScreen) ((xnestPrivCursor *) \
@@ -39,21 +40,13 @@ typedef struct {
   (xnestGetCursorPriv(pCursor, pScreen)->cursor)
 
 Bool xnestRealizeCursor(DeviceIntPtr pDev,
-                        ScreenPtr pScreen,
-                        CursorPtr pCursor);
+                        ScreenPtr pScreen, CursorPtr pCursor);
 Bool xnestUnrealizeCursor(DeviceIntPtr pDev,
-                          ScreenPtr pScreen,
-                          CursorPtr pCursor);
-void xnestRecolorCursor(ScreenPtr pScreen,
-                        CursorPtr pCursor,
-                        Bool displayed);
-void xnestSetCursor (DeviceIntPtr pDev,
-                     ScreenPtr pScreen,
-                     CursorPtr pCursor,
-                     int x, int y);
-void xnestMoveCursor (DeviceIntPtr pDev,
-                      ScreenPtr pScreen,
-                      int x, int y);
+                          ScreenPtr pScreen, CursorPtr pCursor);
+void xnestRecolorCursor(ScreenPtr pScreen, CursorPtr pCursor, Bool displayed);
+void xnestSetCursor(DeviceIntPtr pDev,
+                    ScreenPtr pScreen, CursorPtr pCursor, int x, int y);
+void xnestMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y);
 Bool xnestDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen);
 void xnestDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen);
-#endif /* XNESTCURSOR_H */
+#endif                          /* XNESTCURSOR_H */