libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 926 insertions, 844 deletions

diff --git a/xorg-server/hw/dmx/dmxextension.c b/xorg-server/hw/dmx/dmxextension.c
index 80d11ee89..faa28a590 100644
--- a/xorg-server/hw/dmx/dmxextension.c
+++ b/xorg-server/hw/dmx/dmxextension.c
@@ -60,86 +60,89 @@
 #include "input/dmxinputinit.h"
 
 #include "windowstr.h"
-#include "inputstr.h"                 /* For DeviceIntRec */
-#include <X11/extensions/dmxproto.h>  /* For DMX_BAD_* */
+#include "inputstr.h"           /* For DeviceIntRec */
+#include <X11/extensions/dmxproto.h>    /* For DMX_BAD_* */
 #include "cursorstr.h"
 
 /* The default font is declared in dix/globals.c, but is not included in
  * _any_ header files. */
-extern FontPtr  defaultFont;
-    
+extern FontPtr defaultFont;
+
 /** This routine provides information to the DMX protocol extension
  * about a particular screen. */
-Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)
+Bool
+dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)
 {
     DMXScreenInfo *dmxScreen;
 
-    if (physical < 0 || physical >= dmxNumScreens) return FALSE;
+    if (physical < 0 || physical >= dmxNumScreens)
+        return FALSE;
 
     dmxScreen = &dmxScreens[physical];
-    attr->displayName         = dmxScreen->name;
+    attr->displayName = dmxScreen->name;
 #ifdef PANORAMIX
-    attr->logicalScreen       = noPanoramiXExtension ? dmxScreen->index : 0;
+    attr->logicalScreen = noPanoramiXExtension ? dmxScreen->index : 0;
 #else
-    attr->logicalScreen       = dmxScreen->index;
+    attr->logicalScreen = dmxScreen->index;
 #endif
 
-    attr->screenWindowWidth   = dmxScreen->scrnWidth;
-    attr->screenWindowHeight  = dmxScreen->scrnHeight;
+    attr->screenWindowWidth = dmxScreen->scrnWidth;
+    attr->screenWindowHeight = dmxScreen->scrnHeight;
     attr->screenWindowXoffset = dmxScreen->scrnX;
     attr->screenWindowYoffset = dmxScreen->scrnY;
 
-    attr->rootWindowWidth     = dmxScreen->rootWidth;
-    attr->rootWindowHeight    = dmxScreen->rootHeight;
-    attr->rootWindowXoffset   = dmxScreen->rootX;
-    attr->rootWindowYoffset   = dmxScreen->rootY;
+    attr->rootWindowWidth = dmxScreen->rootWidth;
+    attr->rootWindowHeight = dmxScreen->rootHeight;
+    attr->rootWindowXoffset = dmxScreen->rootX;
+    attr->rootWindowYoffset = dmxScreen->rootY;
 
-    attr->rootWindowXorigin   = dmxScreen->rootXOrigin;
-    attr->rootWindowYorigin   = dmxScreen->rootYOrigin;
+    attr->rootWindowXorigin = dmxScreen->rootXOrigin;
+    attr->rootWindowYorigin = dmxScreen->rootYOrigin;
 
     return TRUE;
 }
 
 /** This routine provides information to the DMX protocol extension
  * about a particular window. */
-Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr)
+Bool
+dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr)
 {
     dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
 
-    attr->screen         = pWindow->drawable.pScreen->myNum;
-    attr->window         = pWinPriv->window;
+    attr->screen = pWindow->drawable.pScreen->myNum;
+    attr->window = pWinPriv->window;
 
-    attr->pos.x          = pWindow->drawable.x;
-    attr->pos.y          = pWindow->drawable.y;
-    attr->pos.width      = pWindow->drawable.width;
-    attr->pos.height     = pWindow->drawable.height;
+    attr->pos.x = pWindow->drawable.x;
+    attr->pos.y = pWindow->drawable.y;
+    attr->pos.width = pWindow->drawable.width;
+    attr->pos.height = pWindow->drawable.height;
 
     if (!pWinPriv->window || pWinPriv->offscreen) {
-        attr->vis.x      = 0;
-        attr->vis.y      = 0;
+        attr->vis.x = 0;
+        attr->vis.y = 0;
         attr->vis.height = 0;
-        attr->vis.width  = 0;
+        attr->vis.width = 0;
         return pWinPriv->window ? TRUE : FALSE;
     }
 
-                                /* Compute display-relative coordinates */
-    attr->vis.x          = pWindow->drawable.x;
-    attr->vis.y          = pWindow->drawable.y;
-    attr->vis.width      = pWindow->drawable.width;
-    attr->vis.height     = pWindow->drawable.height;
+    /* Compute display-relative coordinates */
+    attr->vis.x = pWindow->drawable.x;
+    attr->vis.y = pWindow->drawable.y;
+    attr->vis.width = pWindow->drawable.width;
+    attr->vis.height = pWindow->drawable.height;
 
     if (attr->pos.x < 0) {
-        attr->vis.x     -= attr->pos.x;
-        attr->vis.width  = attr->pos.x + attr->pos.width - attr->vis.x;
+        attr->vis.x -= attr->pos.x;
+        attr->vis.width = attr->pos.x + attr->pos.width - attr->vis.x;
     }
     if (attr->pos.x + attr->pos.width > pWindow->drawable.pScreen->width) {
         if (attr->pos.x < 0)
-            attr->vis.width  = pWindow->drawable.pScreen->width;
+            attr->vis.width = pWindow->drawable.pScreen->width;
         else
-            attr->vis.width  = pWindow->drawable.pScreen->width - attr->pos.x;
+            attr->vis.width = pWindow->drawable.pScreen->width - attr->pos.x;
     }
     if (attr->pos.y < 0) {
-        attr->vis.y     -= attr->pos.y;
+        attr->vis.y -= attr->pos.y;
         attr->vis.height = attr->pos.y + attr->pos.height - attr->vis.y;
     }
     if (attr->pos.y + attr->pos.height > pWindow->drawable.pScreen->height) {
@@ -149,29 +152,32 @@ Bool dmxGetWindowAttributes(WindowPtr pWindow, DMXWindowAttributesPtr attr)
             attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y;
     }
 
-                                /* Convert to window-relative coordinates */
+    /* Convert to window-relative coordinates */
     attr->vis.x -= attr->pos.x;
     attr->vis.y -= attr->pos.y;
 
     return TRUE;
 }
 
-void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)
+void
+dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)
 {
-    attr->width  = dmxGlobalWidth;
+    attr->width = dmxGlobalWidth;
     attr->height = dmxGlobalHeight;
-    attr->shiftX = 0;            /* NOTE: The upper left hand corner of */
-    attr->shiftY = 0;            /*       the desktop is always <0,0>. */
+    attr->shiftX = 0;           /* NOTE: The upper left hand corner of */
+    attr->shiftY = 0;           /*       the desktop is always <0,0>. */
 }
 
 /** Return the total number of devices, not just #dmxNumInputs.  The
  * number returned should be the same as that returned by
  * XListInputDevices. */
-int dmxGetInputCount(void)
+int
+dmxGetInputCount(void)
 {
     int i, total;
-    
-    for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs;
+
+    for (total = i = 0; i < dmxNumInputs; i++)
+        total += dmxInputs[i].numDevs;
     return total;
 }
 
@@ -179,38 +185,42 @@ int dmxGetInputCount(void)
  * information is primarily for the #ProcDMXGetInputAttributes()
  * function, which does not have access to the appropriate data
  * structure. */
-int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
+int
+dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
 {
-    int          i, j;
+    int i, j;
     DMXInputInfo *dmxInput;
 
-    if (deviceId < 0) return -1;
+    if (deviceId < 0)
+        return -1;
     for (i = 0; i < dmxNumInputs; i++) {
         dmxInput = &dmxInputs[i];
         for (j = 0; j < dmxInput->numDevs; j++) {
             DMXLocalInputInfoPtr dmxLocal = dmxInput->devs[j];
-            if (deviceId != dmxLocal->pDevice->id) continue;
-            attr->isCore             = !!dmxLocal->isCore;
-            attr->sendsCore          = !!dmxLocal->sendsCore;
-            attr->detached           = !!dmxInput->detached;
-            attr->physicalScreen     = -1;
-            attr->physicalId         = -1;
-            attr->name               = NULL;
+
+            if (deviceId != dmxLocal->pDevice->id)
+                continue;
+            attr->isCore = ! !dmxLocal->isCore;
+            attr->sendsCore = ! !dmxLocal->sendsCore;
+            attr->detached = ! !dmxInput->detached;
+            attr->physicalScreen = -1;
+            attr->physicalId = -1;
+            attr->name = NULL;
             switch (dmxLocal->extType) {
             case DMX_LOCAL_TYPE_LOCAL:
-                attr->inputType      = 0;
+                attr->inputType = 0;
                 break;
             case DMX_LOCAL_TYPE_CONSOLE:
-                attr->inputType      = 1;
-                attr->name           = dmxInput->name;
-                attr->physicalId     = dmxLocal->deviceId;
+                attr->inputType = 1;
+                attr->name = dmxInput->name;
+                attr->physicalId = dmxLocal->deviceId;
                 break;
             case DMX_LOCAL_TYPE_BACKEND:
             case DMX_LOCAL_TYPE_COMMON:
-                attr->inputType      = 2;
+                attr->inputType = 2;
                 attr->physicalScreen = dmxInput->scrnIdx;
-                attr->name           = dmxInput->name;
-                attr->physicalId     = dmxLocal->deviceId;
+                attr->name = dmxInput->name;
+                attr->physicalId = dmxLocal->deviceId;
                 break;
             }
             return 0;           /* Success */
@@ -220,9 +230,10 @@ int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
 }
 
 /** Reinitialized the cursor boundaries. */
-static void dmxAdjustCursorBoundaries(void)
+static void
+dmxAdjustCursorBoundaries(void)
 {
-    int           i;
+    int i;
 
     dmxReInitOrigins();
     dmxInitOverlap();
@@ -230,28 +241,33 @@ static void dmxAdjustCursorBoundaries(void)
     dmxConnectionBlockCallback();
     for (i = 0; i < dmxNumInputs; i++) {
         DMXInputInfo *dmxInput = &dmxInputs[i];
-	if (!dmxInput->detached) dmxInputReInit(dmxInput);
+
+        if (!dmxInput->detached)
+            dmxInputReInit(dmxInput);
     }
 
     dmxCheckCursor();
 
     for (i = 0; i < dmxNumInputs; i++) {
         DMXInputInfo *dmxInput = &dmxInputs[i];
-	if (!dmxInput->detached) dmxInputLateReInit(dmxInput);
+
+        if (!dmxInput->detached)
+            dmxInputLateReInit(dmxInput);
     }
 }
 
 /** Add an input with the specified attributes.  If the input is added,
  * the physical id is returned in \a deviceId. */
-int dmxAddInput(DMXInputAttributesPtr attr, int *id)
+int
+dmxAddInput(DMXInputAttributesPtr attr, int *id)
 {
     int retcode = BadValue;
 
     if (attr->inputType == 1)   /* console */
         retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);
-    else if (attr->inputType == 2)   /* backend */
+    else if (attr->inputType == 2)      /* backend */
         retcode = dmxInputAttachBackend(attr->physicalScreen,
-                                        attr->sendsCore,id);
+                                        attr->sendsCore, id);
 
     if (retcode == Success) {
         /* Adjust the cursor boundaries */
@@ -265,7 +281,8 @@ int dmxAddInput(DMXInputAttributesPtr attr, int *id)
 }
 
 /** Remove the input with physical id \a id. */
-int dmxRemoveInput(int id)
+int
+dmxRemoveInput(int id)
 {
     return dmxInputDetachId(id);
 }
@@ -273,46 +290,52 @@ int dmxRemoveInput(int id)
 /** Return the value of #dmxNumScreens -- the total number of backend
  * screens in use (these are logical screens and may be larger than the
  * number of backend displays). */
-unsigned long dmxGetNumScreens(void)
+unsigned long
+dmxGetNumScreens(void)
 {
     return dmxNumScreens;
 }
 
 /** Make sure that #dmxCreateAndRealizeWindow has been called for \a
  * pWindow. */
-void dmxForceWindowCreation(WindowPtr pWindow)
+void
+dmxForceWindowCreation(WindowPtr pWindow)
 {
     dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
-    if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE);
+
+    if (!pWinPriv->window)
+        dmxCreateAndRealizeWindow(pWindow, TRUE);
 }
 
 /** Flush pending syncs for all screens. */
-void dmxFlushPendingSyncs(void)
+void
+dmxFlushPendingSyncs(void)
 {
     dmxSync(NULL, TRUE);
 }
 
 /** Update DMX's screen resources to match those of the newly moved
  *  and/or resized "root" window. */
-void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
+void
+dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-    WindowPtr      pRoot     = pScreen->root;
-    WindowPtr      pChild;
-    Bool           anyMarked = FALSE;
+    WindowPtr pRoot = pScreen->root;
+    WindowPtr pChild;
+    Bool anyMarked = FALSE;
 
     /* Handle special case where width and/or height are zero */
     if (w == 0 || h == 0) {
-	w = 1;
-	h = 1;
+        w = 1;
+        h = 1;
     }
 
     /* Change screen size */
-    pScreen->width  = w;
+    pScreen->width = w;
     pScreen->height = h;
 
     /* Reset the root window's drawable's size */
-    pRoot->drawable.width  = w;
+    pRoot->drawable.width = w;
     pRoot->drawable.height = h;
 
     /* Set the root window's new winSize and borderSize */
@@ -328,15 +351,15 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
 
     /* Recompute this screen's mmWidth & mmHeight */
     pScreen->mmWidth =
-	(w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);
+        (w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);
     pScreen->mmHeight =
-	(h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10);
+        (h * 254 + dmxScreen->beYDPI * 5) / (dmxScreen->beYDPI * 10);
 
     /* Recompute this screen's window's clip rects as follows: */
     /*   1. Mark all of root's children's windows */
     for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)
-	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
-						    (WindowPtr *)NULL);
+        anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
+                                                    (WindowPtr *) NULL);
 
     /*   2. Set the root window's borderClip */
     pRoot->borderClip.extents.x1 = 0;
@@ -346,27 +369,28 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
 
     /*   3. Set the root window's clipList */
     if (anyMarked) {
-	/* If any windows have been marked, set the root window's
-	 * clipList to be broken since it will be recalculated in
-	 * ValidateTree()
-	 */
-	RegionBreak(&pRoot->clipList);
-    } else {
-	/* Otherwise, we just set it directly since there are no
-	 * windows visible on this screen
-	 */
-	pRoot->clipList.extents.x1 = 0;
-	pRoot->clipList.extents.y1 = 0;
-	pRoot->clipList.extents.x2 = w;
-	pRoot->clipList.extents.y2 = h;
+        /* If any windows have been marked, set the root window's
+         * clipList to be broken since it will be recalculated in
+         * ValidateTree()
+         */
+        RegionBreak(&pRoot->clipList);
+    }
+    else {
+        /* Otherwise, we just set it directly since there are no
+         * windows visible on this screen
+         */
+        pRoot->clipList.extents.x1 = 0;
+        pRoot->clipList.extents.y1 = 0;
+        pRoot->clipList.extents.x2 = w;
+        pRoot->clipList.extents.y2 = h;
     }
 
     /*   4. Revalidate all clip rects and generate expose events */
     if (anyMarked) {
-	pScreen->ValidateTree(pRoot, NULL, VTBroken);
-	pScreen->HandleExposures(pRoot);
-	if (pScreen->PostValidateTree)
-	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);
+        pScreen->ValidateTree(pRoot, NULL, VTBroken);
+        pScreen->HandleExposures(pRoot);
+        if (pScreen->PostValidateTree)
+            pScreen->PostValidateTree(pRoot, NULL, VTBroken);
     }
 }
 
@@ -375,72 +399,71 @@ void dmxUpdateScreenResources(ScreenPtr pScreen, int x, int y, int w, int h)
 
 /** Change the "screen" window attributes by resizing the actual window
  *  on the back-end display (if necessary). */
-static void dmxConfigureScreenWindow(int idx,
-				     int x, int y, int w, int h)
+static void
+dmxConfigureScreenWindow(int idx, int x, int y, int w, int h)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
+    ScreenPtr pScreen = screenInfo.screens[idx];
 
     /* Resize "screen" window */
-    if (dmxScreen->scrnX      != x ||
-	dmxScreen->scrnY      != y ||
-	dmxScreen->scrnWidth  != w ||
-	dmxScreen->scrnHeight != h) {
-	dmxResizeScreenWindow(pScreen, x, y, w, h);
+    if (dmxScreen->scrnX != x ||
+        dmxScreen->scrnY != y ||
+        dmxScreen->scrnWidth != w || dmxScreen->scrnHeight != h) {
+        dmxResizeScreenWindow(pScreen, x, y, w, h);
     }
 
     /* Change "screen" window values */
-    dmxScreen->scrnX      = x;
-    dmxScreen->scrnY      = y;
-    dmxScreen->scrnWidth  = w;
+    dmxScreen->scrnX = x;
+    dmxScreen->scrnY = y;
+    dmxScreen->scrnWidth = w;
     dmxScreen->scrnHeight = h;
 }
-				     
+
 /** Change the "root" window position and size by resizing the actual
  *  window on the back-end display (if necessary) and updating all of
  *  DMX's resources by calling #dmxUpdateScreenResources. */
-static void dmxConfigureRootWindow(int idx, int x, int y, int w, int h)
+static void
+dmxConfigureRootWindow(int idx, int x, int y, int w, int h)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    WindowPtr      pRoot     = screenInfo.screens[idx]->root;
+    WindowPtr pRoot = screenInfo.screens[idx]->root;
 
     /* NOTE: Either this function or the ones that it calls must handle
      * the case where w == 0 || h == 0.  Currently, the functions that
      * this one calls handle that case. */
 
     /* 1. Resize "root" window */
-    if (dmxScreen->rootX      != x ||
-	dmxScreen->rootY      != y ||
-	dmxScreen->rootWidth  != w ||
-	dmxScreen->rootHeight != h) {
-	dmxResizeRootWindow(pRoot, x, y, w, h);
+    if (dmxScreen->rootX != x ||
+        dmxScreen->rootY != y ||
+        dmxScreen->rootWidth != w || dmxScreen->rootHeight != h) {
+        dmxResizeRootWindow(pRoot, x, y, w, h);
     }
 
     /* 2. Update all of the screen's resources associated with this root
      *    window */
-    if (dmxScreen->rootWidth  != w ||
-	dmxScreen->rootHeight != h) {
-	dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h);
+    if (dmxScreen->rootWidth != w || dmxScreen->rootHeight != h) {
+        dmxUpdateScreenResources(screenInfo.screens[idx], x, y, w, h);
     }
 
     /* Change "root" window values */
-    dmxScreen->rootX      = x;
-    dmxScreen->rootY      = y;
-    dmxScreen->rootWidth  = w;
+    dmxScreen->rootX = x;
+    dmxScreen->rootY = y;
+    dmxScreen->rootWidth = w;
     dmxScreen->rootHeight = h;
 }
 
 /** Change the "root" window's origin by updating DMX's internal data
  *  structures (dix and Xinerama) to use the new origin and adjust the
  *  positions of windows that overlap this "root" window. */
-static void dmxSetRootWindowOrigin(int idx, int x, int y)
+static void
+dmxSetRootWindowOrigin(int idx, int x, int y)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-    WindowPtr      pRoot     = pScreen->root;
-    WindowPtr      pChild;
-    int            xoff;
-    int            yoff;
+    ScreenPtr pScreen = screenInfo.screens[idx];
+    WindowPtr pRoot = pScreen->root;
+    WindowPtr pChild;
+    int xoff;
+    int yoff;
 
     /* Change "root" window's origin */
     dmxScreen->rootXOrigin = x;
@@ -458,129 +481,131 @@ static void dmxSetRootWindowOrigin(int idx, int x, int y)
     XineramaReinitData();
 
     /* Adjust each of the root window's children */
-    if (!idx) ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff);
+    if (!idx)
+        ReinitializeRootWindow(screenInfo.screens[0]->root, xoff, yoff);
     pChild = pRoot->firstChild;
     while (pChild) {
-	/* Adjust child window's position */
-	pScreen->MoveWindow(pChild,
-			    pChild->origin.x - wBorderWidth(pChild) - xoff,
-			    pChild->origin.y - wBorderWidth(pChild) - yoff,
-			    pChild->nextSib,
-			    VTMove);
-
-	/* Note that the call to MoveWindow will eventually call
-	 * dmxPositionWindow which will automatically create a
-	 * window if it is now exposed on screen (for lazy window
-	 * creation optimization) and it will properly set the
-	 * offscreen flag.
-	 */
-
-	pChild = pChild->nextSib;
+        /* Adjust child window's position */
+        pScreen->MoveWindow(pChild,
+                            pChild->origin.x - wBorderWidth(pChild) - xoff,
+                            pChild->origin.y - wBorderWidth(pChild) - yoff,
+                            pChild->nextSib, VTMove);
+
+        /* Note that the call to MoveWindow will eventually call
+         * dmxPositionWindow which will automatically create a
+         * window if it is now exposed on screen (for lazy window
+         * creation optimization) and it will properly set the
+         * offscreen flag.
+         */
+
+        pChild = pChild->nextSib;
     }
 }
 
 /** Configure the attributes of each "screen" and "root" window. */
-int dmxConfigureScreenWindows(int nscreens,
-			      CARD32 *screens,
-			      DMXScreenAttributesPtr attribs,
-			      int *errorScreen)
+int
+dmxConfigureScreenWindows(int nscreens,
+                          CARD32 *screens,
+                          DMXScreenAttributesPtr attribs, int *errorScreen)
 {
-    int           i;
+    int i;
 
     for (i = 0; i < nscreens; i++) {
-	DMXScreenAttributesPtr  attr      = &attribs[i];
-	int                     idx       = screens[i];
-	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];
-
-	if (errorScreen) *errorScreen = i;
-
-	if (!dmxScreen->beDisplay) return DMX_BAD_VALUE;
-
-	/* Check for illegal values */
-	if (idx < 0 || idx >= dmxNumScreens) return BadValue;
-
-	/* The "screen" and "root" windows must have valid sizes */
-	if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 ||
-	    attr->rootWindowWidth   <  0 || attr->rootWindowHeight   <  0)
-	    return DMX_BAD_VALUE;
-
-	/* The "screen" window must fit entirely within the BE display */
-	if (attr->screenWindowXoffset < 0 ||
-	    attr->screenWindowYoffset < 0 ||
-	    attr->screenWindowXoffset
-	    + attr->screenWindowWidth  > (unsigned)dmxScreen->beWidth ||
-	    attr->screenWindowYoffset
-	    + attr->screenWindowHeight > (unsigned)dmxScreen->beHeight)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must fit entirely within the "screen" window */
-	if (attr->rootWindowXoffset < 0 ||
-	    attr->rootWindowYoffset < 0 ||
-	    attr->rootWindowXoffset
-	    + attr->rootWindowWidth  > attr->screenWindowWidth ||
-	    attr->rootWindowYoffset
-	    + attr->rootWindowHeight > attr->screenWindowHeight)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must not expose unaddressable coordinates */
-	if (attr->rootWindowXorigin < 0 ||
-	    attr->rootWindowYorigin < 0 ||
-	    attr->rootWindowXorigin + attr->rootWindowWidth  > 32767 ||
-	    attr->rootWindowYorigin + attr->rootWindowHeight > 32767)
-	    return DMX_BAD_VALUE;
-
-	/* The "root" window must fit within the global bounding box */
-	if (attr->rootWindowXorigin
-	    + attr->rootWindowWidth > (unsigned)dmxGlobalWidth ||
-	    attr->rootWindowYorigin
-	    + attr->rootWindowHeight > (unsigned)dmxGlobalHeight)
-	    return DMX_BAD_VALUE;
-
-	/* FIXME: Handle the rest of the illegal value checking */
+        DMXScreenAttributesPtr attr = &attribs[i];
+        int idx = screens[i];
+        DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+
+        if (errorScreen)
+            *errorScreen = i;
+
+        if (!dmxScreen->beDisplay)
+            return DMX_BAD_VALUE;
+
+        /* Check for illegal values */
+        if (idx < 0 || idx >= dmxNumScreens)
+            return BadValue;
+
+        /* The "screen" and "root" windows must have valid sizes */
+        if (attr->screenWindowWidth <= 0 || attr->screenWindowHeight <= 0 ||
+            attr->rootWindowWidth < 0 || attr->rootWindowHeight < 0)
+            return DMX_BAD_VALUE;
+
+        /* The "screen" window must fit entirely within the BE display */
+        if (attr->screenWindowXoffset < 0 ||
+            attr->screenWindowYoffset < 0 ||
+            attr->screenWindowXoffset
+            + attr->screenWindowWidth > (unsigned) dmxScreen->beWidth ||
+            attr->screenWindowYoffset
+            + attr->screenWindowHeight > (unsigned) dmxScreen->beHeight)
+            return DMX_BAD_VALUE;
+
+        /* The "root" window must fit entirely within the "screen" window */
+        if (attr->rootWindowXoffset < 0 ||
+            attr->rootWindowYoffset < 0 ||
+            attr->rootWindowXoffset
+            + attr->rootWindowWidth > attr->screenWindowWidth ||
+            attr->rootWindowYoffset
+            + attr->rootWindowHeight > attr->screenWindowHeight)
+            return DMX_BAD_VALUE;
+
+        /* The "root" window must not expose unaddressable coordinates */
+        if (attr->rootWindowXorigin < 0 ||
+            attr->rootWindowYorigin < 0 ||
+            attr->rootWindowXorigin + attr->rootWindowWidth > 32767 ||
+            attr->rootWindowYorigin + attr->rootWindowHeight > 32767)
+            return DMX_BAD_VALUE;
+
+        /* The "root" window must fit within the global bounding box */
+        if (attr->rootWindowXorigin
+            + attr->rootWindowWidth > (unsigned) dmxGlobalWidth ||
+            attr->rootWindowYorigin
+            + attr->rootWindowHeight > (unsigned) dmxGlobalHeight)
+            return DMX_BAD_VALUE;
+
+        /* FIXME: Handle the rest of the illegal value checking */
     }
 
     /* No illegal values found */
-    if (errorScreen) *errorScreen = 0;
+    if (errorScreen)
+        *errorScreen = 0;
 
     for (i = 0; i < nscreens; i++) {
-	DMXScreenAttributesPtr  attr      = &attribs[i];
-	int                     idx       = screens[i];
-	DMXScreenInfo          *dmxScreen = &dmxScreens[idx];
-
-	dmxLog(dmxInfo, "Changing screen #%d attributes "
-	       "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d "
-	       "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n",
-	       idx,
-	       dmxScreen->scrnWidth,      dmxScreen->scrnHeight,
-	       dmxScreen->scrnX,          dmxScreen->scrnY,
-	       dmxScreen->rootWidth,      dmxScreen->rootHeight,
-	       dmxScreen->rootX,          dmxScreen->rootY,
-	       dmxScreen->rootXOrigin,    dmxScreen->rootYOrigin,
-	       attr->screenWindowWidth,   attr->screenWindowHeight,
-	       attr->screenWindowXoffset, attr->screenWindowYoffset,
-	       attr->rootWindowWidth,     attr->rootWindowHeight,
-	       attr->rootWindowXoffset,   attr->rootWindowYoffset,
-	       attr->rootWindowXorigin,   attr->rootWindowYorigin);
-
-	/* Configure "screen" window */
-	dmxConfigureScreenWindow(idx,
-				 attr->screenWindowXoffset,
-				 attr->screenWindowYoffset,
-				 attr->screenWindowWidth,
-				 attr->screenWindowHeight);
-
-	/* Configure "root" window */
-	dmxConfigureRootWindow(idx,
-			       attr->rootWindowXoffset,
-			       attr->rootWindowYoffset,
-			       attr->rootWindowWidth,
-			       attr->rootWindowHeight);
-
-
-	/* Set "root" window's origin */
-	dmxSetRootWindowOrigin(idx,
-			       attr->rootWindowXorigin,
-			       attr->rootWindowYorigin);
+        DMXScreenAttributesPtr attr = &attribs[i];
+        int idx = screens[i];
+        DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+
+        dmxLog(dmxInfo, "Changing screen #%d attributes "
+               "from %dx%d+%d+%d %dx%d+%d+%d +%d+%d "
+               "to %dx%d+%d+%d %dx%d+%d+%d +%d+%d\n",
+               idx,
+               dmxScreen->scrnWidth, dmxScreen->scrnHeight,
+               dmxScreen->scrnX, dmxScreen->scrnY,
+               dmxScreen->rootWidth, dmxScreen->rootHeight,
+               dmxScreen->rootX, dmxScreen->rootY,
+               dmxScreen->rootXOrigin, dmxScreen->rootYOrigin,
+               attr->screenWindowWidth, attr->screenWindowHeight,
+               attr->screenWindowXoffset, attr->screenWindowYoffset,
+               attr->rootWindowWidth, attr->rootWindowHeight,
+               attr->rootWindowXoffset, attr->rootWindowYoffset,
+               attr->rootWindowXorigin, attr->rootWindowYorigin);
+
+        /* Configure "screen" window */
+        dmxConfigureScreenWindow(idx,
+                                 attr->screenWindowXoffset,
+                                 attr->screenWindowYoffset,
+                                 attr->screenWindowWidth,
+                                 attr->screenWindowHeight);
+
+        /* Configure "root" window */
+        dmxConfigureRootWindow(idx,
+                               attr->rootWindowXoffset,
+                               attr->rootWindowYoffset,
+                               attr->rootWindowWidth, attr->rootWindowHeight);
+
+        /* Set "root" window's origin */
+        dmxSetRootWindowOrigin(idx,
+                               attr->rootWindowXorigin,
+                               attr->rootWindowYorigin);
     }
 
     /* Adjust the cursor boundaries */
@@ -593,37 +618,46 @@ int dmxConfigureScreenWindows(int nscreens,
 }
 
 /** Configure the attributes of the global desktop. */
-int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
+int
+dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
 {
-    if (attribs->width  <= 0 || attribs->width  >= 32767 ||
-	attribs->height <= 0 || attribs->height >= 32767)
-	return DMX_BAD_VALUE;
+    if (attribs->width <= 0 || attribs->width >= 32767 ||
+        attribs->height <= 0 || attribs->height >= 32767)
+        return DMX_BAD_VALUE;
 
     /* If the desktop is shrinking, adjust the "root" windows on each
      * "screen" window to only show the visible desktop.  Also, handle
      * the special case where the desktop shrinks such that the it no
      * longer overlaps an portion of a "screen" window. */
     if (attribs->width < dmxGlobalWidth || attribs->height < dmxGlobalHeight) {
-	int   i;
-	for (i = 0; i < dmxNumScreens; i++) {
-	    DMXScreenInfo *dmxScreen = &dmxScreens[i];
-	    if (dmxScreen->rootXOrigin
-		+ dmxScreen->rootWidth  > attribs->width ||
-		dmxScreen->rootYOrigin
-		+ dmxScreen->rootHeight > attribs->height) {
-		int  w, h;
-		if ((w = attribs->width  - dmxScreen->rootXOrigin) < 0) w = 0;
-		if ((h = attribs->height - dmxScreen->rootYOrigin) < 0) h = 0;
-		if (w > dmxScreen->scrnWidth)  w = dmxScreen->scrnWidth;
-		if (h > dmxScreen->scrnHeight) h = dmxScreen->scrnHeight;
-		if (w > dmxScreen->rootWidth)  w = dmxScreen->rootWidth;
-		if (h > dmxScreen->rootHeight) h = dmxScreen->rootHeight;
-		dmxConfigureRootWindow(i,
-				       dmxScreen->rootX,
-				       dmxScreen->rootY,
-				       w, h);
-	    }
-	}
+        int i;
+
+        for (i = 0; i < dmxNumScreens; i++) {
+            DMXScreenInfo *dmxScreen = &dmxScreens[i];
+
+            if (dmxScreen->rootXOrigin
+                + dmxScreen->rootWidth > attribs->width ||
+                dmxScreen->rootYOrigin
+                + dmxScreen->rootHeight > attribs->height) {
+                int w, h;
+
+                if ((w = attribs->width - dmxScreen->rootXOrigin) < 0)
+                    w = 0;
+                if ((h = attribs->height - dmxScreen->rootYOrigin) < 0)
+                    h = 0;
+                if (w > dmxScreen->scrnWidth)
+                    w = dmxScreen->scrnWidth;
+                if (h > dmxScreen->scrnHeight)
+                    h = dmxScreen->scrnHeight;
+                if (w > dmxScreen->rootWidth)
+                    w = dmxScreen->rootWidth;
+                if (h > dmxScreen->rootHeight)
+                    h = dmxScreen->rootHeight;
+                dmxConfigureRootWindow(i,
+                                       dmxScreen->rootX,
+                                       dmxScreen->rootY, w, h);
+            }
+        }
     }
 
     /* Set the global width/height */
@@ -631,30 +665,30 @@ int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
 
     /* Handle shift[XY] changes */
     if (attribs->shiftX || attribs->shiftY) {
-	int   i;
-	for (i = 0; i < dmxNumScreens; i++) {
-	    ScreenPtr  pScreen = screenInfo.screens[i];
-	    WindowPtr  pChild  = pScreen->root->firstChild;
-	    while (pChild) {
-		/* Adjust child window's position */
-		pScreen->MoveWindow(pChild,
-				    pChild->origin.x - wBorderWidth(pChild)
-				    - attribs->shiftX,
-				    pChild->origin.y - wBorderWidth(pChild)
-				    - attribs->shiftY,
-				    pChild->nextSib,
-				    VTMove);
-
-		/* Note that the call to MoveWindow will eventually call
-		 * dmxPositionWindow which will automatically create a
-		 * window if it is now exposed on screen (for lazy
-		 * window creation optimization) and it will properly
-		 * set the offscreen flag.
-		 */
-
-		pChild = pChild->nextSib;
-	    }
-	}
+        int i;
+
+        for (i = 0; i < dmxNumScreens; i++) {
+            ScreenPtr pScreen = screenInfo.screens[i];
+            WindowPtr pChild = pScreen->root->firstChild;
+
+            while (pChild) {
+                /* Adjust child window's position */
+                pScreen->MoveWindow(pChild,
+                                    pChild->origin.x - wBorderWidth(pChild)
+                                    - attribs->shiftX,
+                                    pChild->origin.y - wBorderWidth(pChild)
+                                    - attribs->shiftY, pChild->nextSib, VTMove);
+
+                /* Note that the call to MoveWindow will eventually call
+                 * dmxPositionWindow which will automatically create a
+                 * window if it is now exposed on screen (for lazy
+                 * window creation optimization) and it will properly
+                 * set the offscreen flag.
+                 */
+
+                pChild = pChild->nextSib;
+            }
+        }
     }
 
     /* Update connection block, Xinerama, etc. -- these appears to
@@ -672,14 +706,15 @@ int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
 #endif
 
 /** Create the scratch GCs per depth. */
-static void dmxBECreateScratchGCs(int scrnNum)
+static void
+dmxBECreateScratchGCs(int scrnNum)
 {
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
+    ScreenPtr pScreen = screenInfo.screens[scrnNum];
+    GCPtr *ppGC = pScreen->GCperDepth;
+    int i;
 
     for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBECreateGC(pScreen, ppGC[i]);
+        dmxBECreateGC(pScreen, ppGC[i]);
 }
 
 #ifdef PANORAMIX
@@ -689,89 +724,92 @@ static Bool FoundPixImage;
  *  to have its image restored.  When it is found, see if there is
  *  another screen with the same image.  If so, copy the pixmap image
  *  from the existing screen to the newly created pixmap. */
-static void dmxBERestorePixmapImage(pointer value, XID id, RESTYPE type,
-				    pointer p)
+static void
+dmxBERestorePixmapImage(pointer value, XID id, RESTYPE type, pointer p)
 {
     if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {
-	PixmapPtr      pDst     = (PixmapPtr)p;
-	int            idx      = pDst->drawable.pScreen->myNum;
-	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;
-	PixmapPtr      pPix;
-	int            i;
-
-	dixLookupResourceByType((pointer*) &pPix, pXinPix->info[idx].id,
-				RT_PIXMAP, NullClient, DixUnknownAccess);
-	if (pPix != pDst) return; /* Not a match.... Next! */
-
-	FOR_NSCREENS(i) {
-	    PixmapPtr      pSrc;
-	    dmxPixPrivPtr  pSrcPriv = NULL;
-
-	    if (i == idx) continue; /* Self replication is bad */
-
-	    dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id,
-				    RT_PIXMAP, NullClient, DixUnknownAccess);
-	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-	    if (pSrcPriv->pixmap) {
-		DMXScreenInfo *dmxSrcScreen = &dmxScreens[i];
-		DMXScreenInfo *dmxDstScreen = &dmxScreens[idx];
-		dmxPixPrivPtr  pDstPriv = DMX_GET_PIXMAP_PRIV(pDst);
-		XImage        *img;
-		int            j;
-		XlibGC         gc = NULL;
-
-		/* This should never happen, but just in case.... */
-		if (pSrc->drawable.width  != pDst->drawable.width ||
-		    pSrc->drawable.height != pDst->drawable.height)
-		    return;
-
-		/* Copy from src pixmap to dst pixmap */
-		img = XGetImage(dmxSrcScreen->beDisplay,
-				pSrcPriv->pixmap,
-				0, 0,
-				pSrc->drawable.width, pSrc->drawable.height,
-				-1,
-				ZPixmap);
-
-		for (j = 0; j < dmxDstScreen->beNumPixmapFormats; j++) {
-		    if (dmxDstScreen->bePixmapFormats[j].depth == img->depth) {
-			unsigned long  m;
-			XGCValues      v;
-
-			m = GCFunction | GCPlaneMask | GCClipMask;
-			v.function = GXcopy;
-			v.plane_mask = AllPlanes;
-			v.clip_mask = None;
-
-			gc = XCreateGC(dmxDstScreen->beDisplay,
-				       dmxDstScreen->scrnDefDrawables[j],
-				       m, &v);
-			break;
-		    }
-		}
-
-		if (gc) {
-		    XPutImage(dmxDstScreen->beDisplay,
-			      pDstPriv->pixmap,
-			      gc, img, 0, 0, 0, 0,
-			      pDst->drawable.width, pDst->drawable.height);
-		    XFreeGC(dmxDstScreen->beDisplay, gc);
-		    FoundPixImage = True;
-		} else {
-		    dmxLog(dmxWarning, "Could not create GC\n");
-		}
-
-		XDestroyImage(img);
-		return;
-	    }
-	}
+        PixmapPtr pDst = (PixmapPtr) p;
+        int idx = pDst->drawable.pScreen->myNum;
+        PanoramiXRes *pXinPix = (PanoramiXRes *) value;
+        PixmapPtr pPix;
+        int i;
+
+        dixLookupResourceByType((pointer *) &pPix, pXinPix->info[idx].id,
+                                RT_PIXMAP, NullClient, DixUnknownAccess);
+        if (pPix != pDst)
+            return;             /* Not a match.... Next! */
+
+        FOR_NSCREENS(i) {
+            PixmapPtr pSrc;
+            dmxPixPrivPtr pSrcPriv = NULL;
+
+            if (i == idx)
+                continue;       /* Self replication is bad */
+
+            dixLookupResourceByType((pointer *) &pSrc, pXinPix->info[i].id,
+                                    RT_PIXMAP, NullClient, DixUnknownAccess);
+            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
+            if (pSrcPriv->pixmap) {
+                DMXScreenInfo *dmxSrcScreen = &dmxScreens[i];
+                DMXScreenInfo *dmxDstScreen = &dmxScreens[idx];
+                dmxPixPrivPtr pDstPriv = DMX_GET_PIXMAP_PRIV(pDst);
+                XImage *img;
+                int j;
+                XlibGC gc = NULL;
+
+                /* This should never happen, but just in case.... */
+                if (pSrc->drawable.width != pDst->drawable.width ||
+                    pSrc->drawable.height != pDst->drawable.height)
+                    return;
+
+                /* Copy from src pixmap to dst pixmap */
+                img = XGetImage(dmxSrcScreen->beDisplay,
+                                pSrcPriv->pixmap,
+                                0, 0,
+                                pSrc->drawable.width, pSrc->drawable.height,
+                                -1, ZPixmap);
+
+                for (j = 0; j < dmxDstScreen->beNumPixmapFormats; j++) {
+                    if (dmxDstScreen->bePixmapFormats[j].depth == img->depth) {
+                        unsigned long m;
+                        XGCValues v;
+
+                        m = GCFunction | GCPlaneMask | GCClipMask;
+                        v.function = GXcopy;
+                        v.plane_mask = AllPlanes;
+                        v.clip_mask = None;
+
+                        gc = XCreateGC(dmxDstScreen->beDisplay,
+                                       dmxDstScreen->scrnDefDrawables[j],
+                                       m, &v);
+                        break;
+                    }
+                }
+
+                if (gc) {
+                    XPutImage(dmxDstScreen->beDisplay,
+                              pDstPriv->pixmap,
+                              gc, img, 0, 0, 0, 0,
+                              pDst->drawable.width, pDst->drawable.height);
+                    XFreeGC(dmxDstScreen->beDisplay, gc);
+                    FoundPixImage = True;
+                }
+                else {
+                    dmxLog(dmxWarning, "Could not create GC\n");
+                }
+
+                XDestroyImage(img);
+                return;
+            }
+        }
     }
 }
 #endif
 
 /** Restore the pixmap image either from another screen or from an image
  *  that was saved when the screen was previously detached. */
-static void dmxBERestorePixmap(PixmapPtr pPixmap)
+static void
+dmxBERestorePixmap(PixmapPtr pPixmap)
 {
 #ifdef PANORAMIX
     int i;
@@ -779,62 +817,63 @@ static void dmxBERestorePixmap(PixmapPtr pPixmap)
     /* If Xinerama is not active, there's nothing we can do (see comment
      * in #else below for more info). */
     if (noPanoramiXExtension) {
-	dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	return;
+        dmxLog(dmxWarning, "Cannot restore pixmap image\n");
+        return;
     }
 
     FoundPixImage = False;
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBERestorePixmapImage,
-				   (pointer)pPixmap);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindAllClientResources(clients[i], dmxBERestorePixmapImage,
+                                   (pointer) pPixmap);
 
     /* No corresponding pixmap image was found on other screens, so we
      * need to copy it from the saved image when the screen was detached
      * (if available). */
     if (!FoundPixImage) {
-	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
-
-	if (pPixPriv->detachedImage) {
-	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;
-	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-	    XlibGC         gc        = NULL;
-
-	    for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
-		if (dmxScreen->bePixmapFormats[i].depth ==
-		    pPixPriv->detachedImage->depth) {
-		    unsigned long  m;
-		    XGCValues      v;
-
-		    m = GCFunction | GCPlaneMask | GCClipMask;
-		    v.function = GXcopy;
-		    v.plane_mask = AllPlanes;
-		    v.clip_mask = None;
-
-		    gc = XCreateGC(dmxScreen->beDisplay,
-				   dmxScreen->scrnDefDrawables[i],
-				   m, &v);
-		    break;
-		}
-	    }
-
-	    if (gc) {
-		XPutImage(dmxScreen->beDisplay,
-			  pPixPriv->pixmap,
-			  gc,
-			  pPixPriv->detachedImage,
-			  0, 0, 0, 0,
-		      pPixmap->drawable.width, pPixmap->drawable.height);
-		XFreeGC(dmxScreen->beDisplay, gc);
-	    } else {
-		dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	    }
-
-	    XDestroyImage(pPixPriv->detachedImage);
-	    pPixPriv->detachedImage = NULL;
-	} else {
-	    dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	}
+        dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
+
+        if (pPixPriv->detachedImage) {
+            ScreenPtr pScreen = pPixmap->drawable.pScreen;
+            DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
+            XlibGC gc = NULL;
+
+            for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
+                if (dmxScreen->bePixmapFormats[i].depth ==
+                    pPixPriv->detachedImage->depth) {
+                    unsigned long m;
+                    XGCValues v;
+
+                    m = GCFunction | GCPlaneMask | GCClipMask;
+                    v.function = GXcopy;
+                    v.plane_mask = AllPlanes;
+                    v.clip_mask = None;
+
+                    gc = XCreateGC(dmxScreen->beDisplay,
+                                   dmxScreen->scrnDefDrawables[i], m, &v);
+                    break;
+                }
+            }
+
+            if (gc) {
+                XPutImage(dmxScreen->beDisplay,
+                          pPixPriv->pixmap,
+                          gc,
+                          pPixPriv->detachedImage,
+                          0, 0, 0, 0,
+                          pPixmap->drawable.width, pPixmap->drawable.height);
+                XFreeGC(dmxScreen->beDisplay, gc);
+            }
+            else {
+                dmxLog(dmxWarning, "Cannot restore pixmap image\n");
+            }
+
+            XDestroyImage(pPixPriv->detachedImage);
+            pPixPriv->detachedImage = NULL;
+        }
+        else {
+            dmxLog(dmxWarning, "Cannot restore pixmap image\n");
+        }
     }
 #else
     /* If Xinerama is not enabled, then there is no other copy of the
@@ -852,57 +891,68 @@ static void dmxBERestorePixmap(PixmapPtr pPixmap)
  *  function.  It walks all resources, compares them to the screen
  *  number passed in as \a n and calls the appropriate DMX function to
  *  create the associated resource on the back-end server. */
-static void dmxBECreateResources(pointer value, XID id, RESTYPE type,
-				 pointer n)
+static void
+dmxBECreateResources(pointer value, XID id, RESTYPE type, pointer n)
 {
-    int        scrnNum = (uintptr_t)n;
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
+    int scrnNum = (uintptr_t) n;
+    ScreenPtr pScreen = screenInfo.screens[scrnNum];
 
     if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {
-	/* Window resources are created below in dmxBECreateWindowTree */
-    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
-	PixmapPtr  pPix = value;
-	if (pPix->drawable.pScreen->myNum == scrnNum) {
-	    dmxBECreatePixmap(pPix);
-	    dmxBERestorePixmap(pPix);
-	}
-    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {
-	GCPtr  pGC = value;
-	if (pGC->pScreen->myNum == scrnNum) {
-	    /* Create the GC on the back-end server */
-	    dmxBECreateGC(pScreen, pGC);
-	    /* Create any pixmaps associated with this GC */
-	    if (!pGC->tileIsPixel) {
-		dmxBECreatePixmap(pGC->tile.pixmap);
-		dmxBERestorePixmap(pGC->tile.pixmap);
-	    }
-	    if (pGC->stipple != pScreen->PixmapPerDepth[0]) {
-		dmxBECreatePixmap(pGC->stipple);
-		dmxBERestorePixmap(pGC->stipple);
-	    }
-	    if (pGC->font != defaultFont) {
-		(void)dmxBELoadFont(pScreen, pGC->font);
-	    }
-	    /* Update the GC on the back-end server */
-	    dmxChangeGC(pGC, -1L);
-	}
-    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
-	(void)dmxBELoadFont(pScreen, (FontPtr)value);
-    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
-	dmxBECreateCursor(pScreen, (CursorPtr)value);
-    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
-	ColormapPtr  pCmap = value;
-	if (pCmap->pScreen->myNum == scrnNum)
-	    (void)dmxBECreateColormap((ColormapPtr)value);
+        /* Window resources are created below in dmxBECreateWindowTree */
+    }
+    else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
+        PixmapPtr pPix = value;
+
+        if (pPix->drawable.pScreen->myNum == scrnNum) {
+            dmxBECreatePixmap(pPix);
+            dmxBERestorePixmap(pPix);
+        }
+    }
+    else if ((type & TypeMask) == (RT_GC & TypeMask)) {
+        GCPtr pGC = value;
+
+        if (pGC->pScreen->myNum == scrnNum) {
+            /* Create the GC on the back-end server */
+            dmxBECreateGC(pScreen, pGC);
+            /* Create any pixmaps associated with this GC */
+            if (!pGC->tileIsPixel) {
+                dmxBECreatePixmap(pGC->tile.pixmap);
+                dmxBERestorePixmap(pGC->tile.pixmap);
+            }
+            if (pGC->stipple != pScreen->PixmapPerDepth[0]) {
+                dmxBECreatePixmap(pGC->stipple);
+                dmxBERestorePixmap(pGC->stipple);
+            }
+            if (pGC->font != defaultFont) {
+                (void) dmxBELoadFont(pScreen, pGC->font);
+            }
+            /* Update the GC on the back-end server */
+            dmxChangeGC(pGC, -1L);
+        }
+    }
+    else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
+        (void) dmxBELoadFont(pScreen, (FontPtr) value);
+    }
+    else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
+        dmxBECreateCursor(pScreen, (CursorPtr) value);
+    }
+    else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
+        ColormapPtr pCmap = value;
+
+        if (pCmap->pScreen->myNum == scrnNum)
+            (void) dmxBECreateColormap((ColormapPtr) value);
 #if 0
-    /* TODO: Recreate Picture and GlyphSet resources */
-    } else if ((type & TypeMask) == (PictureType & TypeMask)) {
-	/* Picture resources are created when windows are created */
-    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
-	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);
+        /* TODO: Recreate Picture and GlyphSet resources */
+    }
+    else if ((type & TypeMask) == (PictureType & TypeMask)) {
+        /* Picture resources are created when windows are created */
+    }
+    else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
+        dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr) value);
 #endif
-    } else {
-	/* Other resource types??? */
+    }
+    else {
+        /* Other resource types??? */
     }
 }
 
@@ -912,21 +962,22 @@ static void dmxBECreateResources(pointer value, XID id, RESTYPE type,
  *  itself to create each window's parents.  This is required so that we
  *  have the opportunity to create each window's border and background
  *  pixmaps (where appropriate) before the window is created. */
-static void dmxBECreateWindowTree(int idx)
+static void
+dmxBECreateWindowTree(int idx)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    WindowPtr      pRoot     = screenInfo.screens[idx]->root;
-    dmxWinPrivPtr  pWinPriv  = DMX_GET_WINDOW_PRIV(pRoot);
-    WindowPtr      pWin;
+    WindowPtr pRoot = screenInfo.screens[idx]->root;
+    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pRoot);
+    WindowPtr pWin;
 
     /* Create the pixmaps associated with the root window */
     if (!pRoot->borderIsPixel) {
-	dmxBECreatePixmap(pRoot->border.pixmap);
-	dmxBERestorePixmap(pRoot->border.pixmap);
+        dmxBECreatePixmap(pRoot->border.pixmap);
+        dmxBERestorePixmap(pRoot->border.pixmap);
     }
     if (pRoot->backgroundState == BackgroundPixmap) {
-	dmxBECreatePixmap(pRoot->background.pixmap);
-	dmxBERestorePixmap(pRoot->background.pixmap);
+        dmxBECreatePixmap(pRoot->background.pixmap);
+        dmxBERestorePixmap(pRoot->background.pixmap);
     }
 
     /* Create root window first */
@@ -935,175 +986,188 @@ static void dmxBECreateWindowTree(int idx)
 
     pWin = pRoot->lastChild;
     while (pWin) {
-	pWinPriv = DMX_GET_WINDOW_PRIV(pWin);
-
-	/* Create the pixmaps regardless of whether or not the
-	 * window is created or not due to lazy window creation.
-	 */
-	if (!pWin->borderIsPixel) {
-	    dmxBECreatePixmap(pWin->border.pixmap);
-	    dmxBERestorePixmap(pWin->border.pixmap);
-	}
-	if (pWin->backgroundState == BackgroundPixmap) {
-	    dmxBECreatePixmap(pWin->background.pixmap);
-	    dmxBERestorePixmap(pWin->background.pixmap);
-	}
-
-	/* Reset the window attributes */
-	dmxGetDefaultWindowAttributes(pWin,
-				      &pWinPriv->cmap,
-				      &pWinPriv->visual);
-
-	/* Create the window */
-	if (pWinPriv->mapped && !pWinPriv->offscreen)
-	    dmxCreateAndRealizeWindow(pWin, TRUE);
-
-	/* Next, create the bottom-most child */
-	if (pWin->lastChild) {
-	    pWin = pWin->lastChild;
-	    continue;
-	}
-
-	/* If the window has no children, move on to the next higher window */
-	while (!pWin->prevSib && (pWin != pRoot))
-	    pWin = pWin->parent;
-
-	if (pWin->prevSib) {
-	    pWin = pWin->prevSib;
-	    continue;
-	}
-
-	/* When we reach the root window, we are finished */
-	if (pWin == pRoot)
-	    break;
+        pWinPriv = DMX_GET_WINDOW_PRIV(pWin);
+
+        /* Create the pixmaps regardless of whether or not the
+         * window is created or not due to lazy window creation.
+         */
+        if (!pWin->borderIsPixel) {
+            dmxBECreatePixmap(pWin->border.pixmap);
+            dmxBERestorePixmap(pWin->border.pixmap);
+        }
+        if (pWin->backgroundState == BackgroundPixmap) {
+            dmxBECreatePixmap(pWin->background.pixmap);
+            dmxBERestorePixmap(pWin->background.pixmap);
+        }
+
+        /* Reset the window attributes */
+        dmxGetDefaultWindowAttributes(pWin, &pWinPriv->cmap, &pWinPriv->visual);
+
+        /* Create the window */
+        if (pWinPriv->mapped && !pWinPriv->offscreen)
+            dmxCreateAndRealizeWindow(pWin, TRUE);
+
+        /* Next, create the bottom-most child */
+        if (pWin->lastChild) {
+            pWin = pWin->lastChild;
+            continue;
+        }
+
+        /* If the window has no children, move on to the next higher window */
+        while (!pWin->prevSib && (pWin != pRoot))
+            pWin = pWin->parent;
+
+        if (pWin->prevSib) {
+            pWin = pWin->prevSib;
+            continue;
+        }
+
+        /* When we reach the root window, we are finished */
+        if (pWin == pRoot)
+            break;
     }
 }
 
 /* Refresh screen by generating exposure events for all windows */
-static void dmxForceExposures(int idx)
+static void
+dmxForceExposures(int idx)
 {
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-    WindowPtr  pRoot     = pScreen->root;
-    Bool       anyMarked = FALSE;
-    WindowPtr  pChild;
+    ScreenPtr pScreen = screenInfo.screens[idx];
+    WindowPtr pRoot = pScreen->root;
+    Bool anyMarked = FALSE;
+    WindowPtr pChild;
 
     for (pChild = pRoot->firstChild; pChild; pChild = pChild->nextSib)
-	anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
-						    (WindowPtr *)NULL);
+        anyMarked |= pScreen->MarkOverlappedWindows(pChild, pChild,
+                                                    (WindowPtr *) NULL);
     if (anyMarked) {
-	/* If any windows have been marked, set the root window's
-	 * clipList to be broken since it will be recalculated in
-	 * ValidateTree()
-	 */
-	RegionBreak(&pRoot->clipList);
-	pScreen->ValidateTree(pRoot, NULL, VTBroken);
-	pScreen->HandleExposures(pRoot);
-	if (pScreen->PostValidateTree)
-	    pScreen->PostValidateTree(pRoot, NULL, VTBroken);
+        /* If any windows have been marked, set the root window's
+         * clipList to be broken since it will be recalculated in
+         * ValidateTree()
+         */
+        RegionBreak(&pRoot->clipList);
+        pScreen->ValidateTree(pRoot, NULL, VTBroken);
+        pScreen->HandleExposures(pRoot);
+        if (pScreen->PostValidateTree)
+            pScreen->PostValidateTree(pRoot, NULL, VTBroken);
     }
 }
 
 /** Compare the new and old screens to see if they are compatible. */
-static Bool dmxCompareScreens(DMXScreenInfo *new, DMXScreenInfo *old)
+static Bool
+dmxCompareScreens(DMXScreenInfo * new, DMXScreenInfo * old)
 {
     int i;
 
-    if (new->beWidth != old->beWidth) return FALSE;
-    if (new->beHeight != old->beHeight) return FALSE;
-    if (new->beDepth != old->beDepth) return FALSE;
-    if (new->beBPP != old->beBPP) return FALSE;
-
-    if (new->beNumDepths != old->beNumDepths) return FALSE;
+    if (new->beWidth != old->beWidth)
+        return FALSE;
+    if (new->beHeight != old->beHeight)
+        return FALSE;
+    if (new->beDepth != old->beDepth)
+        return FALSE;
+    if (new->beBPP != old->beBPP)
+        return FALSE;
+
+    if (new->beNumDepths != old->beNumDepths)
+        return FALSE;
     for (i = 0; i < old->beNumDepths; i++)
-	if (new->beDepths[i] != old->beDepths[i]) return FALSE;
+        if (new->beDepths[i] != old->beDepths[i])
+            return FALSE;
 
-    if (new->beNumPixmapFormats != old->beNumPixmapFormats) return FALSE;
+    if (new->beNumPixmapFormats != old->beNumPixmapFormats)
+        return FALSE;
     for (i = 0; i < old->beNumPixmapFormats; i++) {
-	if (new->bePixmapFormats[i].depth !=
-	    old->bePixmapFormats[i].depth) return FALSE;
-	if (new->bePixmapFormats[i].bits_per_pixel !=
-	    old->bePixmapFormats[i].bits_per_pixel) return FALSE;
-	if (new->bePixmapFormats[i].scanline_pad !=
-	    old->bePixmapFormats[i].scanline_pad) return FALSE;
+        if (new->bePixmapFormats[i].depth != old->bePixmapFormats[i].depth)
+            return FALSE;
+        if (new->bePixmapFormats[i].bits_per_pixel !=
+            old->bePixmapFormats[i].bits_per_pixel)
+            return FALSE;
+        if (new->bePixmapFormats[i].scanline_pad !=
+            old->bePixmapFormats[i].scanline_pad)
+            return FALSE;
     }
 
-    if (new->beNumVisuals != old->beNumVisuals) return FALSE;
+    if (new->beNumVisuals != old->beNumVisuals)
+        return FALSE;
     for (i = 0; i < old->beNumVisuals; i++) {
-	if (new->beVisuals[i].visualid !=
-	    old->beVisuals[i].visualid) return FALSE;
-	if (new->beVisuals[i].screen !=
-	    old->beVisuals[i].screen) return FALSE;
-	if (new->beVisuals[i].depth !=
-	    old->beVisuals[i].depth) return FALSE;
-	if (new->beVisuals[i].class !=
-	    old->beVisuals[i].class) return FALSE;
-	if (new->beVisuals[i].red_mask !=
-	    old->beVisuals[i].red_mask) return FALSE;
-	if (new->beVisuals[i].green_mask !=
-	    old->beVisuals[i].green_mask) return FALSE;
-	if (new->beVisuals[i].blue_mask !=
-	    old->beVisuals[i].blue_mask) return FALSE;
-	if (new->beVisuals[i].colormap_size !=
-	    old->beVisuals[i].colormap_size) return FALSE;
-	if (new->beVisuals[i].bits_per_rgb !=
-	    old->beVisuals[i].bits_per_rgb) return FALSE;
-    }
-
-    if (new->beDefVisualIndex != old->beDefVisualIndex) return FALSE;
+        if (new->beVisuals[i].visualid != old->beVisuals[i].visualid)
+            return FALSE;
+        if (new->beVisuals[i].screen != old->beVisuals[i].screen)
+            return FALSE;
+        if (new->beVisuals[i].depth != old->beVisuals[i].depth)
+            return FALSE;
+        if (new->beVisuals[i].class != old->beVisuals[i].class)
+            return FALSE;
+        if (new->beVisuals[i].red_mask != old->beVisuals[i].red_mask)
+            return FALSE;
+        if (new->beVisuals[i].green_mask != old->beVisuals[i].green_mask)
+            return FALSE;
+        if (new->beVisuals[i].blue_mask != old->beVisuals[i].blue_mask)
+            return FALSE;
+        if (new->beVisuals[i].colormap_size != old->beVisuals[i].colormap_size)
+            return FALSE;
+        if (new->beVisuals[i].bits_per_rgb != old->beVisuals[i].bits_per_rgb)
+            return FALSE;
+    }
+
+    if (new->beDefVisualIndex != old->beDefVisualIndex)
+        return FALSE;
 
     return TRUE;
 }
 
 /** Restore Render's picture */
-static void dmxBERestoreRenderPict(pointer value, XID id, pointer n)
+static void
+dmxBERestoreRenderPict(pointer value, XID id, pointer n)
 {
-    PicturePtr   pPicture = value;               /* The picture */
-    DrawablePtr  pDraw    = pPicture->pDrawable; /* The picture's drawable */
-    int          scrnNum  = (uintptr_t)n;
+    PicturePtr pPicture = value;        /* The picture */
+    DrawablePtr pDraw = pPicture->pDrawable;    /* The picture's drawable */
+    int scrnNum = (uintptr_t) n;
 
     if (pDraw->pScreen->myNum != scrnNum) {
-	/* Picture not on the screen we are restoring*/
-	return;
+        /* Picture not on the screen we are restoring */
+        return;
     }
 
     if (pDraw->type == DRAWABLE_PIXMAP) {
-	PixmapPtr  pPixmap = (PixmapPtr)pDraw;
-	
-	/* Create and restore the pixmap drawable */
-	dmxBECreatePixmap(pPixmap);
-	dmxBERestorePixmap(pPixmap);
+        PixmapPtr pPixmap = (PixmapPtr) pDraw;
+
+        /* Create and restore the pixmap drawable */
+        dmxBECreatePixmap(pPixmap);
+        dmxBERestorePixmap(pPixmap);
     }
 
     dmxBECreatePicture(pPicture);
 }
 
 /** Restore Render's glyphs */
-static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n)
+static void
+dmxBERestoreRenderGlyph(pointer value, XID id, pointer n)
 {
-    GlyphSetPtr      glyphSet   = value;
-    int              scrnNum    = (uintptr_t)n;
-    dmxGlyphPrivPtr  glyphPriv  = DMX_GET_GLYPH_PRIV(glyphSet);
-    DMXScreenInfo   *dmxScreen  = &dmxScreens[scrnNum];
-    GlyphRefPtr      table;
-    char            *images;
-    Glyph           *gids;
-    XGlyphInfo      *glyphs;
-    char            *pos;
-    int              beret;
-    int              len_images = 0;
-    int              i;
-    int              ctr;
+    GlyphSetPtr glyphSet = value;
+    int scrnNum = (uintptr_t) n;
+    dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+    DMXScreenInfo *dmxScreen = &dmxScreens[scrnNum];
+    GlyphRefPtr table;
+    char *images;
+    Glyph *gids;
+    XGlyphInfo *glyphs;
+    char *pos;
+    int beret;
+    int len_images = 0;
+    int i;
+    int ctr;
 
     if (glyphPriv->glyphSets[scrnNum]) {
-	/* Only restore glyphs on the screen we are attaching */
-	return;
+        /* Only restore glyphs on the screen we are attaching */
+        return;
     }
 
     /* First we must create the glyph set on the backend. */
     if ((beret = dmxBECreateGlyphSet(scrnNum, glyphSet)) != Success) {
-	dmxLog(dmxWarning,
-	       "\tdmxBERestoreRenderGlyph failed to create glyphset!\n");
-	return;
+        dmxLog(dmxWarning,
+               "\tdmxBERestoreRenderGlyph failed to create glyphset!\n");
+        return;
     }
 
     /* Now for the complex part, restore the glyph data */
@@ -1111,89 +1175,92 @@ static void dmxBERestoreRenderGlyph(pointer value, XID id, pointer n)
 
     /* We need to know how much memory to allocate for this part */
     for (i = 0; i < glyphSet->hash.hashSet->size; i++) {
-	GlyphRefPtr  gr = &table[i];
-	GlyphPtr     gl = gr->glyph;
+        GlyphRefPtr gr = &table[i];
+        GlyphPtr gl = gr->glyph;
 
-	if (!gl || gl == DeletedGlyph) continue;
-	len_images += gl->size - sizeof(gl->info);
+        if (!gl || gl == DeletedGlyph)
+            continue;
+        len_images += gl->size - sizeof(gl->info);
     }
 
     /* Now allocate the memory we need */
     images = calloc(len_images, sizeof(char));
-    gids   = malloc(glyphSet->hash.tableEntries*sizeof(Glyph));
-    glyphs = malloc(glyphSet->hash.tableEntries*sizeof(XGlyphInfo));
+    gids = malloc(glyphSet->hash.tableEntries * sizeof(Glyph));
+    glyphs = malloc(glyphSet->hash.tableEntries * sizeof(XGlyphInfo));
 
     pos = images;
     ctr = 0;
-    
+
     /* Fill the allocated memory with the proper data */
     for (i = 0; i < glyphSet->hash.hashSet->size; i++) {
-	GlyphRefPtr  gr = &table[i];
-	GlyphPtr     gl = gr->glyph;
-
-	if (!gl || gl == DeletedGlyph) continue;
-
-	/* First lets put the data into gids */
-	gids[ctr] = gr->signature;
-
-	/* Next do the glyphs data structures */
-	glyphs[ctr].width  = gl->info.width;
-	glyphs[ctr].height = gl->info.height;
-	glyphs[ctr].x      = gl->info.x;
-	glyphs[ctr].y      = gl->info.y;
-	glyphs[ctr].xOff   = gl->info.xOff;
-	glyphs[ctr].yOff   = gl->info.yOff;
-
-	/* Copy the images from the DIX's data into the buffer */
-	memcpy(pos, gl+1, gl->size - sizeof(gl->info));
-	pos += gl->size - sizeof(gl->info);
-	ctr++;
+        GlyphRefPtr gr = &table[i];
+        GlyphPtr gl = gr->glyph;
+
+        if (!gl || gl == DeletedGlyph)
+            continue;
+
+        /* First lets put the data into gids */
+        gids[ctr] = gr->signature;
+
+        /* Next do the glyphs data structures */
+        glyphs[ctr].width = gl->info.width;
+        glyphs[ctr].height = gl->info.height;
+        glyphs[ctr].x = gl->info.x;
+        glyphs[ctr].y = gl->info.y;
+        glyphs[ctr].xOff = gl->info.xOff;
+        glyphs[ctr].yOff = gl->info.yOff;
+
+        /* Copy the images from the DIX's data into the buffer */
+        memcpy(pos, gl + 1, gl->size - sizeof(gl->info));
+        pos += gl->size - sizeof(gl->info);
+        ctr++;
     }
-    
+
     /* Now restore the glyph data */
     XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],
-		     gids,glyphs, glyphSet->hash.tableEntries, images,
-		     len_images);
+                     gids, glyphs, glyphSet->hash.tableEntries, images,
+                     len_images);
 
     /* Clean up */
     free(images);
     free(gids);
-    free(glyphs);    
+    free(glyphs);
 }
 
 /** Reattach previously detached back-end screen. */
-int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
+int
+dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
 {
-    ScreenPtr      pScreen;
+    ScreenPtr pScreen;
     DMXScreenInfo *dmxScreen;
-    CARD32         scrnNum   = idx;
-    DMXScreenInfo  oldDMXScreen;
-    int            i;
+    CARD32 scrnNum = idx;
+    DMXScreenInfo oldDMXScreen;
+    int i;
 
     /* Return failure if dynamic addition/removal of screens is disabled */
     if (!dmxAddRemoveScreens) {
-	dmxLog(dmxWarning,
-	       "Attempting to add a screen, but the AddRemoveScreen\n");
-	dmxLog(dmxWarning,
-	       "extension has not been enabled.  To enable this extension\n");
-	dmxLog(dmxWarning,
-	       "add the \"-addremovescreens\" option either to the command\n");
-	dmxLog(dmxWarning,
-	       "line or in the configuration file.\n");
-	return 1;
+        dmxLog(dmxWarning,
+               "Attempting to add a screen, but the AddRemoveScreen\n");
+        dmxLog(dmxWarning,
+               "extension has not been enabled.  To enable this extension\n");
+        dmxLog(dmxWarning,
+               "add the \"-addremovescreens\" option either to the command\n");
+        dmxLog(dmxWarning, "line or in the configuration file.\n");
+        return 1;
     }
 
     /* Cannot add a screen that does not exist */
-    if (idx < 0 || idx >= dmxNumScreens) return 1;
+    if (idx < 0 || idx >= dmxNumScreens)
+        return 1;
     pScreen = screenInfo.screens[idx];
     dmxScreen = &dmxScreens[idx];
 
     /* Cannot attach to a screen that is already opened */
     if (dmxScreen->beDisplay) {
-	dmxLog(dmxWarning,
-	       "Attempting to add screen #%d but a screen already exists\n",
-	       idx);
-	return 1;
+        dmxLog(dmxWarning,
+               "Attempting to add screen #%d but a screen already exists\n",
+               idx);
+        return 1;
     }
 
     dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);
@@ -1206,13 +1273,12 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
 
     /* Open display and get all of the screen info */
     if (!dmxOpenDisplay(dmxScreen)) {
-	dmxLog(dmxWarning,
-               "dmxOpenDisplay: Unable to open display %s\n",
-               dmxScreen->name);
+        dmxLog(dmxWarning,
+               "dmxOpenDisplay: Unable to open display %s\n", dmxScreen->name);
 
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
+        /* Restore the old screen */
+        *dmxScreen = oldDMXScreen;
+        return 1;
     }
 
     dmxSetErrorHandler(dmxScreen);
@@ -1220,13 +1286,13 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
     dmxGetScreenAttribs(dmxScreen);
 
     if (!dmxGetVisualInfo(dmxScreen)) {
-	dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
-	XFree(dmxScreen->beVisuals);
-	XCloseDisplay(dmxScreen->beDisplay);
+        dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
+        XFree(dmxScreen->beVisuals);
+        XCloseDisplay(dmxScreen->beDisplay);
 
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
+        /* Restore the old screen */
+        *dmxScreen = oldDMXScreen;
+        return 1;
     }
 
     dmxGetColormaps(dmxScreen);
@@ -1235,23 +1301,20 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
     /* Verify that the screen to be added has the same info as the
      * previously added screen. */
     if (!dmxCompareScreens(dmxScreen, &oldDMXScreen)) {
-	dmxLog(dmxWarning,
-	       "New screen data (%s) does not match previously\n",
-	       dmxScreen->name);
-	dmxLog(dmxWarning,
-	       "attached screen data (%s)\n",
-	       oldDMXScreen.name);
-	dmxLog(dmxWarning,
-	       "All data must match in order to attach to screen #%d\n",
-	       idx);
-	XFree(dmxScreen->beVisuals);
-	XFree(dmxScreen->beDepths);
-	XFree(dmxScreen->bePixmapFormats);
-	XCloseDisplay(dmxScreen->beDisplay);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
+        dmxLog(dmxWarning,
+               "New screen data (%s) does not match previously\n",
+               dmxScreen->name);
+        dmxLog(dmxWarning, "attached screen data (%s)\n", oldDMXScreen.name);
+        dmxLog(dmxWarning,
+               "All data must match in order to attach to screen #%d\n", idx);
+        XFree(dmxScreen->beVisuals);
+        XFree(dmxScreen->beDepths);
+        XFree(dmxScreen->bePixmapFormats);
+        XCloseDisplay(dmxScreen->beDisplay);
+
+        /* Restore the old screen */
+        *dmxScreen = oldDMXScreen;
+        return 1;
     }
 
     /* Initialize the BE screen resources */
@@ -1268,30 +1331,30 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
     dmxBECreateScratchGCs(idx);
 
     /* Create the default font */
-    (void)dmxBELoadFont(pScreen, defaultFont);
+    (void) dmxBELoadFont(pScreen, defaultFont);
 
     /* Create all resources that don't depend on windows */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBECreateResources,
-				   (pointer)(uintptr_t)idx);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindAllClientResources(clients[i], dmxBECreateResources,
+                                   (pointer) (uintptr_t) idx);
 
     /* Create window hierarchy (top down) */
     dmxBECreateWindowTree(idx);
 
     /* Restore the picture state for RENDER */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindClientResourcesByType(clients[i],PictureType, 
-				      dmxBERestoreRenderPict,
-				      (pointer)(uintptr_t)idx);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindClientResourcesByType(clients[i], PictureType,
+                                      dmxBERestoreRenderPict,
+                                      (pointer) (uintptr_t) idx);
 
     /* Restore the glyph state for RENDER */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindClientResourcesByType(clients[i],GlyphSetType, 
-				      dmxBERestoreRenderGlyph,
-				      (pointer)(uintptr_t)idx);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindClientResourcesByType(clients[i], GlyphSetType,
+                                      dmxBERestoreRenderGlyph,
+                                      (pointer) (uintptr_t) idx);
 
     /* Refresh screen by generating exposure events for all windows */
     dmxForceExposures(idx);
@@ -1308,10 +1371,10 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
 
 #ifdef PANORAMIX
     if (!noPanoramiXExtension)
-	return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
+        return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
     else
 #endif
-	return 0; /* Success */
+        return 0;               /* Success */
 }
 
 /*
@@ -1358,34 +1421,36 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
 #ifdef PANORAMIX
 /** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs
  *  to have its image saved. */
-static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type,
-				 pointer p)
+static void
+dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type, pointer p)
 {
     if ((type & TypeMask) == (XRT_PIXMAP & TypeMask)) {
-	PixmapPtr      pDst     = (PixmapPtr)p;
-	int            idx      = pDst->drawable.pScreen->myNum;
-	PanoramiXRes  *pXinPix  = (PanoramiXRes *)value;
-	PixmapPtr      pPix;
-	int            i;
-
-	dixLookupResourceByType((pointer*) &pPix, pXinPix->info[idx].id,
-				RT_PIXMAP, NullClient, DixUnknownAccess);
-	if (pPix != pDst) return; /* Not a match.... Next! */
-
-	FOR_NSCREENS(i) {
-	    PixmapPtr      pSrc;
-	    dmxPixPrivPtr  pSrcPriv = NULL;
-
-	    if (i == idx) continue; /* Self replication is bad */
-
-	    dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id,
-				    RT_PIXMAP, NullClient, DixUnknownAccess);
-	    pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-	    if (pSrcPriv->pixmap) {
-		FoundPixImage = True;
-		return;
-	    }
-	}
+        PixmapPtr pDst = (PixmapPtr) p;
+        int idx = pDst->drawable.pScreen->myNum;
+        PanoramiXRes *pXinPix = (PanoramiXRes *) value;
+        PixmapPtr pPix;
+        int i;
+
+        dixLookupResourceByType((pointer *) &pPix, pXinPix->info[idx].id,
+                                RT_PIXMAP, NullClient, DixUnknownAccess);
+        if (pPix != pDst)
+            return;             /* Not a match.... Next! */
+
+        FOR_NSCREENS(i) {
+            PixmapPtr pSrc;
+            dmxPixPrivPtr pSrcPriv = NULL;
+
+            if (i == idx)
+                continue;       /* Self replication is bad */
+
+            dixLookupResourceByType((pointer *) &pSrc, pXinPix->info[i].id,
+                                    RT_PIXMAP, NullClient, DixUnknownAccess);
+            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
+            if (pSrcPriv->pixmap) {
+                FoundPixImage = True;
+                return;
+            }
+        }
     }
 }
 #endif
@@ -1399,40 +1464,41 @@ static void dmxBEFindPixmapImage(pointer value, XID id, RESTYPE type,
  *  However, if we do not find one, then we need to save the image data.
  *  The common case for these are for the default stipple and root
  *  tile. */
-static void dmxBESavePixmap(PixmapPtr pPixmap)
+static void
+dmxBESavePixmap(PixmapPtr pPixmap)
 {
 #ifdef PANORAMIX
     int i;
 
     /* If Xinerama is not active, there's nothing we can do (see comment
      * in #else below for more info). */
-    if (noPanoramiXExtension) return;
+    if (noPanoramiXExtension)
+        return;
 
     FoundPixImage = False;
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBEFindPixmapImage,
-				   (pointer)pPixmap);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindAllClientResources(clients[i], dmxBEFindPixmapImage,
+                                   (pointer) pPixmap);
 
     /* Save the image only if there is no other screens that have a
      * pixmap that corresponds to the one we are trying to save. */
     if (!FoundPixImage) {
-	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
-
-	if (!pPixPriv->detachedImage) {
-	    ScreenPtr      pScreen   = pPixmap->drawable.pScreen;
-	    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-
-	    pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay,
-						pPixPriv->pixmap,
-						0, 0,
-						pPixmap->drawable.width,
-						pPixmap->drawable.height,
-						-1,
-						ZPixmap);
-	    if (!pPixPriv->detachedImage)
-		dmxLog(dmxWarning, "Cannot save pixmap image\n");
-	}
+        dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pPixmap);
+
+        if (!pPixPriv->detachedImage) {
+            ScreenPtr pScreen = pPixmap->drawable.pScreen;
+            DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
+
+            pPixPriv->detachedImage = XGetImage(dmxScreen->beDisplay,
+                                                pPixPriv->pixmap,
+                                                0, 0,
+                                                pPixmap->drawable.width,
+                                                pPixmap->drawable.height,
+                                                -1, ZPixmap);
+            if (!pPixPriv->detachedImage)
+                dmxLog(dmxWarning, "Cannot save pixmap image\n");
+        }
     }
 #else
     /* NOTE: The only time there is a pixmap on another screen that
@@ -1452,59 +1518,73 @@ static void dmxBESavePixmap(PixmapPtr pPixmap)
  *  function.  It walks all resources, compares them to the screen
  *  number passed in as \a n and calls the appropriate DMX function to
  *  free the associated resource on the back-end server. */
-static void dmxBEDestroyResources(pointer value, XID id, RESTYPE type,
-				  pointer n)
+static void
+dmxBEDestroyResources(pointer value, XID id, RESTYPE type, pointer n)
 {
-    int        scrnNum = (uintptr_t)n;
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
+    int scrnNum = (uintptr_t) n;
+    ScreenPtr pScreen = screenInfo.screens[scrnNum];
 
     if ((type & TypeMask) == (RT_WINDOW & TypeMask)) {
-	/* Window resources are destroyed below in dmxBEDestroyWindowTree */
-    } else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
-	PixmapPtr  pPix = value;
-	if (pPix->drawable.pScreen->myNum == scrnNum) {
-	    dmxBESavePixmap(pPix);
-	    dmxBEFreePixmap(pPix);
-	}
-    } else if ((type & TypeMask) == (RT_GC & TypeMask)) {
-	GCPtr  pGC = value;
-	if (pGC->pScreen->myNum == scrnNum)
-	    dmxBEFreeGC(pGC);
-    } else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
-	dmxBEFreeFont(pScreen, (FontPtr)value);
-    } else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
-	dmxBEFreeCursor(pScreen, (CursorPtr)value);
-    } else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
-	ColormapPtr  pCmap = value;
-	if (pCmap->pScreen->myNum == scrnNum)
-	    dmxBEFreeColormap((ColormapPtr)value);
-    } else if ((type & TypeMask) == (PictureType & TypeMask)) {
-	PicturePtr  pPict = value;
-	if (pPict->pDrawable->pScreen->myNum == scrnNum) {
-	    /* Free the pixmaps on the backend if needed */
-	    if (pPict->pDrawable->type == DRAWABLE_PIXMAP) {
-		PixmapPtr pPixmap = (PixmapPtr)(pPict->pDrawable);
-		dmxBESavePixmap(pPixmap);
-		dmxBEFreePixmap(pPixmap);
-	    }
-	    dmxBEFreePicture((PicturePtr)value);
-	}
-    } else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
-	dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr)value);
-    } else {
-	/* Other resource types??? */
+        /* Window resources are destroyed below in dmxBEDestroyWindowTree */
+    }
+    else if ((type & TypeMask) == (RT_PIXMAP & TypeMask)) {
+        PixmapPtr pPix = value;
+
+        if (pPix->drawable.pScreen->myNum == scrnNum) {
+            dmxBESavePixmap(pPix);
+            dmxBEFreePixmap(pPix);
+        }
+    }
+    else if ((type & TypeMask) == (RT_GC & TypeMask)) {
+        GCPtr pGC = value;
+
+        if (pGC->pScreen->myNum == scrnNum)
+            dmxBEFreeGC(pGC);
+    }
+    else if ((type & TypeMask) == (RT_FONT & TypeMask)) {
+        dmxBEFreeFont(pScreen, (FontPtr) value);
+    }
+    else if ((type & TypeMask) == (RT_CURSOR & TypeMask)) {
+        dmxBEFreeCursor(pScreen, (CursorPtr) value);
+    }
+    else if ((type & TypeMask) == (RT_COLORMAP & TypeMask)) {
+        ColormapPtr pCmap = value;
+
+        if (pCmap->pScreen->myNum == scrnNum)
+            dmxBEFreeColormap((ColormapPtr) value);
+    }
+    else if ((type & TypeMask) == (PictureType & TypeMask)) {
+        PicturePtr pPict = value;
+
+        if (pPict->pDrawable->pScreen->myNum == scrnNum) {
+            /* Free the pixmaps on the backend if needed */
+            if (pPict->pDrawable->type == DRAWABLE_PIXMAP) {
+                PixmapPtr pPixmap = (PixmapPtr) (pPict->pDrawable);
+
+                dmxBESavePixmap(pPixmap);
+                dmxBEFreePixmap(pPixmap);
+            }
+            dmxBEFreePicture((PicturePtr) value);
+        }
+    }
+    else if ((type & TypeMask) == (GlyphSetType & TypeMask)) {
+        dmxBEFreeGlyphSet(pScreen, (GlyphSetPtr) value);
+    }
+    else {
+        /* Other resource types??? */
     }
 }
 
 /** Destroy the scratch GCs that are created per depth. */
-static void dmxBEDestroyScratchGCs(int scrnNum)
+static void
+dmxBEDestroyScratchGCs(int scrnNum)
 {
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
+    ScreenPtr pScreen = screenInfo.screens[scrnNum];
+    GCPtr *ppGC = pScreen->GCperDepth;
+    int i;
 
     for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBEFreeGC(ppGC[i]);
+        dmxBEFreeGC(ppGC[i]);
 }
 
 /** Destroy window hierachy on back-end server.  To ensure that all
@@ -1512,79 +1592,81 @@ static void dmxBEDestroyScratchGCs(int scrnNum)
  *  up order so that windows are not destroyed before their children.
  *  XDestroyWindow(), which is called from #dmxBEDestroyWindow(), will
  *  destroy a window as well as all of it's children. */
-static void dmxBEDestroyWindowTree(int idx)
+static void
+dmxBEDestroyWindowTree(int idx)
 {
-    WindowPtr  pWin   = screenInfo.screens[idx]->root;
-    WindowPtr  pChild = pWin;
+    WindowPtr pWin = screenInfo.screens[idx]->root;
+    WindowPtr pChild = pWin;
 
     while (1) {
-	if (pChild->firstChild) {
-	    pChild = pChild->firstChild;
-	    continue;
-	}
-
-	/* Destroy the window */
-	dmxBEDestroyWindow(pChild);
-
-	/* Make sure we destroy the window's border and background
-	 * pixmaps if they exist */
-	if (!pChild->borderIsPixel) {
-	    dmxBESavePixmap(pChild->border.pixmap);
-	    dmxBEFreePixmap(pChild->border.pixmap);
-	}
-	if (pChild->backgroundState == BackgroundPixmap) {
-	    dmxBESavePixmap(pChild->background.pixmap);
-	    dmxBEFreePixmap(pChild->background.pixmap);
-	}
-
-	while (!pChild->nextSib && (pChild != pWin)) {
-	    pChild = pChild->parent;
-	    dmxBEDestroyWindow(pChild);
-	    if (!pChild->borderIsPixel) {
-		dmxBESavePixmap(pChild->border.pixmap);
-		dmxBEFreePixmap(pChild->border.pixmap);
-	    }
-	    if (pChild->backgroundState == BackgroundPixmap) {
-		dmxBESavePixmap(pChild->background.pixmap);
-		dmxBEFreePixmap(pChild->background.pixmap);
-	    }
-	}
-
-	if (pChild == pWin)
-	    break;
-
-	pChild = pChild->nextSib;
+        if (pChild->firstChild) {
+            pChild = pChild->firstChild;
+            continue;
+        }
+
+        /* Destroy the window */
+        dmxBEDestroyWindow(pChild);
+
+        /* Make sure we destroy the window's border and background
+         * pixmaps if they exist */
+        if (!pChild->borderIsPixel) {
+            dmxBESavePixmap(pChild->border.pixmap);
+            dmxBEFreePixmap(pChild->border.pixmap);
+        }
+        if (pChild->backgroundState == BackgroundPixmap) {
+            dmxBESavePixmap(pChild->background.pixmap);
+            dmxBEFreePixmap(pChild->background.pixmap);
+        }
+
+        while (!pChild->nextSib && (pChild != pWin)) {
+            pChild = pChild->parent;
+            dmxBEDestroyWindow(pChild);
+            if (!pChild->borderIsPixel) {
+                dmxBESavePixmap(pChild->border.pixmap);
+                dmxBEFreePixmap(pChild->border.pixmap);
+            }
+            if (pChild->backgroundState == BackgroundPixmap) {
+                dmxBESavePixmap(pChild->background.pixmap);
+                dmxBEFreePixmap(pChild->background.pixmap);
+            }
+        }
+
+        if (pChild == pWin)
+            break;
+
+        pChild = pChild->nextSib;
     }
 }
 
 /** Detach back-end screen. */
-int dmxDetachScreen(int idx)
+int
+dmxDetachScreen(int idx)
 {
     DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    int            i;
+    int i;
 
     /* Return failure if dynamic addition/removal of screens is disabled */
     if (!dmxAddRemoveScreens) {
-	dmxLog(dmxWarning,
-	       "Attempting to remove a screen, but the AddRemoveScreen\n");
-	dmxLog(dmxWarning,
-	       "extension has not been enabled.  To enable this extension\n");
-	dmxLog(dmxWarning,
-	       "add the \"-addremovescreens\" option either to the command\n");
-	dmxLog(dmxWarning,
-	       "line or in the configuration file.\n");
-	return 1;
+        dmxLog(dmxWarning,
+               "Attempting to remove a screen, but the AddRemoveScreen\n");
+        dmxLog(dmxWarning,
+               "extension has not been enabled.  To enable this extension\n");
+        dmxLog(dmxWarning,
+               "add the \"-addremovescreens\" option either to the command\n");
+        dmxLog(dmxWarning, "line or in the configuration file.\n");
+        return 1;
     }
 
     /* Cannot remove a screen that does not exist */
-    if (idx < 0 || idx >= dmxNumScreens) return 1;
+    if (idx < 0 || idx >= dmxNumScreens)
+        return 1;
 
     /* Cannot detach from a screen that is not opened */
     if (!dmxScreen->beDisplay) {
-	dmxLog(dmxWarning,
-	       "Attempting to remove screen #%d but it has not been opened\n",
-	       idx);
-	return 1;
+        dmxLog(dmxWarning,
+               "Attempting to remove screen #%d but it has not been opened\n",
+               idx);
+        return 1;
     }
 
     dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);
@@ -1595,10 +1677,10 @@ int dmxDetachScreen(int idx)
     /* Save all relevant state (TODO) */
 
     /* Free all non-window resources related to this screen */
-    for (i = currentMaxClients; --i >= 0; )
-	if (clients[i])
-	    FindAllClientResources(clients[i], dmxBEDestroyResources,
-				   (pointer)(uintptr_t)idx);
+    for (i = currentMaxClients; --i >= 0;)
+        if (clients[i])
+            FindAllClientResources(clients[i], dmxBEDestroyResources,
+                                   (pointer) (uintptr_t) idx);
 
     /* Free scratch GCs */
     dmxBEDestroyScratchGCs(idx);
@@ -1616,5 +1698,5 @@ int dmxDetachScreen(int idx)
     /* Adjust the cursor boundaries (paints detached console window) */
     dmxAdjustCursorBoundaries();
 
-    return 0; /* Success */
+    return 0;                   /* Success */
 }