9 files changed, 8781 insertions, 8780 deletions
diff --git a/xorg-server/hw/dmx/dmxcb.c b/xorg-server/hw/dmx/dmxcb.c
index d0eb35117..bc3281f56 100644
--- a/xorg-server/hw/dmx/dmxcb.c
+++ b/xorg-server/hw/dmx/dmxcb.c
@@ -1,223 +1,223 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * This code queries and modifies the connection block. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxcb.h"
-#include "dmxinput.h"
-#include "dmxlog.h"
-
-extern int     connBlockScreenStart;
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-extern int     PanoramiXPixWidth;
-extern int     PanoramiXPixHeight;
-extern int     PanoramiXNumScreens;
-#endif
-
-       int     dmxGlobalWidth, dmxGlobalHeight;
-
-/** We may want the wall dimensions to be different from the bounding
- * box dimensions that Xinerama computes, so save those and update them
- * here.
- */
-void dmxSetWidthHeight(int width, int height)
-{
-    dmxGlobalWidth  = width;
-    dmxGlobalHeight = height;
-}
-
-/** Computes the global bounding box for DMX.  This may be larger than
- * the one computed by Xinerama because of the DMX configuration
- * file. */
-void dmxComputeWidthHeight(DMXRecomputeFlag flag)
-{
-    int           i;
-    DMXScreenInfo *dmxScreen;
-    int           w = 0;
-    int           h = 0;
-    
-    for (i = 0; i < dmxNumScreens; i++) {
-                                /* Don't use root* here because this is
-                                 * the global bounding box. */
-        dmxScreen = &dmxScreens[i];
-        if (w < dmxScreen->scrnWidth + dmxScreen->rootXOrigin)
-            w = dmxScreen->scrnWidth + dmxScreen->rootXOrigin;
-        if (h < dmxScreen->scrnHeight + dmxScreen->rootYOrigin)
-            h = dmxScreen->scrnHeight + dmxScreen->rootYOrigin;
-    }
-    if (!dmxGlobalWidth && !dmxGlobalHeight) {
-        dmxLog(dmxInfo, "Using %dx%d as global bounding box\n", w, h);
-    } else {
-        switch (flag) {
-        case DMX_NO_RECOMPUTE_BOUNDING_BOX:
-            dmxLog(dmxInfo,
-                   "Using old bounding box (%dx%d) instead of new (%dx%d)\n",
-                   dmxGlobalWidth, dmxGlobalHeight, w, h);
-            w = dmxGlobalWidth;
-            h = dmxGlobalHeight;
-            break;
-        case DMX_RECOMPUTE_BOUNDING_BOX:
-            dmxLog(dmxInfo,
-                   "Using %dx%d as global bounding box, instead of %dx%d\n",
-                   w, h, dmxGlobalWidth, dmxGlobalHeight);
-            break;
-        }
-    }
-        
-    dmxGlobalWidth  = w;
-    dmxGlobalHeight = h;
-}
-
-/** A callback routine that hooks into Xinerama and provides a
- * convenient place to print summary log information during server
- * startup.  This routine does not modify any values. */
-void dmxConnectionBlockCallback(void)
-{
-    xWindowRoot *root   = (xWindowRoot *)(ConnectionInfo+connBlockScreenStart);
-    int         offset  = connBlockScreenStart + sizeof(xWindowRoot);
-    int         i;
-    Bool        *found  = NULL;
-
-    MAXSCREENSALLOC(found);
-    if (!found)
-        dmxLog(dmxFatal, "dmxConnectionBlockCallback: out of memory\n");
-
-    dmxLog(dmxInfo, "===== Start of Summary =====\n");
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-        if (dmxGlobalWidth && dmxGlobalHeight
-            && (dmxGlobalWidth != PanoramiXPixWidth
-                || dmxGlobalHeight != PanoramiXPixHeight)) {
-            dmxLog(dmxInfo,
-                   "Changing Xinerama dimensions from %d %d to %d %d\n",
-                   PanoramiXPixWidth, PanoramiXPixHeight,
-                   dmxGlobalWidth, dmxGlobalHeight);
-            PanoramiXPixWidth  = root->pixWidth  = dmxGlobalWidth;
-            PanoramiXPixHeight = root->pixHeight = dmxGlobalHeight;
-        } else {
-            dmxGlobalWidth  = PanoramiXPixWidth;
-            dmxGlobalHeight = PanoramiXPixHeight;
-        }
-        dmxLog(dmxInfo, "%d screens configured with Xinerama (%d %d)\n",
-               PanoramiXNumScreens, PanoramiXPixWidth, PanoramiXPixHeight);
-	FOR_NSCREENS(i) found[i] = FALSE;
-    } else {
-#endif
-                                /* This never happens because we're
-                                 * either called from a Xinerama
-                                 * callback or during reconfiguration
-                                 * (which only works with Xinerama on).
-                                 * In any case, be reasonable. */
-        dmxLog(dmxInfo, "%d screens configured (%d %d)\n",
-               screenInfo.numScreens, root->pixWidth, root->pixHeight);
-#ifdef PANORAMIX
-    }
-#endif
-
-    for (i = 0; i < root->nDepths; i++) {
-        xDepth      *depth  = (xDepth *)(ConnectionInfo + offset);
-        int         voffset = offset + sizeof(xDepth);
-        xVisualType *visual = (xVisualType *)(ConnectionInfo + voffset);
-        int         j;
-        
-        dmxLog(dmxInfo, "%d visuals at depth %d:\n",
-               depth->nVisuals, depth->depth);
-        for (j = 0; j < depth->nVisuals; j++, visual++) {
-            XVisualInfo vi;
-            
-            vi.visual        = NULL;
-            vi.visualid      = visual->visualID;
-            vi.screen        = 0;
-            vi.depth         = depth->depth;
-            vi.class         = visual->class;
-            vi.red_mask      = visual->redMask;
-            vi.green_mask    = visual->greenMask;
-            vi.blue_mask     = visual->blueMask;
-            vi.colormap_size = visual->colormapEntries;
-            vi.bits_per_rgb  = visual->bitsPerRGB;
-            dmxLogVisual(NULL, &vi, 0);
-
-#ifdef PANORAMIX
-	    if (!noPanoramiXExtension) {
-		int  k;
-		FOR_NSCREENS(k) {
-		    DMXScreenInfo *dmxScreen = &dmxScreens[k];
-
-		    if (dmxScreen->beDisplay) {
-			XVisualInfo *pvi =
-			    &dmxScreen->beVisuals[dmxScreen->beDefVisualIndex];
-			if (pvi->depth == depth->depth &&
-			    pvi->class == visual->class)
-			    found[k] = TRUE;
-		    } else {
-			/* Screen #k is detatched, so it always succeeds */
-			found[k] = TRUE;
-		    }
-		}
-	    }
-#endif
-        }
-        offset = voffset + depth->nVisuals * sizeof(xVisualType);
-    }
-
-    dmxInputLogDevices();
-    dmxLog(dmxInfo, "===== End of Summary =====\n");
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-	Bool fatal = FALSE;
-	FOR_NSCREENS(i) {
-	    fatal |= !found[i];
-	    if (!found[i]) {
-		dmxLog(dmxError,
-		       "The default visual for screen #%d does not match "
-		       "any of the\n", i);
-		dmxLog(dmxError,
-		       "consolidated visuals from Xinerama (listed above)\n");
-	    }
-	}
-	if (fatal)
-            dmxLog(dmxFatal,
-                   "dmxConnectionBlockCallback: invalid screen(s) found");
-    }
-#endif
-    MAXSCREENSFREE(found);
-}
+/*
+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ * This code queries and modifies the connection block. */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxcb.h"
+#include "dmxinput.h"
+#include "dmxlog.h"
+
+extern int     connBlockScreenStart;
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.h"
+extern int     PanoramiXPixWidth;
+extern int     PanoramiXPixHeight;
+extern int     PanoramiXNumScreens;
+#endif
+
+       int     dmxGlobalWidth, dmxGlobalHeight;
+
+/** We may want the wall dimensions to be different from the bounding
+ * box dimensions that Xinerama computes, so save those and update them
+ * here.
+ */
+void dmxSetWidthHeight(int width, int height)
+{
+    dmxGlobalWidth  = width;
+    dmxGlobalHeight = height;
+}
+
+/** Computes the global bounding box for DMX.  This may be larger than
+ * the one computed by Xinerama because of the DMX configuration
+ * file. */
+void dmxComputeWidthHeight(DMXRecomputeFlag flag)
+{
+    int           i;
+    DMXScreenInfo *dmxScreen;
+    int           w = 0;
+    int           h = 0;
+    
+    for (i = 0; i < dmxNumScreens; i++) {
+                                /* Don't use root* here because this is
+                                 * the global bounding box. */
+        dmxScreen = &dmxScreens[i];
+        if (w < dmxScreen->scrnWidth + dmxScreen->rootXOrigin)
+            w = dmxScreen->scrnWidth + dmxScreen->rootXOrigin;
+        if (h < dmxScreen->scrnHeight + dmxScreen->rootYOrigin)
+            h = dmxScreen->scrnHeight + dmxScreen->rootYOrigin;
+    }
+    if (!dmxGlobalWidth && !dmxGlobalHeight) {
+        dmxLog(dmxInfo, "Using %dx%d as global bounding box\n", w, h);
+    } else {
+        switch (flag) {
+        case DMX_NO_RECOMPUTE_BOUNDING_BOX:
+            dmxLog(dmxInfo,
+                   "Using old bounding box (%dx%d) instead of new (%dx%d)\n",
+                   dmxGlobalWidth, dmxGlobalHeight, w, h);
+            w = dmxGlobalWidth;
+            h = dmxGlobalHeight;
+            break;
+        case DMX_RECOMPUTE_BOUNDING_BOX:
+            dmxLog(dmxInfo,
+                   "Using %dx%d as global bounding box, instead of %dx%d\n",
+                   w, h, dmxGlobalWidth, dmxGlobalHeight);
+            break;
+        }
+    }
+        
+    dmxGlobalWidth  = w;
+    dmxGlobalHeight = h;
+}
+
+/** A callback routine that hooks into Xinerama and provides a
+ * convenient place to print summary log information during server
+ * startup.  This routine does not modify any values. */
+void dmxConnectionBlockCallback(void)
+{
+    xWindowRoot *root   = (xWindowRoot *)(ConnectionInfo+connBlockScreenStart);
+    int         offset  = connBlockScreenStart + sizeof(xWindowRoot);
+    int         i;
+    Bool        *found  = NULL;
+
+    MAXSCREENSALLOC(found);
+    if (!found)
+        dmxLog(dmxFatal, "dmxConnectionBlockCallback: out of memory\n");
+
+    dmxLog(dmxInfo, "===== Start of Summary =====\n");
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+        if (dmxGlobalWidth && dmxGlobalHeight
+            && (dmxGlobalWidth != PanoramiXPixWidth
+                || dmxGlobalHeight != PanoramiXPixHeight)) {
+            dmxLog(dmxInfo,
+                   "Changing Xinerama dimensions from %d %d to %d %d\n",
+                   PanoramiXPixWidth, PanoramiXPixHeight,
+                   dmxGlobalWidth, dmxGlobalHeight);
+            PanoramiXPixWidth  = root->pixWidth  = dmxGlobalWidth;
+            PanoramiXPixHeight = root->pixHeight = dmxGlobalHeight;
+        } else {
+            dmxGlobalWidth  = PanoramiXPixWidth;
+            dmxGlobalHeight = PanoramiXPixHeight;
+        }
+        dmxLog(dmxInfo, "%d screens configured with Xinerama (%d %d)\n",
+               PanoramiXNumScreens, PanoramiXPixWidth, PanoramiXPixHeight);
+	FOR_NSCREENS(i) found[i] = FALSE;
+    } else {
+#endif
+                                /* This never happens because we're
+                                 * either called from a Xinerama
+                                 * callback or during reconfiguration
+                                 * (which only works with Xinerama on).
+                                 * In any case, be reasonable. */
+        dmxLog(dmxInfo, "%d screens configured (%d %d)\n",
+               screenInfo.numScreens, root->pixWidth, root->pixHeight);
+#ifdef PANORAMIX
+    }
+#endif
+
+    for (i = 0; i < root->nDepths; i++) {
+        xDepth      *depth  = (xDepth *)(ConnectionInfo + offset);
+        int         voffset = offset + sizeof(xDepth);
+        xVisualType *visual = (xVisualType *)(ConnectionInfo + voffset);
+        int         j;
+        
+        dmxLog(dmxInfo, "%d visuals at depth %d:\n",
+               depth->nVisuals, depth->depth);
+        for (j = 0; j < depth->nVisuals; j++, visual++) {
+            XVisualInfo vi;
+            
+            vi.visual        = NULL;
+            vi.visualid      = visual->visualID;
+            vi.screen        = 0;
+            vi.depth         = depth->depth;
+            vi.class         = visual->class;
+            vi.red_mask      = visual->redMask;
+            vi.green_mask    = visual->greenMask;
+            vi.blue_mask     = visual->blueMask;
+            vi.colormap_size = visual->colormapEntries;
+            vi.bits_per_rgb  = visual->bitsPerRGB;
+            dmxLogVisual(NULL, &vi, 0);
+
+#ifdef PANORAMIX
+	    if (!noPanoramiXExtension) {
+		int  k;
+		FOR_NSCREENS(k) {
+		    DMXScreenInfo *dmxScreen = &dmxScreens[k];
+
+		    if (dmxScreen->beDisplay) {
+			XVisualInfo *pvi =
+			    &dmxScreen->beVisuals[dmxScreen->beDefVisualIndex];
+			if (pvi->depth == depth->depth &&
+			    pvi->class == visual->class)
+			    found[k] = TRUE;
+		    } else {
+			/* Screen #k is detatched, so it always succeeds */
+			found[k] = TRUE;
+		    }
+		}
+	    }
+#endif
+        }
+        offset = voffset + depth->nVisuals * sizeof(xVisualType);
+    }
+
+    dmxInputLogDevices();
+    dmxLog(dmxInfo, "===== End of Summary =====\n");
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+	Bool fatal = FALSE;
+	FOR_NSCREENS(i) {
+	    fatal |= !found[i];
+	    if (!found[i]) {
+		dmxLog(dmxError,
+		       "The default visual for screen #%d does not match "
+		       "any of the\n", i);
+		dmxLog(dmxError,
+		       "consolidated visuals from Xinerama (listed above)\n");
+	    }
+	}
+	if (fatal)
+            dmxLog(dmxFatal,
+                   "dmxConnectionBlockCallback: invalid screen(s) found");
+    }
+#endif
+    MAXSCREENSFREE(found);
+}
diff --git a/xorg-server/hw/dmx/dmxextension.c b/xorg-server/hw/dmx/dmxextension.c
index db5709ee6..00b95a96d 100644
--- a/xorg-server/hw/dmx/dmxextension.c
+++ b/xorg-server/hw/dmx/dmxextension.c
@@ -1,1620 +1,1620 @@
-/*
- * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Author:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * This file provides the only interface to the X server extension support
- * in programs/Xserver/Xext.  Those programs should only include dmxext.h
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include "dmx.h"
-#include "dmxinit.h"
-#include "dmxextension.h"
-#include "dmxwindow.h"
-#include "dmxcb.h"
-#include "dmxcursor.h"
-#include "dmxpixmap.h"
-#include "dmxgc.h"
-#include "dmxfont.h"
-#include "dmxcmap.h"
-#include "dmxpict.h"
-#include "dmxinput.h"
-#include "dmxsync.h"
-#include "dmxscrinit.h"
-#include "input/dmxinputinit.h"
-
-#include "windowstr.h"
-#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;
-    
-/** This routine provides information to the DMX protocol extension
- * about a particular screen. */
-Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)
-{
-    DMXScreenInfo *dmxScreen;
-
-    if (physical < 0 || physical >= dmxNumScreens) return FALSE;
-
-    dmxScreen = &dmxScreens[physical];
-    attr->displayName         = dmxScreen->name;
-#ifdef PANORAMIX
-    attr->logicalScreen       = noPanoramiXExtension ? dmxScreen->index : 0;
-#else
-    attr->logicalScreen       = dmxScreen->index;
-#endif
-
-    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->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)
-{
-    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
-
-    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;
-
-    if (!pWinPriv->window || pWinPriv->offscreen) {
-        attr->vis.x      = 0;
-        attr->vis.y      = 0;
-        attr->vis.height = 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;
-
-    if (attr->pos.x < 0) {
-        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;
-        else
-            attr->vis.width  = pWindow->drawable.pScreen->width - attr->pos.x;
-    }
-    if (attr->pos.y < 0) {
-        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) {
-        if (attr->pos.y < 0)
-            attr->vis.height = pWindow->drawable.pScreen->height;
-        else
-            attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y;
-    }
-
-                                /* Convert to window-relative coordinates */
-    attr->vis.x -= attr->pos.x;
-    attr->vis.y -= attr->pos.y;
-
-    return TRUE;
-}
-
-void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)
-{
-    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>. */
-}
-
-/** 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 i, total;
-    
-    for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs;
-    return total;
-}
-
-/** Return information about the device with id = \a deviceId.  This
- * information is primarily for the #ProcDMXGetInputAttributes()
- * function, which does not have access to the appropriate data
- * structure. */
-int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
-{
-    int          i, j;
-    DMXInputInfo *dmxInput;
-
-    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;
-            switch (dmxLocal->extType) {
-            case DMX_LOCAL_TYPE_LOCAL:
-                attr->inputType      = 0;
-                break;
-            case DMX_LOCAL_TYPE_CONSOLE:
-                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->physicalScreen = dmxInput->scrnIdx;
-                attr->name           = dmxInput->name;
-                attr->physicalId     = dmxLocal->deviceId;
-                break;
-            }
-            return 0;           /* Success */
-        }
-    }
-    return -1;                  /* Failure */
-}
-
-/** Reinitialized the cursor boundaries. */
-static void dmxAdjustCursorBoundaries(void)
-{
-    int           i;
-
-    dmxReInitOrigins();
-    dmxInitOverlap();
-    dmxComputeWidthHeight(DMX_NO_RECOMPUTE_BOUNDING_BOX);
-    dmxConnectionBlockCallback();
-    for (i = 0; i < dmxNumInputs; i++) {
-        DMXInputInfo *dmxInput = &dmxInputs[i];
-	if (!dmxInput->detached) dmxInputReInit(dmxInput);
-    }
-
-    dmxCheckCursor();
-
-    for (i = 0; i < dmxNumInputs; i++) {
-        DMXInputInfo *dmxInput = &dmxInputs[i];
-	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 retcode = BadValue;
-
-    if (attr->inputType == 1)   /* console */
-        retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);
-    else if (attr->inputType == 2)   /* backend */
-        retcode = dmxInputAttachBackend(attr->physicalScreen,
-                                        attr->sendsCore,id);
-
-    if (retcode == Success) {
-        /* Adjust the cursor boundaries */
-        dmxAdjustCursorBoundaries();
-
-        /* Force completion of the changes */
-        dmxSync(NULL, TRUE);
-    }
-
-    return retcode;
-}
-
-/** Remove the input with physical id \a id. */
-int dmxRemoveInput(int id)
-{
-    return dmxInputDetachId(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)
-{
-    return dmxNumScreens;
-}
-
-/** Make sure that #dmxCreateAndRealizeWindow has been called for \a
- * pWindow. */
-void dmxForceWindowCreation(WindowPtr pWindow)
-{
-    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
-    if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE);
-}
-
-/** Flush pending syncs for all screens. */
-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)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
-    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;
-    }
-
-    /* Change screen size */
-    pScreen->width  = w;
-    pScreen->height = h;
-
-    /* Reset the root window's drawable's size */
-    pRoot->drawable.width  = w;
-    pRoot->drawable.height = h;
-
-    /* Set the root window's new winSize and borderSize */
-    pRoot->winSize.extents.x1 = 0;
-    pRoot->winSize.extents.y1 = 0;
-    pRoot->winSize.extents.x2 = w;
-    pRoot->winSize.extents.y2 = h;
-
-    pRoot->borderSize.extents.x1 = 0;
-    pRoot->borderSize.extents.y1 = 0;
-    pRoot->borderSize.extents.x2 = w;
-    pRoot->borderSize.extents.y2 = h;
-
-    /* Recompute this screen's mmWidth & mmHeight */
-    pScreen->mmWidth =
-	(w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);
-    pScreen->mmHeight =
-	(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);
-
-    /*   2. Set the root window's borderClip */
-    pRoot->borderClip.extents.x1 = 0;
-    pRoot->borderClip.extents.y1 = 0;
-    pRoot->borderClip.extents.x2 = w;
-    pRoot->borderClip.extents.y2 = 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;
-    }
-
-    /*   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);
-    }
-}
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.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)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[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);
-    }
-
-    /* Change "screen" window values */
-    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)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    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);
-    }
-
-    /* 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);
-    }
-
-    /* Change "root" window values */
-    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)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    ScreenPtr      pScreen   = screenInfo.screens[idx];
-    WindowPtr      pRoot     = pScreen->root;
-    WindowPtr      pChild;
-    int            xoff;
-    int            yoff;
-
-    /* Change "root" window's origin */
-    dmxScreen->rootXOrigin = x;
-    dmxScreen->rootYOrigin = y;
-
-    /* Compute offsets here in case <x,y> has been changed above */
-    xoff = x - pScreen->x;
-    yoff = y - pScreen->y;
-
-    /* Adjust the root window's position */
-    pScreen->x = dmxScreen->rootXOrigin;
-    pScreen->y = dmxScreen->rootYOrigin;
-
-    /* Recalculate the Xinerama regions and data structs */
-    XineramaReinitData(pScreen);
-
-    /* Adjust each of the root window's children */
-    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;
-    }
-}
-
-/** Configure the attributes of each "screen" and "root" window. */
-int dmxConfigureScreenWindows(int nscreens,
-			      CARD32 *screens,
-			      DMXScreenAttributesPtr attribs,
-			      int *errorScreen)
-{
-    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 */
-    }
-
-    /* No illegal values found */
-    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);
-    }
-
-    /* Adjust the cursor boundaries */
-    dmxAdjustCursorBoundaries();
-
-    /* Force completion of the changes */
-    dmxSync(NULL, TRUE);
-
-    return Success;
-}
-
-/** Configure the attributes of the global desktop. */
-int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
-{
-    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);
-	    }
-	}
-    }
-
-    /* Set the global width/height */
-    dmxSetWidthHeight(attribs->width, attribs->height);
-
-    /* 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;
-	    }
-	}
-    }
-
-    /* Update connection block, Xinerama, etc. -- these appears to
-     * already be handled in dmxConnectionBlockCallback(), which is
-     * called from dmxAdjustCursorBoundaries() [below]. */
-
-    /* Adjust the cursor boundaries */
-    dmxAdjustCursorBoundaries();
-
-    /* Force completion of the changes */
-    dmxSync(NULL, TRUE);
-
-    return Success;
-}
-#endif
-
-/** Create the scratch GCs per depth. */
-static void dmxBECreateScratchGCs(int scrnNum)
-{
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
-
-    for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBECreateGC(pScreen, ppGC[i]);
-}
-
-#ifdef PANORAMIX
-static Bool FoundPixImage;
-
-/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs
- *  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)
-{
-    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;
-	    }
-	}
-    }
-}
-#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)
-{
-#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) {
-	dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-	return;
-    }
-
-    FoundPixImage = False;
-    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");
-	}
-    }
-#else
-    /* If Xinerama is not enabled, then there is no other copy of the
-     * pixmap image that we can restore.  Saving all pixmap data is not
-     * a feasible option since there is no mechanism for updating pixmap
-     * data when a screen is detached, which means that the data that
-     * was previously saved would most likely be out of date. */
-    dmxLog(dmxWarning, "Cannot restore pixmap image\n");
-    return;
-#endif
-}
-
-/** Create resources on the back-end server.  This function is called
- *  from #dmxAttachScreen() via the dix layer's FindAllResources
- *  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)
-{
-    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);
-#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);
-#endif
-    } else {
-	/* Other resource types??? */
-    }
-}
-
-/** Create window hierachy on back-end server.  The window tree is
- *  created in a special order (bottom most subwindow first) so that the
- *  #dmxCreateNonRootWindow() function does not need to recursively call
- *  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)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    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);
-    }
-    if (pRoot->backgroundState == BackgroundPixmap) {
-	dmxBECreatePixmap(pRoot->background.pixmap);
-	dmxBERestorePixmap(pRoot->background.pixmap);
-    }
-
-    /* Create root window first */
-    dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot);
-    XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin);
-
-    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;
-    }
-}
-
-/* Refresh screen by generating exposure events for all windows */
-static void dmxForceExposures(int idx)
-{
-    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);
-    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);
-    }
-}
-
-/** Compare the new and old screens to see if they are compatible. */
-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;
-    for (i = 0; i < old->beNumDepths; i++)
-	if (new->beDepths[i] != old->beDepths[i]) 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->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;
-
-    return TRUE;
-}
-
-/** Restore Render's picture */
-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;
-
-    if (pDraw->pScreen->myNum != scrnNum) {
-	/* 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);
-    }
-
-    dmxBECreatePicture(pPicture);
-}
-
-/** Restore Render's glyphs */
-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;
-
-    if (glyphPriv->glyphSets[scrnNum]) {
-	/* 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;
-    }
-
-    /* Now for the complex part, restore the glyph data */
-    table = glyphSet->hash.table;
-
-    /* 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;
-
-	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));
-
-    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++;
-    }
-    
-    /* Now restore the glyph data */
-    XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],
-		     gids,glyphs, glyphSet->hash.tableEntries, images,
-		     len_images);
-
-    /* Clean up */
-    free(images);
-    free(gids);
-    free(glyphs);    
-}
-
-/** Reattach previously detached back-end screen. */
-int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
-{
-    ScreenPtr      pScreen;
-    DMXScreenInfo *dmxScreen;
-    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;
-    }
-
-    /* Cannot add a screen that does not exist */
-    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;
-    }
-
-    dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);
-
-    /* Save old info */
-    oldDMXScreen = *dmxScreen;
-
-    /* Copy the name to the new screen */
-    dmxScreen->name = strdup(attr->displayName);
-
-    /* Open display and get all of the screen info */
-    if (!dmxOpenDisplay(dmxScreen)) {
-	dmxLog(dmxWarning,
-               "dmxOpenDisplay: Unable to open display %s\n",
-               dmxScreen->name);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
-    }
-
-    dmxSetErrorHandler(dmxScreen);
-    dmxCheckForWM(dmxScreen);
-    dmxGetScreenAttribs(dmxScreen);
-
-    if (!dmxGetVisualInfo(dmxScreen)) {
-	dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
-	XFree(dmxScreen->beVisuals);
-	XCloseDisplay(dmxScreen->beDisplay);
-
-	/* Restore the old screen */
-	*dmxScreen = oldDMXScreen;
-	return 1;
-    }
-
-    dmxGetColormaps(dmxScreen);
-    dmxGetPixmapFormats(dmxScreen);
-
-    /* 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;
-    }
-
-    /* Initialize the BE screen resources */
-    dmxBEScreenInit(idx, screenInfo.screens[idx]);
-
-    /* TODO: Handle GLX visual initialization.  GLXProxy needs to be
-     * updated to handle dynamic addition/removal of screens. */
-
-    /* Create default stipple */
-    dmxBECreatePixmap(pScreen->PixmapPerDepth[0]);
-    dmxBERestorePixmap(pScreen->PixmapPerDepth[0]);
-
-    /* Create the scratch GCs */
-    dmxBECreateScratchGCs(idx);
-
-    /* Create the default font */
-    (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);
-
-    /* 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);
-
-    /* Restore the glyph state for RENDER */
-    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);
-
-    dmxSync(&dmxScreens[idx], TRUE);
-
-    /* We used these to compare the old and new screens.  They are no
-     * longer needed since we have a newly attached screen, so we can
-     * now free the old screen's resources. */
-    XFree(oldDMXScreen.beVisuals);
-    XFree(oldDMXScreen.beDepths);
-    XFree(oldDMXScreen.bePixmapFormats);
-    /* TODO: should oldDMXScreen.name be freed?? */
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension)
-	return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
-    else
-#endif
-	return 0; /* Success */
-}
-
-/*
- * Resources that may have state on the BE server and need to be freed:
- *
- * RT_NONE
- * RT_WINDOW
- * RT_PIXMAP
- * RT_GC
- * RT_FONT
- * RT_CURSOR
- * RT_COLORMAP
- * RT_CMAPENTRY
- * RT_OTHERCLIENT
- * RT_PASSIVEGRAB
- * XRT_WINDOW
- * XRT_PIXMAP
- * XRT_GC
- * XRT_COLORMAP
- * XRT_PICTURE
- * PictureType
- * PictFormatType
- * GlyphSetType
- * ClientType
- * EventType
- * RT_INPUTCLIENT
- * XETrapType
- * RTCounter
- * RTAwait
- * RTAlarmClient
- * RT_XKBCLIENT
- * RTContext
- * TagResType
- * StalledResType
- * SecurityAuthorizationResType
- * RTEventClient
- * __glXContextRes
- * __glXClientRes
- * __glXPixmapRes
- * __glXWindowRes
- * __glXPbufferRes
- */
-
-#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)
-{
-    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;
-	    }
-	}
-    }
-}
-#endif
-
-/** Save the pixmap image only when there is not another screen with
- *  that pixmap from which the image can be read when the screen is
- *  reattached.  To do this, we first try to find a pixmap on another
- *  screen corresponding to the one we are trying to save.  If we find
- *  one, then we do not need to save the image data since during
- *  reattachment, the image data can be read from that other pixmap.
- *  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)
-{
-#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;
-
-    FoundPixImage = False;
-    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");
-	}
-    }
-#else
-    /* NOTE: The only time there is a pixmap on another screen that
-     * corresponds to the one we are trying to save is when Xinerama is
-     * active.  Otherwise, the pixmap image data is only stored on a
-     * single screen, which means that once it is detached, that data is
-     * lost.  We could save the data here, but then that would require
-     * us to implement the ability for Xdmx to keep the pixmap up to
-     * date while the screen is detached, which is beyond the scope of
-     * the current project. */
-    return;
-#endif
-}
-
-/** Destroy resources on the back-end server.  This function is called
- *  from #dmxDetachScreen() via the dix layer's FindAllResources
- *  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)
-{
-    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??? */
-    }
-}
-
-/** Destroy the scratch GCs that are created per depth. */
-static void dmxBEDestroyScratchGCs(int scrnNum)
-{
-    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
-    GCPtr     *ppGC    = pScreen->GCperDepth;
-    int        i;
-
-    for (i = 0; i <= pScreen->numDepths; i++)
-	dmxBEFreeGC(ppGC[i]);
-}
-
-/** Destroy window hierachy on back-end server.  To ensure that all
- *  XDestroyWindow() calls succeed, they must be performed in a bottom
- *  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)
-{
-    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;
-    }
-}
-
-/** Detach back-end screen. */
-int dmxDetachScreen(int idx)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
-    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;
-    }
-
-    /* Cannot remove a screen that does not exist */
-    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;
-    }
-
-    dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);
-
-    /* Detach input */
-    dmxInputDetachAll(dmxScreen);
-
-    /* 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);
-
-    /* Free scratch GCs */
-    dmxBEDestroyScratchGCs(idx);
-
-    /* Free window resources related to this screen */
-    dmxBEDestroyWindowTree(idx);
-
-    /* Free default stipple */
-    dmxBESavePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
-    dmxBEFreePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
-
-    /* Free the remaining screen resources and close the screen */
-    dmxBECloseScreen(screenInfo.screens[idx]);
-
-    /* Adjust the cursor boundaries (paints detached console window) */
-    dmxAdjustCursorBoundaries();
-
-    return 0; /* Success */
-}
+/*
+ * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Author:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *   Kevin E. Martin <kem@redhat.com>
+ *
+ */
+
+/** \file
+ * This file provides the only interface to the X server extension support
+ * in programs/Xserver/Xext.  Those programs should only include dmxext.h
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include <stdlib.h>
+
+#include "dmx.h"
+#include "dmxinit.h"
+#include "dmxextension.h"
+#include "dmxwindow.h"
+#include "dmxcb.h"
+#include "dmxcursor.h"
+#include "dmxpixmap.h"
+#include "dmxgc.h"
+#include "dmxfont.h"
+#include "dmxcmap.h"
+#include "dmxpict.h"
+#include "dmxinput.h"
+#include "dmxsync.h"
+#include "dmxscrinit.h"
+#include "input/dmxinputinit.h"
+
+#include "windowstr.h"
+#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;
+    
+/** This routine provides information to the DMX protocol extension
+ * about a particular screen. */
+Bool dmxGetScreenAttributes(int physical, DMXScreenAttributesPtr attr)
+{
+    DMXScreenInfo *dmxScreen;
+
+    if (physical < 0 || physical >= dmxNumScreens) return FALSE;
+
+    dmxScreen = &dmxScreens[physical];
+    attr->displayName         = dmxScreen->name;
+#ifdef PANORAMIX
+    attr->logicalScreen       = noPanoramiXExtension ? dmxScreen->index : 0;
+#else
+    attr->logicalScreen       = dmxScreen->index;
+#endif
+
+    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->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)
+{
+    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
+
+    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;
+
+    if (!pWinPriv->window || pWinPriv->offscreen) {
+        attr->vis.x      = 0;
+        attr->vis.y      = 0;
+        attr->vis.height = 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;
+
+    if (attr->pos.x < 0) {
+        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;
+        else
+            attr->vis.width  = pWindow->drawable.pScreen->width - attr->pos.x;
+    }
+    if (attr->pos.y < 0) {
+        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) {
+        if (attr->pos.y < 0)
+            attr->vis.height = pWindow->drawable.pScreen->height;
+        else
+            attr->vis.height = pWindow->drawable.pScreen->height - attr->pos.y;
+    }
+
+                                /* Convert to window-relative coordinates */
+    attr->vis.x -= attr->pos.x;
+    attr->vis.y -= attr->pos.y;
+
+    return TRUE;
+}
+
+void dmxGetDesktopAttributes(DMXDesktopAttributesPtr attr)
+{
+    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>. */
+}
+
+/** 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 i, total;
+    
+    for (total = i = 0; i < dmxNumInputs; i++) total += dmxInputs[i].numDevs;
+    return total;
+}
+
+/** Return information about the device with id = \a deviceId.  This
+ * information is primarily for the #ProcDMXGetInputAttributes()
+ * function, which does not have access to the appropriate data
+ * structure. */
+int dmxGetInputAttributes(int deviceId, DMXInputAttributesPtr attr)
+{
+    int          i, j;
+    DMXInputInfo *dmxInput;
+
+    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;
+            switch (dmxLocal->extType) {
+            case DMX_LOCAL_TYPE_LOCAL:
+                attr->inputType      = 0;
+                break;
+            case DMX_LOCAL_TYPE_CONSOLE:
+                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->physicalScreen = dmxInput->scrnIdx;
+                attr->name           = dmxInput->name;
+                attr->physicalId     = dmxLocal->deviceId;
+                break;
+            }
+            return 0;           /* Success */
+        }
+    }
+    return -1;                  /* Failure */
+}
+
+/** Reinitialized the cursor boundaries. */
+static void dmxAdjustCursorBoundaries(void)
+{
+    int           i;
+
+    dmxReInitOrigins();
+    dmxInitOverlap();
+    dmxComputeWidthHeight(DMX_NO_RECOMPUTE_BOUNDING_BOX);
+    dmxConnectionBlockCallback();
+    for (i = 0; i < dmxNumInputs; i++) {
+        DMXInputInfo *dmxInput = &dmxInputs[i];
+	if (!dmxInput->detached) dmxInputReInit(dmxInput);
+    }
+
+    dmxCheckCursor();
+
+    for (i = 0; i < dmxNumInputs; i++) {
+        DMXInputInfo *dmxInput = &dmxInputs[i];
+	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 retcode = BadValue;
+
+    if (attr->inputType == 1)   /* console */
+        retcode = dmxInputAttachConsole(attr->name, attr->sendsCore, id);
+    else if (attr->inputType == 2)   /* backend */
+        retcode = dmxInputAttachBackend(attr->physicalScreen,
+                                        attr->sendsCore,id);
+
+    if (retcode == Success) {
+        /* Adjust the cursor boundaries */
+        dmxAdjustCursorBoundaries();
+
+        /* Force completion of the changes */
+        dmxSync(NULL, TRUE);
+    }
+
+    return retcode;
+}
+
+/** Remove the input with physical id \a id. */
+int dmxRemoveInput(int id)
+{
+    return dmxInputDetachId(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)
+{
+    return dmxNumScreens;
+}
+
+/** Make sure that #dmxCreateAndRealizeWindow has been called for \a
+ * pWindow. */
+void dmxForceWindowCreation(WindowPtr pWindow)
+{
+    dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV(pWindow);
+    if (!pWinPriv->window) dmxCreateAndRealizeWindow(pWindow, TRUE);
+}
+
+/** Flush pending syncs for all screens. */
+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)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
+    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;
+    }
+
+    /* Change screen size */
+    pScreen->width  = w;
+    pScreen->height = h;
+
+    /* Reset the root window's drawable's size */
+    pRoot->drawable.width  = w;
+    pRoot->drawable.height = h;
+
+    /* Set the root window's new winSize and borderSize */
+    pRoot->winSize.extents.x1 = 0;
+    pRoot->winSize.extents.y1 = 0;
+    pRoot->winSize.extents.x2 = w;
+    pRoot->winSize.extents.y2 = h;
+
+    pRoot->borderSize.extents.x1 = 0;
+    pRoot->borderSize.extents.y1 = 0;
+    pRoot->borderSize.extents.x2 = w;
+    pRoot->borderSize.extents.y2 = h;
+
+    /* Recompute this screen's mmWidth & mmHeight */
+    pScreen->mmWidth =
+	(w * 254 + dmxScreen->beXDPI * 5) / (dmxScreen->beXDPI * 10);
+    pScreen->mmHeight =
+	(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);
+
+    /*   2. Set the root window's borderClip */
+    pRoot->borderClip.extents.x1 = 0;
+    pRoot->borderClip.extents.y1 = 0;
+    pRoot->borderClip.extents.x2 = w;
+    pRoot->borderClip.extents.y2 = 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;
+    }
+
+    /*   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);
+    }
+}
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.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)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[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);
+    }
+
+    /* Change "screen" window values */
+    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)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+    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);
+    }
+
+    /* 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);
+    }
+
+    /* Change "root" window values */
+    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)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+    ScreenPtr      pScreen   = screenInfo.screens[idx];
+    WindowPtr      pRoot     = pScreen->root;
+    WindowPtr      pChild;
+    int            xoff;
+    int            yoff;
+
+    /* Change "root" window's origin */
+    dmxScreen->rootXOrigin = x;
+    dmxScreen->rootYOrigin = y;
+
+    /* Compute offsets here in case <x,y> has been changed above */
+    xoff = x - pScreen->x;
+    yoff = y - pScreen->y;
+
+    /* Adjust the root window's position */
+    pScreen->x = dmxScreen->rootXOrigin;
+    pScreen->y = dmxScreen->rootYOrigin;
+
+    /* Recalculate the Xinerama regions and data structs */
+    XineramaReinitData(pScreen);
+
+    /* Adjust each of the root window's children */
+    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;
+    }
+}
+
+/** Configure the attributes of each "screen" and "root" window. */
+int dmxConfigureScreenWindows(int nscreens,
+			      CARD32 *screens,
+			      DMXScreenAttributesPtr attribs,
+			      int *errorScreen)
+{
+    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 */
+    }
+
+    /* No illegal values found */
+    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);
+    }
+
+    /* Adjust the cursor boundaries */
+    dmxAdjustCursorBoundaries();
+
+    /* Force completion of the changes */
+    dmxSync(NULL, TRUE);
+
+    return Success;
+}
+
+/** Configure the attributes of the global desktop. */
+int dmxConfigureDesktop(DMXDesktopAttributesPtr attribs)
+{
+    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);
+	    }
+	}
+    }
+
+    /* Set the global width/height */
+    dmxSetWidthHeight(attribs->width, attribs->height);
+
+    /* 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;
+	    }
+	}
+    }
+
+    /* Update connection block, Xinerama, etc. -- these appears to
+     * already be handled in dmxConnectionBlockCallback(), which is
+     * called from dmxAdjustCursorBoundaries() [below]. */
+
+    /* Adjust the cursor boundaries */
+    dmxAdjustCursorBoundaries();
+
+    /* Force completion of the changes */
+    dmxSync(NULL, TRUE);
+
+    return Success;
+}
+#endif
+
+/** Create the scratch GCs per depth. */
+static void dmxBECreateScratchGCs(int scrnNum)
+{
+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
+    GCPtr     *ppGC    = pScreen->GCperDepth;
+    int        i;
+
+    for (i = 0; i <= pScreen->numDepths; i++)
+	dmxBECreateGC(pScreen, ppGC[i]);
+}
+
+#ifdef PANORAMIX
+static Bool FoundPixImage;
+
+/** Search the Xinerama XRT_PIXMAP resources for the pixmap that needs
+ *  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)
+{
+    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;
+	    }
+	}
+    }
+}
+#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)
+{
+#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) {
+	dmxLog(dmxWarning, "Cannot restore pixmap image\n");
+	return;
+    }
+
+    FoundPixImage = False;
+    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");
+	}
+    }
+#else
+    /* If Xinerama is not enabled, then there is no other copy of the
+     * pixmap image that we can restore.  Saving all pixmap data is not
+     * a feasible option since there is no mechanism for updating pixmap
+     * data when a screen is detached, which means that the data that
+     * was previously saved would most likely be out of date. */
+    dmxLog(dmxWarning, "Cannot restore pixmap image\n");
+    return;
+#endif
+}
+
+/** Create resources on the back-end server.  This function is called
+ *  from #dmxAttachScreen() via the dix layer's FindAllResources
+ *  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)
+{
+    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);
+#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);
+#endif
+    } else {
+	/* Other resource types??? */
+    }
+}
+
+/** Create window hierachy on back-end server.  The window tree is
+ *  created in a special order (bottom most subwindow first) so that the
+ *  #dmxCreateNonRootWindow() function does not need to recursively call
+ *  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)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+    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);
+    }
+    if (pRoot->backgroundState == BackgroundPixmap) {
+	dmxBECreatePixmap(pRoot->background.pixmap);
+	dmxBERestorePixmap(pRoot->background.pixmap);
+    }
+
+    /* Create root window first */
+    dmxScreen->rootWin = pWinPriv->window = dmxCreateRootWindow(pRoot);
+    XMapWindow(dmxScreen->beDisplay, dmxScreen->rootWin);
+
+    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;
+    }
+}
+
+/* Refresh screen by generating exposure events for all windows */
+static void dmxForceExposures(int idx)
+{
+    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);
+    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);
+    }
+}
+
+/** Compare the new and old screens to see if they are compatible. */
+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;
+    for (i = 0; i < old->beNumDepths; i++)
+	if (new->beDepths[i] != old->beDepths[i]) 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->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;
+
+    return TRUE;
+}
+
+/** Restore Render's picture */
+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;
+
+    if (pDraw->pScreen->myNum != scrnNum) {
+	/* 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);
+    }
+
+    dmxBECreatePicture(pPicture);
+}
+
+/** Restore Render's glyphs */
+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;
+
+    if (glyphPriv->glyphSets[scrnNum]) {
+	/* 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;
+    }
+
+    /* Now for the complex part, restore the glyph data */
+    table = glyphSet->hash.table;
+
+    /* 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;
+
+	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));
+
+    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++;
+    }
+    
+    /* Now restore the glyph data */
+    XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[scrnNum],
+		     gids,glyphs, glyphSet->hash.tableEntries, images,
+		     len_images);
+
+    /* Clean up */
+    free(images);
+    free(gids);
+    free(glyphs);    
+}
+
+/** Reattach previously detached back-end screen. */
+int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
+{
+    ScreenPtr      pScreen;
+    DMXScreenInfo *dmxScreen;
+    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;
+    }
+
+    /* Cannot add a screen that does not exist */
+    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;
+    }
+
+    dmxLogOutput(dmxScreen, "Attaching screen #%d\n", idx);
+
+    /* Save old info */
+    oldDMXScreen = *dmxScreen;
+
+    /* Copy the name to the new screen */
+    dmxScreen->name = strdup(attr->displayName);
+
+    /* Open display and get all of the screen info */
+    if (!dmxOpenDisplay(dmxScreen)) {
+	dmxLog(dmxWarning,
+               "dmxOpenDisplay: Unable to open display %s\n",
+               dmxScreen->name);
+
+	/* Restore the old screen */
+	*dmxScreen = oldDMXScreen;
+	return 1;
+    }
+
+    dmxSetErrorHandler(dmxScreen);
+    dmxCheckForWM(dmxScreen);
+    dmxGetScreenAttribs(dmxScreen);
+
+    if (!dmxGetVisualInfo(dmxScreen)) {
+	dmxLog(dmxWarning, "dmxGetVisualInfo: No matching visuals found\n");
+	XFree(dmxScreen->beVisuals);
+	XCloseDisplay(dmxScreen->beDisplay);
+
+	/* Restore the old screen */
+	*dmxScreen = oldDMXScreen;
+	return 1;
+    }
+
+    dmxGetColormaps(dmxScreen);
+    dmxGetPixmapFormats(dmxScreen);
+
+    /* 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;
+    }
+
+    /* Initialize the BE screen resources */
+    dmxBEScreenInit(idx, screenInfo.screens[idx]);
+
+    /* TODO: Handle GLX visual initialization.  GLXProxy needs to be
+     * updated to handle dynamic addition/removal of screens. */
+
+    /* Create default stipple */
+    dmxBECreatePixmap(pScreen->PixmapPerDepth[0]);
+    dmxBERestorePixmap(pScreen->PixmapPerDepth[0]);
+
+    /* Create the scratch GCs */
+    dmxBECreateScratchGCs(idx);
+
+    /* Create the default font */
+    (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);
+
+    /* 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);
+
+    /* Restore the glyph state for RENDER */
+    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);
+
+    dmxSync(&dmxScreens[idx], TRUE);
+
+    /* We used these to compare the old and new screens.  They are no
+     * longer needed since we have a newly attached screen, so we can
+     * now free the old screen's resources. */
+    XFree(oldDMXScreen.beVisuals);
+    XFree(oldDMXScreen.beDepths);
+    XFree(oldDMXScreen.bePixmapFormats);
+    /* TODO: should oldDMXScreen.name be freed?? */
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension)
+	return dmxConfigureScreenWindows(1, &scrnNum, attr, NULL);
+    else
+#endif
+	return 0; /* Success */
+}
+
+/*
+ * Resources that may have state on the BE server and need to be freed:
+ *
+ * RT_NONE
+ * RT_WINDOW
+ * RT_PIXMAP
+ * RT_GC
+ * RT_FONT
+ * RT_CURSOR
+ * RT_COLORMAP
+ * RT_CMAPENTRY
+ * RT_OTHERCLIENT
+ * RT_PASSIVEGRAB
+ * XRT_WINDOW
+ * XRT_PIXMAP
+ * XRT_GC
+ * XRT_COLORMAP
+ * XRT_PICTURE
+ * PictureType
+ * PictFormatType
+ * GlyphSetType
+ * ClientType
+ * EventType
+ * RT_INPUTCLIENT
+ * XETrapType
+ * RTCounter
+ * RTAwait
+ * RTAlarmClient
+ * RT_XKBCLIENT
+ * RTContext
+ * TagResType
+ * StalledResType
+ * SecurityAuthorizationResType
+ * RTEventClient
+ * __glXContextRes
+ * __glXClientRes
+ * __glXPixmapRes
+ * __glXWindowRes
+ * __glXPbufferRes
+ */
+
+#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)
+{
+    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;
+	    }
+	}
+    }
+}
+#endif
+
+/** Save the pixmap image only when there is not another screen with
+ *  that pixmap from which the image can be read when the screen is
+ *  reattached.  To do this, we first try to find a pixmap on another
+ *  screen corresponding to the one we are trying to save.  If we find
+ *  one, then we do not need to save the image data since during
+ *  reattachment, the image data can be read from that other pixmap.
+ *  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)
+{
+#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;
+
+    FoundPixImage = False;
+    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");
+	}
+    }
+#else
+    /* NOTE: The only time there is a pixmap on another screen that
+     * corresponds to the one we are trying to save is when Xinerama is
+     * active.  Otherwise, the pixmap image data is only stored on a
+     * single screen, which means that once it is detached, that data is
+     * lost.  We could save the data here, but then that would require
+     * us to implement the ability for Xdmx to keep the pixmap up to
+     * date while the screen is detached, which is beyond the scope of
+     * the current project. */
+    return;
+#endif
+}
+
+/** Destroy resources on the back-end server.  This function is called
+ *  from #dmxDetachScreen() via the dix layer's FindAllResources
+ *  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)
+{
+    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??? */
+    }
+}
+
+/** Destroy the scratch GCs that are created per depth. */
+static void dmxBEDestroyScratchGCs(int scrnNum)
+{
+    ScreenPtr  pScreen = screenInfo.screens[scrnNum];
+    GCPtr     *ppGC    = pScreen->GCperDepth;
+    int        i;
+
+    for (i = 0; i <= pScreen->numDepths; i++)
+	dmxBEFreeGC(ppGC[i]);
+}
+
+/** Destroy window hierachy on back-end server.  To ensure that all
+ *  XDestroyWindow() calls succeed, they must be performed in a bottom
+ *  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)
+{
+    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;
+    }
+}
+
+/** Detach back-end screen. */
+int dmxDetachScreen(int idx)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[idx];
+    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;
+    }
+
+    /* Cannot remove a screen that does not exist */
+    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;
+    }
+
+    dmxLogOutput(dmxScreen, "Detaching screen #%d\n", idx);
+
+    /* Detach input */
+    dmxInputDetachAll(dmxScreen);
+
+    /* 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);
+
+    /* Free scratch GCs */
+    dmxBEDestroyScratchGCs(idx);
+
+    /* Free window resources related to this screen */
+    dmxBEDestroyWindowTree(idx);
+
+    /* Free default stipple */
+    dmxBESavePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
+    dmxBEFreePixmap(screenInfo.screens[idx]->PixmapPerDepth[0]);
+
+    /* Free the remaining screen resources and close the screen */
+    dmxBECloseScreen(screenInfo.screens[idx]);
+
+    /* Adjust the cursor boundaries (paints detached console window) */
+    dmxAdjustCursorBoundaries();
+
+    return 0; /* Success */
+}
diff --git a/xorg-server/hw/dmx/dmxgcops.c b/xorg-server/hw/dmx/dmxgcops.c
index 500e2cdf1..07165f731 100644
--- a/xorg-server/hw/dmx/dmxgcops.c
+++ b/xorg-server/hw/dmx/dmxgcops.c
@@ -1,605 +1,605 @@
-/*
- * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kem@redhat.com>
- *
- */
-
-/** \file
- * This file provides support for GC operations. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxsync.h"
-#include "dmxgc.h"
-#include "dmxgcops.h"
-#include "dmxwindow.h"
-#include "dmxpixmap.h"
-
-#include "mi.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "dixfontstr.h"
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-#endif
-
-#define DMX_GCOPS_SET_DRAWABLE(_pDraw, _draw)				\
-do {									\
-    if ((_pDraw)->type == DRAWABLE_WINDOW) {				\
-	dmxWinPrivPtr  pWinPriv =					\
-	    DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw));			\
-	(_draw) = (Drawable)pWinPriv->window;				\
-    } else {								\
-	dmxPixPrivPtr  pPixPriv =					\
-	    DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw));			\
-	(_draw) = (Drawable)pPixPriv->pixmap;				\
-    }									\
-} while (0)
-
-#define DMX_GCOPS_OFFSCREEN(_pDraw)					\
-    (!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay ||			\
-     (dmxOffScreenOpt &&						\
-      (_pDraw)->type == DRAWABLE_WINDOW &&				\
-      (DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen ||		\
-       !DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))
-
-/** Fill spans -- this function should never be called. */
-void dmxFillSpans(DrawablePtr pDrawable, GCPtr pGC,
-		  int nInit, DDXPointPtr pptInit, int *pwidthInit,
-		  int fSorted)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Set spans -- this function should never be called. */
-void dmxSetSpans(DrawablePtr pDrawable, GCPtr pGC,
-		 char *psrc, DDXPointPtr ppt, int *pwidth, int nspans,
-		 int fSorted)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Transfer \a pBits image to back-end server associated with \a
- *  pDrawable's screen.  If primitive subdivision optimization is
- *  enabled, then only transfer the sections of \a pBits that are
- *  visible (i.e., not-clipped) to the back-end server. */
-void dmxPutImage(DrawablePtr pDrawable, GCPtr pGC,
-		 int depth, int x, int y, int w, int h,
-		 int leftPad, int format, char *pBits)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    XImage        *img;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    img = XCreateImage(dmxScreen->beDisplay,
-		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
-		       depth, format, leftPad, pBits, w, h,
-		       BitmapPad(dmxScreen->beDisplay),
-		       (format == ZPixmap) ?
-		       PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));
-
-    if (img) {
-	Drawable draw;
-
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	if (dmxSubdividePrimitives && pGC->pCompositeClip) {
-	    RegionPtr  pSubImages;
-	    RegionPtr  pClip;
-	    BoxRec     box;
-	    BoxPtr     pBox;
-	    int        nBox;
-
-	    box.x1 = x;
-	    box.y1 = y;
-	    box.x2 = x + w;
-	    box.y2 = y + h;
-	    pSubImages = RegionCreate(&box, 1);
-
-	    pClip = RegionCreate(NullBox, 1);
-	    RegionCopy(pClip, pGC->pCompositeClip);
-	    RegionTranslate(pClip,
-			     -pDrawable->x, -pDrawable->y);
-	    RegionIntersect(pSubImages, pSubImages, pClip);
-
-	    nBox = RegionNumRects(pSubImages);
-	    pBox = RegionRects(pSubImages);
-
-	    while (nBox--) {
-		XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc, img,
-			  pBox->x1 - box.x1,
-			  pBox->y1 - box.y1,
-			  pBox->x1,
-			  pBox->y1,
-			  pBox->x2 - pBox->x1,
-			  pBox->y2 - pBox->y1);
-		pBox++;
-	    }
-            RegionDestroy(pClip);
-            RegionDestroy(pSubImages);
-	} else {
-	    XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		      img, 0, 0, x, y, w, h);
-	}
-	XFree(img);             /* Use XFree instead of XDestroyImage
-                                 * because pBits is passed in from the
-                                 * caller. */
-
-	dmxSync(dmxScreen, FALSE);
-    } else {
-	/* Error -- this should not happen! */
-    }
-}
-
-/** Copy area from \a pSrc drawable to \a pDst drawable on the back-end
- *  server associated with \a pSrc drawable's screen.  If the offscreen
- *  optimization is enabled, only copy when both \a pSrc and \a pDst are
- *  at least partially visible. */
-RegionPtr dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		      int srcx, int srcy, int w, int h, int dstx, int dsty)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       srcDraw, dstDraw;
-
-    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
-	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
-				 dstx, dsty, 0L);
-
-    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
-    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
-
-    XCopyArea(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
-	      srcx, srcy, w, h, dstx, dsty);
-    dmxSync(dmxScreen, FALSE);
-
-    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
-			     dstx, dsty, 0L);
-}
-
-/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
- *  drawable on the back-end server associated with \a pSrc drawable's
- *  screen.  If the offscreen optimization is enabled, only copy when
- *  both \a pSrc and \a pDst are at least partially visible. */
-RegionPtr dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		       int srcx, int srcy, int width, int height,
-		       int dstx, int dsty, unsigned long bitPlane)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       srcDraw, dstDraw;
-
-    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
-	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-				 dstx, dsty, bitPlane);
-
-    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
-    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
-
-    XCopyPlane(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
-	       srcx, srcy, width, height, dstx, dsty, bitPlane);
-    dmxSync(dmxScreen, FALSE);
-
-    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
-			     dstx, dsty, bitPlane);
-}
-
-/** Render list of points, \a pptInit in \a pDrawable on the back-end
- *  server associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxPolyPoint(DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr pptInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawPoints(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		(XPoint *)pptInit, npt, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of connected lines, \a pptInit in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolylines(DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr pptInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawLines(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	       (XPoint *)pptInit, npt, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of disjoint segments, \a pSegs in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolySegment(DrawablePtr pDrawable, GCPtr pGC,
-		    int nseg, xSegment *pSegs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawSegments(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		  (XSegment *)pSegs, nseg);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of rectangle outlines, \a pRects in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyRectangle(DrawablePtr pDrawable, GCPtr pGC,
-		      int nrects, xRectangle *pRects)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    (XRectangle *)pRects, nrects);
-
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of arc outlines, \a parcs in \a pDrawable on the
- *  back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyArc(DrawablePtr pDrawable, GCPtr pGC,
-		int narcs, xArc *parcs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	      (XArc *)parcs, narcs);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render a filled polygons in \a pDrawable on the back-end server
- *  associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
-		    int shape, int mode, int count, DDXPointPtr pPts)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillPolygon(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		 (XPoint *)pPts, count, shape, mode);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of filled rectangles, \a prectInit in \a pDrawable on
- *  the back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-void dmxPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
-		     int nrectFill, xRectangle *prectInit)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    (XRectangle *)prectInit, nrectFill);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render list of filled arcs, \a parcs in \a pDrawable on the back-end
- *  server associated with \a pDrawable's screen.  If the offscreen
- *  optimization is enabled, only draw when \a pDrawable is at least
- *  partially visible. */
-void dmxPolyFillArc(DrawablePtr pDrawable, GCPtr pGC,
-		    int narcs, xArc *parcs)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XFillArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
-	      (XArc *)parcs, narcs);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render string of 8-bit \a chars (foreground only) in \a pDrawable on
- *  the back-end server associated with \a pDrawable's screen.  If the
- *  offscreen optimization is enabled, only draw when \a pDrawable is at
- *  least partially visible. */
-int dmxPolyText8(DrawablePtr pDrawable, GCPtr pGC,
-		 int x, int y, int count, char *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    unsigned long  n, i;
-    int            w;
-    CharInfoPtr    charinfo[255];
-    Drawable       draw;
-
-    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
-	      Linear8Bit, &n, charinfo);
-
-    /* Calculate text width */
-    w = 0;
-    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
-
-    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	XDrawString(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		    x, y, chars, count);
-	dmxSync(dmxScreen, FALSE);
-    }
-
-    return x+w;
-}
-
-/** Render string of 16-bit \a chars (foreground only) in \a pDrawable
- *  on the back-end server associated with \a pDrawable's screen.  If
- *  the offscreen optimization is enabled, only draw when \a pDrawable
- *  is at least partially visible. */
-int dmxPolyText16(DrawablePtr pDrawable, GCPtr pGC,
-		  int x, int y, int count, unsigned short *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    unsigned long  n, i;
-    int            w;
-    CharInfoPtr    charinfo[255];
-    Drawable       draw;
-
-    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
-	      (FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,
-	      &n, charinfo);
-
-    /* Calculate text width */
-    w = 0;
-    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
-
-    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-	XDrawString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		      x, y, (XChar2b *)chars, count);
-	dmxSync(dmxScreen, FALSE);
-    }
-
-    return x+w;
-}
-
-/** Render string of 8-bit \a chars (both foreground and background) in
- *  \a pDrawable on the back-end server associated with \a pDrawable's
- *  screen.  If the offscreen optimization is enabled, only draw when \a
- *  pDrawable is at least partially visible. */
-void dmxImageText8(DrawablePtr pDrawable, GCPtr pGC,
-		   int x, int y, int count, char *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawImageString(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		     x, y, chars, count);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Render string of 16-bit \a chars (both foreground and background) in
- *  \a pDrawable on the back-end server associated with \a pDrawable's
- *  screen.  If the offscreen optimization is enabled, only draw when \a
- *  pDrawable is at least partially visible. */
-void dmxImageText16(DrawablePtr pDrawable, GCPtr pGC,
-		    int x, int y, int count, unsigned short *chars)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
-    Drawable       draw;
-
-    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
-
-    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-
-    XDrawImageString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
-		       x, y, (XChar2b *)chars, count);
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Image Glyph Blt -- this function should never be called. */
-void dmxImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
-		      int x, int y, unsigned int nglyph,
-		      CharInfoPtr *ppci, pointer pglyphBase)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Poly Glyph Blt -- this function should never be called. */
-void dmxPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
-		     int x, int y, unsigned int nglyph,
-		     CharInfoPtr *ppci, pointer pglyphBase)
-{
-    /* Error -- this should never happen! */
-}
-
-/** Push Pixels -- this function should never be called. */
-void dmxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
-		   int w, int h, int x, int y)
-{
-    /* Error -- this should never happen! */
-}
-
-/**********************************************************************
- * Miscellaneous drawing commands
- */
-
-/** When Xinerama is active, the client pixmaps are always obtained from
- * screen 0.  When screen 0 is detached, the pixmaps must be obtained
- * from any other screen that is not detached.  Usually, this is screen
- * 1. */
-static DMXScreenInfo *dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw)
-{
-#ifdef PANORAMIX
-    PanoramiXRes  *pXinPix;
-    int           i;
-    DMXScreenInfo *dmxScreen;
-            
-    if (noPanoramiXExtension)               return NULL;
-    if (pDrawable->type != DRAWABLE_PIXMAP) return NULL;
-
-    if (Success != dixLookupResourceByType((pointer*) &pXinPix,
-					   pDrawable->id, XRT_PIXMAP,
-					   NullClient, DixUnknownAccess))
-        return NULL;
-
-    FOR_NSCREENS_FORWARD_SKIP(i) {
-        dmxScreen = &dmxScreens[i];
-        if (dmxScreen->beDisplay) {
-            PixmapPtr     pSrc;
-            dmxPixPrivPtr pSrcPriv;
-            
-            dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id,
-				    RT_PIXMAP, NullClient, DixUnknownAccess);
-            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
-            if (pSrcPriv->pixmap) {
-                *draw = pSrcPriv->pixmap;
-                return dmxScreen;
-            }
-        }
-    }
-#endif
-    return NULL;
-}
-
-/** Get an image from the back-end server associated with \a pDrawable's
- *  screen.  If \a pDrawable is a window, it must be viewable to get an
- *  image from it.  If it is not viewable, then get the image from the
- *  first ancestor of \a pDrawable that is viewable.  If no viewable
- *  ancestor is found, then simply return without getting an image.  */
-void dmxGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
-		 unsigned int format, unsigned long planeMask, char *pdstLine)
-{
-    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
-    XImage        *img;
-    Drawable       draw;
-
-    /* Cannot get image from unviewable window */
-    if (pDrawable->type == DRAWABLE_WINDOW) {
-	WindowPtr pWindow = (WindowPtr)pDrawable;
-	if (!pWindow->viewable) {
-	    while (!pWindow->viewable && pWindow->parent) {
-		sx += pWindow->origin.x - wBorderWidth(pWindow);
-		sx += pWindow->origin.y - wBorderWidth(pWindow);
-		pWindow = pWindow->parent;
-	    }
-	    if (!pWindow->viewable) {
-		return;
-	    }
-	}
-	DMX_GCOPS_SET_DRAWABLE(&pWindow->drawable, draw);
-	if (DMX_GCOPS_OFFSCREEN(&pWindow->drawable))
-	    return;
-    } else {
-	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
-	if (DMX_GCOPS_OFFSCREEN(pDrawable)) {
-            /* Try to find the pixmap on a non-detached Xinerama screen */
-            dmxScreen = dmxFindAlternatePixmap(pDrawable, &draw);
-            if (!dmxScreen) return;
-        }
-    }
-
-    img = XGetImage(dmxScreen->beDisplay, draw,
-		    sx, sy, w, h, planeMask, format);
-    if (img) {
-	int len = img->bytes_per_line * img->height;
-	memmove(pdstLine, img->data, len);
-	XDestroyImage(img);
-    }
-
-    dmxSync(dmxScreen, FALSE);
-}
-
-/** Get Spans -- this function should never be called. */
-void dmxGetSpans(DrawablePtr pDrawable, int wMax,
-		 DDXPointPtr ppt, int *pwidth, int nspans,
-		 char *pdstStart)
-{
-    /* Error -- this should never happen! */
-}
+/*
+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kem@redhat.com>
+ *
+ */
+
+/** \file
+ * This file provides support for GC operations. */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxsync.h"
+#include "dmxgc.h"
+#include "dmxgcops.h"
+#include "dmxwindow.h"
+#include "dmxpixmap.h"
+
+#include "mi.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "dixfontstr.h"
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.h"
+#endif
+
+#define DMX_GCOPS_SET_DRAWABLE(_pDraw, _draw)				\
+do {									\
+    if ((_pDraw)->type == DRAWABLE_WINDOW) {				\
+	dmxWinPrivPtr  pWinPriv =					\
+	    DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw));			\
+	(_draw) = (Drawable)pWinPriv->window;				\
+    } else {								\
+	dmxPixPrivPtr  pPixPriv =					\
+	    DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw));			\
+	(_draw) = (Drawable)pPixPriv->pixmap;				\
+    }									\
+} while (0)
+
+#define DMX_GCOPS_OFFSCREEN(_pDraw)					\
+    (!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay ||			\
+     (dmxOffScreenOpt &&						\
+      (_pDraw)->type == DRAWABLE_WINDOW &&				\
+      (DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen ||		\
+       !DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))
+
+/** Fill spans -- this function should never be called. */
+void dmxFillSpans(DrawablePtr pDrawable, GCPtr pGC,
+		  int nInit, DDXPointPtr pptInit, int *pwidthInit,
+		  int fSorted)
+{
+    /* Error -- this should never happen! */
+}
+
+/** Set spans -- this function should never be called. */
+void dmxSetSpans(DrawablePtr pDrawable, GCPtr pGC,
+		 char *psrc, DDXPointPtr ppt, int *pwidth, int nspans,
+		 int fSorted)
+{
+    /* Error -- this should never happen! */
+}
+
+/** Transfer \a pBits image to back-end server associated with \a
+ *  pDrawable's screen.  If primitive subdivision optimization is
+ *  enabled, then only transfer the sections of \a pBits that are
+ *  visible (i.e., not-clipped) to the back-end server. */
+void dmxPutImage(DrawablePtr pDrawable, GCPtr pGC,
+		 int depth, int x, int y, int w, int h,
+		 int leftPad, int format, char *pBits)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    XImage        *img;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    img = XCreateImage(dmxScreen->beDisplay,
+		       dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
+		       depth, format, leftPad, pBits, w, h,
+		       BitmapPad(dmxScreen->beDisplay),
+		       (format == ZPixmap) ?
+		       PixmapBytePad(w, depth) : BitmapBytePad(w+leftPad));
+
+    if (img) {
+	Drawable draw;
+
+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+	if (dmxSubdividePrimitives && pGC->pCompositeClip) {
+	    RegionPtr  pSubImages;
+	    RegionPtr  pClip;
+	    BoxRec     box;
+	    BoxPtr     pBox;
+	    int        nBox;
+
+	    box.x1 = x;
+	    box.y1 = y;
+	    box.x2 = x + w;
+	    box.y2 = y + h;
+	    pSubImages = RegionCreate(&box, 1);
+
+	    pClip = RegionCreate(NullBox, 1);
+	    RegionCopy(pClip, pGC->pCompositeClip);
+	    RegionTranslate(pClip,
+			     -pDrawable->x, -pDrawable->y);
+	    RegionIntersect(pSubImages, pSubImages, pClip);
+
+	    nBox = RegionNumRects(pSubImages);
+	    pBox = RegionRects(pSubImages);
+
+	    while (nBox--) {
+		XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc, img,
+			  pBox->x1 - box.x1,
+			  pBox->y1 - box.y1,
+			  pBox->x1,
+			  pBox->y1,
+			  pBox->x2 - pBox->x1,
+			  pBox->y2 - pBox->y1);
+		pBox++;
+	    }
+            RegionDestroy(pClip);
+            RegionDestroy(pSubImages);
+	} else {
+	    XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		      img, 0, 0, x, y, w, h);
+	}
+	XFree(img);             /* Use XFree instead of XDestroyImage
+                                 * because pBits is passed in from the
+                                 * caller. */
+
+	dmxSync(dmxScreen, FALSE);
+    } else {
+	/* Error -- this should not happen! */
+    }
+}
+
+/** Copy area from \a pSrc drawable to \a pDst drawable on the back-end
+ *  server associated with \a pSrc drawable's screen.  If the offscreen
+ *  optimization is enabled, only copy when both \a pSrc and \a pDst are
+ *  at least partially visible. */
+RegionPtr dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+		      int srcx, int srcy, int w, int h, int dstx, int dsty)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       srcDraw, dstDraw;
+
+    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
+	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
+				 dstx, dsty, 0L);
+
+    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
+    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
+
+    XCopyArea(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
+	      srcx, srcy, w, h, dstx, dsty);
+    dmxSync(dmxScreen, FALSE);
+
+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
+			     dstx, dsty, 0L);
+}
+
+/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
+ *  drawable on the back-end server associated with \a pSrc drawable's
+ *  screen.  If the offscreen optimization is enabled, only copy when
+ *  both \a pSrc and \a pDst are at least partially visible. */
+RegionPtr dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+		       int srcx, int srcy, int width, int height,
+		       int dstx, int dsty, unsigned long bitPlane)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       srcDraw, dstDraw;
+
+    if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
+	return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
+				 dstx, dsty, bitPlane);
+
+    DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
+    DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
+
+    XCopyPlane(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
+	       srcx, srcy, width, height, dstx, dsty, bitPlane);
+    dmxSync(dmxScreen, FALSE);
+
+    return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
+			     dstx, dsty, bitPlane);
+}
+
+/** Render list of points, \a pptInit in \a pDrawable on the back-end
+ *  server associated with \a pDrawable's screen.  If the offscreen
+ *  optimization is enabled, only draw when \a pDrawable is at least
+ *  partially visible. */
+void dmxPolyPoint(DrawablePtr pDrawable, GCPtr pGC,
+		  int mode, int npt, DDXPointPtr pptInit)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawPoints(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		(XPoint *)pptInit, npt, mode);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of connected lines, \a pptInit in \a pDrawable on the
+ *  back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+void dmxPolylines(DrawablePtr pDrawable, GCPtr pGC,
+		  int mode, int npt, DDXPointPtr pptInit)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawLines(dmxScreen->beDisplay, draw, pGCPriv->gc,
+	       (XPoint *)pptInit, npt, mode);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of disjoint segments, \a pSegs in \a pDrawable on the
+ *  back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+void dmxPolySegment(DrawablePtr pDrawable, GCPtr pGC,
+		    int nseg, xSegment *pSegs)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawSegments(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		  (XSegment *)pSegs, nseg);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of rectangle outlines, \a pRects in \a pDrawable on the
+ *  back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+void dmxPolyRectangle(DrawablePtr pDrawable, GCPtr pGC,
+		      int nrects, xRectangle *pRects)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		    (XRectangle *)pRects, nrects);
+
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of arc outlines, \a parcs in \a pDrawable on the
+ *  back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+void dmxPolyArc(DrawablePtr pDrawable, GCPtr pGC,
+		int narcs, xArc *parcs)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
+	      (XArc *)parcs, narcs);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render a filled polygons in \a pDrawable on the back-end server
+ *  associated with \a pDrawable's screen.  If the offscreen
+ *  optimization is enabled, only draw when \a pDrawable is at least
+ *  partially visible. */
+void dmxFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
+		    int shape, int mode, int count, DDXPointPtr pPts)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XFillPolygon(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		 (XPoint *)pPts, count, shape, mode);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of filled rectangles, \a prectInit in \a pDrawable on
+ *  the back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+void dmxPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
+		     int nrectFill, xRectangle *prectInit)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XFillRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		    (XRectangle *)prectInit, nrectFill);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render list of filled arcs, \a parcs in \a pDrawable on the back-end
+ *  server associated with \a pDrawable's screen.  If the offscreen
+ *  optimization is enabled, only draw when \a pDrawable is at least
+ *  partially visible. */
+void dmxPolyFillArc(DrawablePtr pDrawable, GCPtr pGC,
+		    int narcs, xArc *parcs)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XFillArcs(dmxScreen->beDisplay, draw, pGCPriv->gc,
+	      (XArc *)parcs, narcs);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render string of 8-bit \a chars (foreground only) in \a pDrawable on
+ *  the back-end server associated with \a pDrawable's screen.  If the
+ *  offscreen optimization is enabled, only draw when \a pDrawable is at
+ *  least partially visible. */
+int dmxPolyText8(DrawablePtr pDrawable, GCPtr pGC,
+		 int x, int y, int count, char *chars)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    unsigned long  n, i;
+    int            w;
+    CharInfoPtr    charinfo[255];
+    Drawable       draw;
+
+    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
+	      Linear8Bit, &n, charinfo);
+
+    /* Calculate text width */
+    w = 0;
+    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
+
+    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+	XDrawString(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		    x, y, chars, count);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    return x+w;
+}
+
+/** Render string of 16-bit \a chars (foreground only) in \a pDrawable
+ *  on the back-end server associated with \a pDrawable's screen.  If
+ *  the offscreen optimization is enabled, only draw when \a pDrawable
+ *  is at least partially visible. */
+int dmxPolyText16(DrawablePtr pDrawable, GCPtr pGC,
+		  int x, int y, int count, unsigned short *chars)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    unsigned long  n, i;
+    int            w;
+    CharInfoPtr    charinfo[255];
+    Drawable       draw;
+
+    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)chars,
+	      (FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,
+	      &n, charinfo);
+
+    /* Calculate text width */
+    w = 0;
+    for (i = 0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
+
+    if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+	XDrawString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		      x, y, (XChar2b *)chars, count);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    return x+w;
+}
+
+/** Render string of 8-bit \a chars (both foreground and background) in
+ *  \a pDrawable on the back-end server associated with \a pDrawable's
+ *  screen.  If the offscreen optimization is enabled, only draw when \a
+ *  pDrawable is at least partially visible. */
+void dmxImageText8(DrawablePtr pDrawable, GCPtr pGC,
+		   int x, int y, int count, char *chars)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawImageString(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		     x, y, chars, count);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Render string of 16-bit \a chars (both foreground and background) in
+ *  \a pDrawable on the back-end server associated with \a pDrawable's
+ *  screen.  If the offscreen optimization is enabled, only draw when \a
+ *  pDrawable is at least partially visible. */
+void dmxImageText16(DrawablePtr pDrawable, GCPtr pGC,
+		    int x, int y, int count, unsigned short *chars)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    dmxGCPrivPtr   pGCPriv = DMX_GET_GC_PRIV(pGC);
+    Drawable       draw;
+
+    if (DMX_GCOPS_OFFSCREEN(pDrawable)) return;
+
+    DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+
+    XDrawImageString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
+		       x, y, (XChar2b *)chars, count);
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Image Glyph Blt -- this function should never be called. */
+void dmxImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+		      int x, int y, unsigned int nglyph,
+		      CharInfoPtr *ppci, pointer pglyphBase)
+{
+    /* Error -- this should never happen! */
+}
+
+/** Poly Glyph Blt -- this function should never be called. */
+void dmxPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+		     int x, int y, unsigned int nglyph,
+		     CharInfoPtr *ppci, pointer pglyphBase)
+{
+    /* Error -- this should never happen! */
+}
+
+/** Push Pixels -- this function should never be called. */
+void dmxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
+		   int w, int h, int x, int y)
+{
+    /* Error -- this should never happen! */
+}
+
+/**********************************************************************
+ * Miscellaneous drawing commands
+ */
+
+/** When Xinerama is active, the client pixmaps are always obtained from
+ * screen 0.  When screen 0 is detached, the pixmaps must be obtained
+ * from any other screen that is not detached.  Usually, this is screen
+ * 1. */
+static DMXScreenInfo *dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw)
+{
+#ifdef PANORAMIX
+    PanoramiXRes  *pXinPix;
+    int           i;
+    DMXScreenInfo *dmxScreen;
+            
+    if (noPanoramiXExtension)               return NULL;
+    if (pDrawable->type != DRAWABLE_PIXMAP) return NULL;
+
+    if (Success != dixLookupResourceByType((pointer*) &pXinPix,
+					   pDrawable->id, XRT_PIXMAP,
+					   NullClient, DixUnknownAccess))
+        return NULL;
+
+    FOR_NSCREENS_FORWARD_SKIP(i) {
+        dmxScreen = &dmxScreens[i];
+        if (dmxScreen->beDisplay) {
+            PixmapPtr     pSrc;
+            dmxPixPrivPtr pSrcPriv;
+            
+            dixLookupResourceByType((pointer*) &pSrc, pXinPix->info[i].id,
+				    RT_PIXMAP, NullClient, DixUnknownAccess);
+            pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
+            if (pSrcPriv->pixmap) {
+                *draw = pSrcPriv->pixmap;
+                return dmxScreen;
+            }
+        }
+    }
+#endif
+    return NULL;
+}
+
+/** Get an image from the back-end server associated with \a pDrawable's
+ *  screen.  If \a pDrawable is a window, it must be viewable to get an
+ *  image from it.  If it is not viewable, then get the image from the
+ *  first ancestor of \a pDrawable that is viewable.  If no viewable
+ *  ancestor is found, then simply return without getting an image.  */
+void dmxGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
+		 unsigned int format, unsigned long planeMask, char *pdstLine)
+{
+    DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
+    XImage        *img;
+    Drawable       draw;
+
+    /* Cannot get image from unviewable window */
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+	WindowPtr pWindow = (WindowPtr)pDrawable;
+	if (!pWindow->viewable) {
+	    while (!pWindow->viewable && pWindow->parent) {
+		sx += pWindow->origin.x - wBorderWidth(pWindow);
+		sx += pWindow->origin.y - wBorderWidth(pWindow);
+		pWindow = pWindow->parent;
+	    }
+	    if (!pWindow->viewable) {
+		return;
+	    }
+	}
+	DMX_GCOPS_SET_DRAWABLE(&pWindow->drawable, draw);
+	if (DMX_GCOPS_OFFSCREEN(&pWindow->drawable))
+	    return;
+    } else {
+	DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
+	if (DMX_GCOPS_OFFSCREEN(pDrawable)) {
+            /* Try to find the pixmap on a non-detached Xinerama screen */
+            dmxScreen = dmxFindAlternatePixmap(pDrawable, &draw);
+            if (!dmxScreen) return;
+        }
+    }
+
+    img = XGetImage(dmxScreen->beDisplay, draw,
+		    sx, sy, w, h, planeMask, format);
+    if (img) {
+	int len = img->bytes_per_line * img->height;
+	memmove(pdstLine, img->data, len);
+	XDestroyImage(img);
+    }
+
+    dmxSync(dmxScreen, FALSE);
+}
+
+/** Get Spans -- this function should never be called. */
+void dmxGetSpans(DrawablePtr pDrawable, int wMax,
+		 DDXPointPtr ppt, int *pwidth, int nspans,
+		 char *pdstStart)
+{
+    /* Error -- this should never happen! */
+}
diff --git a/xorg-server/hw/dmx/dmxinit.c b/xorg-server/hw/dmx/dmxinit.c
index e0e5d1228..5dce93028 100644
--- a/xorg-server/hw/dmx/dmxinit.c
+++ b/xorg-server/hw/dmx/dmxinit.c
@@ -834,6 +834,7 @@ void AbortDDX(void)
 }
 
 #ifdef DDXBEFORERESET
+/* This function is called in Xserver/dix/dispatch.c */
 void ddxBeforeReset(void)
 {
 }
diff --git a/xorg-server/hw/dmx/glxProxy/glxcmds.c b/xorg-server/hw/dmx/glxProxy/glxcmds.c
index f79264ea9..eb589f428 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmds.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmds.c
@@ -1,3645 +1,3645 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxwindow.h"
-#include "dmxpixmap.h"
-#include "dmxfont.h"
-#include "dmxsync.h"
-
-#include "glxserver.h"
-#include <GL/glxtokens.h>
-#include "g_disptab.h"
-#include <pixmapstr.h>
-#include <windowstr.h>
-#include "glxutil.h"
-#include "glxext.h"
-#include "unpack.h"
-
-#include "GL/glxproto.h"
-#include "glxvendor.h"
-#include "glxvisuals.h"
-#include "glxswap.h"
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-#endif
-
-extern __GLXFBConfig **__glXFBConfigs;
-extern int            __glXNumFBConfigs;
-
-extern __GLXFBConfig *glxLookupFBConfig( GLXFBConfigID id );
-extern __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid );
-extern __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen );
-extern int glxIsExtensionSupported( char *ext );
-extern int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
-
-#define BE_TO_CLIENT_ERROR(x) \
-           ( (x) >= __glXerrorBase ? \
-             (x) - dmxScreen->glxErrorBase + __glXerrorBase \
-	     : (x) )
-
-Display *GetBackEndDisplay( __GLXclientState *cl, int s )
-{
-   if (! cl->be_displays[s] ) {
-      cl->be_displays[s] = XOpenDisplay( DisplayString(dmxScreens[s].beDisplay) );
-   }
-   return cl->be_displays[s];
-}
-
-/*
-** Create a GL context with the given properties.
-*/
-static int CreateContext(__GLXclientState *cl, 
-                         GLXContextID gcId,
-			 VisualID vid, GLXFBConfigID fbconfigId,
-			 int screen,
-			 GLXContextID shareList,
-			 int isDirect )
-{
-    ClientPtr client = cl->client;
-    xGLXCreateContextReq *be_req;
-    xGLXCreateNewContextReq *be_new_req;
-    VisualPtr pVisual;
-    ScreenPtr pScreen;
-    __GLXcontext *glxc, *shareglxc;
-    __GLXvisualConfig *pGlxVisual;
-    __GLXscreenInfo *pGlxScreen;
-    VisualID visual = vid;
-    GLint i;
-    int from_screen = screen;
-    int to_screen = screen;
-    DMXScreenInfo *dmxScreen;
-    VisualID be_vid = 0;
-    GLXFBConfigID be_fbconfigId = 0;
-    int num_be_screens;
-    Display *dpy;
-    
-    /*
-    ** Check if screen exists.
-    */
-    if (screen >= screenInfo.numScreens) {
-	client->errorValue = screen;
-	return BadValue;
-    }
-
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    /*
-     ** Find the display list space that we want to share.  
-     **
-     */
-    if (shareList == None) {
-       shareglxc = NULL;
-    } else {
-       dixLookupResourceByType((pointer*) &shareglxc, shareList,
-                               __glXContextRes, NullClient, DixUnknownAccess);
-       if (!shareglxc) {
-	  client->errorValue = shareList;
-	  return __glXBadContext;
-       }
-    }
-
-    /*
-    ** Allocate memory for the new context
-    */
-    glxc = calloc(1, sizeof(__GLXcontext));
-    if (!glxc) {
-	return BadAlloc;
-    }
-
-    pScreen = screenInfo.screens[screen];
-    pGlxScreen = &__glXActiveScreens[screen];
-
-    if (fbconfigId != None) {
-       glxc->pFBConfig = glxLookupFBConfig( fbconfigId );
-       if (!glxc->pFBConfig) {
-	  client->errorValue = fbconfigId;
-	  free( glxc );
-	  return BadValue;
-       }
-       visual = glxc->pFBConfig->associatedVisualId;
-    }
-    else {
-       glxc->pFBConfig = NULL;
-    }
-
-    if (visual != None) {
-       /*
-	** Check if the visual ID is valid for this screen.
-	*/
-       pVisual = pScreen->visuals;
-       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
-	  if (pVisual->vid == visual) {
-	     break;
-	  }
-       }
-       if (i == pScreen->numVisuals) {
-	  client->errorValue = visual;
-	  free( glxc );
-	  return BadValue;
-       }
-
-       pGlxVisual = pGlxScreen->pGlxVisual;
-       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	  if (pGlxVisual->vid == visual) {
-	     break;
-	  }
-       }
-       if (i == pGlxScreen->numVisuals) {
-	  /*
-	   ** Visual not support on this screen by this OpenGL implementation.
-	   */
-	  client->errorValue = visual;
-	  free( glxc );
-	  return BadValue;
-       }
-
-       if ( glxc->pFBConfig == NULL ) {
-	   glxc->pFBConfig = glxLookupFBConfigByVID( visual );
-
-	   if ( glxc->pFBConfig == NULL ) {
-	      /*
-               * visual does not have an FBConfig ???
-	      client->errorValue = visual;
-	      free( glxc );
-	      return BadValue;
-	       */
-	   }
-       }
-    }
-    else {
-       pVisual = NULL;
-       pGlxVisual = NULL;
-    }
-
-    glxc->pScreen = pScreen;
-    glxc->pGlxScreen = pGlxScreen;
-    glxc->pVisual = pVisual;
-    glxc->pGlxVisual = pGlxVisual;
-
-    /*
-     * allocate memory for back-end servers info
-     */
-    num_be_screens = to_screen - from_screen + 1;
-    glxc->real_ids = (XID *)malloc(sizeof(XID) * num_be_screens);
-    if (!glxc->real_ids) {
-	return BadAlloc;
-    }
-    glxc->real_vids = (XID *)malloc(sizeof(XID) * num_be_screens);
-    if (!glxc->real_vids) {
-	return BadAlloc;
-    }
-
-    for (screen = from_screen; screen <= to_screen; screen++) {
-       int sent = 0;
-       pScreen = screenInfo.screens[screen];
-       pGlxScreen = &__glXActiveScreens[screen];
-       dmxScreen = &dmxScreens[screen];
-
-       if (glxc->pFBConfig) {
-	  __GLXFBConfig *beFBConfig = glxLookupBackEndFBConfig( glxc->pFBConfig->id, 
-		                                                screen );
-	  be_fbconfigId = beFBConfig->id;
-       }
-
-       if (pGlxVisual) {
-
-	  be_vid = glxMatchGLXVisualInConfigList( pGlxVisual,
-	                                    dmxScreen->glxVisuals,
-					    dmxScreen->numGlxVisuals  );
-
-	  if (!be_vid) {
-	     /* visual is not supported on the back-end server */
-	     free( glxc->real_ids );
-	     free( glxc->real_vids );
-	     free( glxc );
-	     return BadValue;
-	  }
-       }
-
-       glxc->real_ids[screen-from_screen] = XAllocID(GetBackEndDisplay(cl,screen));
-
-       /* send the create context request to the back-end server */
-       dpy = GetBackEndDisplay(cl,screen);
-       if (glxc->pFBConfig) {
-	     /*Since for a certain visual both RGB and COLOR INDEX
-	      *can be on then the only parmeter to choose the renderType
-	      * should be the class of the colormap since all 4 first 
-	      * classes does not support RGB mode only COLOR INDEX ,
-	      * and so TrueColor and DirectColor does not support COLOR INDEX*/
-	     int renderType =  glxc->pFBConfig->renderType;  
-	     if ( pVisual ) {
-		 switch ( pVisual->class ){
-		     case PseudoColor:
-                     case StaticColor:
-                     case GrayScale:
-                     case StaticGray:
-                         renderType = GLX_COLOR_INDEX_TYPE;
-                         break;
-                     case TrueColor:
-                     case DirectColor:
-                     default:
-                         renderType = GLX_RGBA_TYPE;
-                     break;
-		 }
-	     }
-	  if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	     LockDisplay(dpy);
-	     GetReq(GLXCreateNewContext,be_new_req);
-	     be_new_req->reqType = dmxScreen->glxMajorOpcode;
-	     be_new_req->glxCode = X_GLXCreateNewContext;
-	     be_new_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
-	     be_new_req->fbconfig = (unsigned int)be_fbconfigId;
-	     be_new_req->screen = DefaultScreen(dpy);
-	     be_new_req->renderType = renderType;  
-
-	     be_new_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
-	     be_new_req->isDirect = 0;
-	     UnlockDisplay(dpy);
-	     glxc->real_vids[screen-from_screen] = be_fbconfigId;
-	     sent = 1;
-	  }
-	  else if (glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
-
-	     xGLXCreateContextWithConfigSGIXReq *ext_req;
-	     xGLXVendorPrivateReq *vpreq;
-	     LockDisplay(dpy);
-	     GetReqExtra(GLXVendorPrivate,
-		         sz_xGLXCreateContextWithConfigSGIXReq - sz_xGLXVendorPrivateReq,
-			vpreq);
-	     ext_req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
-	     ext_req->reqType = dmxScreen->glxMajorOpcode;
-	     ext_req->glxCode = X_GLXVendorPrivate;
-	     ext_req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
-	     ext_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
-	     ext_req->fbconfig = (unsigned int)be_fbconfigId;
-	     ext_req->screen = DefaultScreen(dpy);
-	     ext_req->renderType = renderType;  
-	     ext_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
-	     ext_req->isDirect = 0;
-	     UnlockDisplay(dpy);
-	     glxc->real_vids[screen-from_screen] = be_fbconfigId;
-	     sent = 1;
-	  }
-       }
-
-       if (!sent) {
-	  LockDisplay(dpy);
-	  GetReq(GLXCreateContext,be_req);
-	  be_req->reqType = dmxScreen->glxMajorOpcode;
-	  be_req->glxCode = X_GLXCreateContext;
-	  be_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
-	  be_req->visual = (unsigned int)be_vid;
-	  be_req->screen = DefaultScreen(dpy);
-	  be_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
-	  be_req->isDirect = 0;
-	  UnlockDisplay(dpy);
-	  glxc->real_vids[screen-from_screen] = be_vid;
-       }
-       SyncHandle();
-
-    }
-
-    /*
-    ** Register this context as a resource.
-    */
-    if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
-       free( glxc->real_ids );
-       free( glxc->real_vids );
-       free( glxc );
-	client->errorValue = gcId;
-	return BadAlloc;
-    }
-    
-    /*
-    ** Finally, now that everything is working, setup the rest of the
-    ** context.
-    */
-    glxc->id = gcId;
-    glxc->share_id = shareList;
-    glxc->idExists = GL_TRUE;
-    glxc->isCurrent = GL_FALSE;
-
-    return Success;
-}
-
-int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
-
-    return( CreateContext(cl, req->context,req->visual, None,
-	                  req->screen, req->shareList, req->isDirect) );
-
-}
-
-int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
-
-    return( CreateContext(cl, req->context,None, req->fbconfig,
-	                  req->screen, req->shareList, req->isDirect) );
-
-}
-
-int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;
-
-    return( CreateContext(cl, req->context, None, req->fbconfig,
-	                  req->screen, req->shareList, req->isDirect) );
-
-}
-
-int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXQueryMaxSwapBarriersSGIXReq *req =
-	(xGLXQueryMaxSwapBarriersSGIXReq *)pc;
-    xGLXQueryMaxSwapBarriersSGIXReply reply;
-
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = 0;
-    reply.max = QueryMaxSwapBarriersSGIX(req->screen);
-
-    if (client->swapped) {
-	__glXSwapQueryMaxSwapBarriersSGIXReply(client, &reply);
-    } else {
-	WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply,
-		      (char *)&reply);
-    }
-
-    return Success;
-}
-
-int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
-    DrawablePtr pDraw;
-    __GLXpixmap *pGlxPixmap = NULL;
-    __glXWindow *pGlxWindow = NULL;
-    int rc;
-
-    rc = dixLookupDrawable(&pDraw, req->drawable, client, 0, DixGetAttrAccess);
-    if (rc != Success) {
-	dixLookupResourceByType((pointer*) &pGlxPixmap, req->drawable,
-				__glXPixmapRes, NullClient, DixUnknownAccess);
-	if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
-    }
-
-    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-       dixLookupResourceByType((pointer*) &pGlxWindow, req->drawable,
-                               __glXWindowRes, NullClient, DixUnknownAccess);
-       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
-    }
-
-    if (!pDraw) {
-       client->errorValue = req->drawable;
-       return __glXBadDrawable;
-    }
-
-    return BindSwapBarrierSGIX(pDraw, req->barrier);
-}
-
-int __glXJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
-    DrawablePtr pDraw, pMember = NULL;
-    __GLXpixmap *pGlxPixmap = NULL;
-    __glXWindow *pGlxWindow = NULL;
-    int rc;
-
-    rc = dixLookupDrawable(&pDraw, req->drawable, client, 0, DixManageAccess);
-    if (rc != Success) {
-	dixLookupResourceByType((pointer*) &pGlxPixmap, req->drawable,
-				__glXPixmapRes, NullClient, DixUnknownAccess);
-	if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
-    }
-
-    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-       dixLookupResourceByType((pointer*) &pGlxWindow, req->drawable,
-                               __glXWindowRes, NullClient, DixUnknownAccess);
-       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
-    }
-
-    if (!pDraw) {
-       client->errorValue = req->drawable;
-       return __glXBadDrawable;
-    }
-
-    if (req->member != None) {
-	rc = dixLookupDrawable(&pMember, req->member, client, 0,
-			       DixGetAttrAccess);
-	if (rc != Success) {
-	    dixLookupResourceByType((pointer*) &pGlxPixmap, req->member,
-                                    __glXPixmapRes, NullClient,
-                                    DixUnknownAccess);
-	    if (pGlxPixmap) pMember = pGlxPixmap->pDraw;
-	}
-
-	if (!pMember && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	    dixLookupResourceByType((pointer*) &pGlxWindow, req->member,
-                                    __glXWindowRes, NullClient,
-                                    DixUnknownAccess);
-	    if (pGlxWindow) pMember = pGlxWindow->pDraw;
-	}
-
-	if (!pMember) {
-	    client->errorValue = req->member;
-	    return __glXBadDrawable;
-	}
-    }
-
-    return JoinSwapGroupSGIX(pDraw, pMember);
-}
-
-
-/*
-** Destroy a GL context as an X resource.
-*/
-int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
-    xGLXDestroyContextReq *be_req;
-    GLXContextID gcId = req->context;
-    __GLXcontext *glxc;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-    
-    dixLookupResourceByType((pointer*) &glxc, gcId, __glXContextRes,
-			    NullClient, DixUnknownAccess);
-    if (glxc) {
-	/*
-	** Just free the resource; don't actually destroy the context,
-	** because it might be in use.  The
-	** destroy method will be called by the resource destruction routine
-	** if necessary.
-	*/
-	FreeResourceByType(gcId, __glXContextRes, FALSE);
-
-	from_screen = to_screen = glxc->pScreen->myNum;
-
-    } else {
-	client->errorValue = gcId;
-	return __glXBadContext;
-    }
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    /*
-     * send DestroyContext request to all back-end servers
-     */
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReq(GLXDestroyContext,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXDestroyContext;
-       be_req->context = glxc->real_ids[s-from_screen];
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    return Success;
-}
-
-/*****************************************************************************/
-
-/*
-** For each client, the server keeps a table of all the contexts that are
-** current for that client (each thread of a client may have its own current
-** context).  These routines add, change, and lookup contexts in the table.
-*/
-
-/*
-** Add a current context, and return the tag that will be used to refer to it.
-*/
-static int AddCurrentContext(__GLXclientState *cl, __GLXcontext *glxc, DrawablePtr pDraw)
-{
-    int i;
-    int num = cl->numCurrentContexts;
-    __GLXcontext **table = cl->currentContexts;
-
-    if (!glxc) return -1;
-    
-    /*
-    ** Try to find an empty slot and use it.
-    */
-    for (i=0; i < num; i++) {
-	if (!table[i]) {
-	    table[i] = glxc;
-	    return i+1;
-	}
-    }
-    /*
-    ** Didn't find a free slot, so we'll have to grow the table.
-    */
-    if (!num) {
-	table = (__GLXcontext **) malloc(sizeof(__GLXcontext *));
-	cl->currentDrawables = (DrawablePtr *) malloc(sizeof(DrawablePtr));
-	cl->be_currentCTag = (GLXContextTag *) malloc(screenInfo.numScreens *sizeof(GLXContextTag));
-    } else {
-	table = (__GLXcontext **) realloc(table,
-					   (num+1)*sizeof(__GLXcontext *));
-	cl->currentDrawables = (DrawablePtr *) realloc(
-	                                          cl->currentDrawables ,
-						  (num+1)*sizeof(DrawablePtr));
-	cl->be_currentCTag = (GLXContextTag *) realloc(cl->be_currentCTag,
-	            (num+1)*screenInfo.numScreens*sizeof(GLXContextTag));
-    }
-    table[num] = glxc;
-    cl->currentDrawables[num] = pDraw;
-    cl->currentContexts = table;
-    cl->numCurrentContexts++;
-
-    memset(cl->be_currentCTag + num*screenInfo.numScreens, 0, 
-	         screenInfo.numScreens * sizeof(GLXContextTag));
-
-    return num+1;
-}
-
-/*
-** Given a tag, change the current context for the corresponding entry.
-*/
-static void ChangeCurrentContext(__GLXclientState *cl, __GLXcontext *glxc,
-				GLXContextTag tag)
-{
-    __GLXcontext **table = cl->currentContexts;
-    table[tag-1] = glxc;
-}
-
-/*
-** Given a tag, and back-end screen number, retrives the current back-end
-** tag.
-*/
-int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s)
-{
-   if (tag >0) {
-      return( cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] );
-   }
-   else {
-      return 0;
-   }
-}
-
-/*
-** Given a tag, and back-end screen number, sets the current back-end
-** tag.
-*/
-static void SetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s, GLXContextTag be_tag)
-{
-   if (tag >0) {
-      cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] = be_tag;
-   }
-}
-
-/*
-** For this implementation we have chosen to simply use the index of the
-** context's entry in the table as the context tag.  A tag must be greater
-** than 0.
-*/
-__GLXcontext *__glXLookupContextByTag(__GLXclientState *cl, GLXContextTag tag)
-{
-    int num = cl->numCurrentContexts;
-
-    if (tag < 1 || tag > num) {
-	return 0;
-    } else {
-	return cl->currentContexts[tag-1];
-    }
-}
-
-DrawablePtr __glXLookupDrawableByTag(__GLXclientState *cl, GLXContextTag tag)
-{
-    int num = cl->numCurrentContexts;
-
-    if (tag < 1 || tag > num) {
-	return 0;
-    } else {
-	return cl->currentDrawables[tag-1];
-    }
-}
-
-/*****************************************************************************/
-
-static void StopUsingContext(__GLXcontext *glxc)
-{
-    if (glxc) {
-	if (glxc == __glXLastContext) {
-	    /* Tell server GL library */
-	    __glXLastContext = 0;
-	}
-	glxc->isCurrent = GL_FALSE;
-	if (!glxc->idExists) {
-	    __glXFreeContext(glxc);
-	}
-    }
-}
-
-static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
-{
-    glxc->isCurrent = GL_TRUE;
-}
-
-/*****************************************************************************/
-/*
-** Make an OpenGL context and drawable current.
-*/
-static int MakeCurrent(__GLXclientState *cl,
-                       GLXDrawable drawable,
-                       GLXDrawable readdrawable,
-		       GLXContextID context,
-		       GLXContextTag oldContextTag)
-{
-    ClientPtr client = cl->client;
-    DrawablePtr pDraw = NULL;
-    DrawablePtr pReadDraw = NULL;
-    xGLXMakeCurrentReadSGIReply new_reply;
-    xGLXMakeCurrentReq *be_req;
-    xGLXMakeCurrentReply be_reply;
-    xGLXMakeContextCurrentReq *be_new_req;
-    xGLXMakeContextCurrentReply be_new_reply;
-    GLXDrawable drawId = drawable;
-    GLXDrawable readId = readdrawable;
-    GLXContextID contextId = context;
-    __GLXpixmap *pGlxPixmap = 0;
-    __GLXpixmap *pReadGlxPixmap = 0;
-    __GLXcontext *glxc, *prevglxc;
-    GLXContextTag tag = oldContextTag;
-    WindowPtr pWin = NULL;
-    WindowPtr pReadWin = NULL;
-    __glXWindow *pGlxWindow = NULL;
-    __glXWindow *pGlxReadWindow = NULL;
-    __glXPbuffer *pGlxPbuffer = NULL;
-    __glXPbuffer *pGlxReadPbuffer = NULL;
-#ifdef PANORAMIX
-    PanoramiXRes *pXinDraw = NULL;
-    PanoramiXRes *pXinReadDraw = NULL;
-#endif
-    int from_screen = 0;
-    int to_screen = 0;
-    int s, rc;
-
-    /*
-    ** If one is None and the other isn't, it's a bad match.
-    */
-    if ((drawId == None && contextId != None) ||
-	(drawId != None && contextId == None)) {
-	return BadMatch;
-    }
-    
-    /*
-    ** Lookup old context.  If we have one, it must be in a usable state.
-    */
-    if (tag != 0) {
-	prevglxc = __glXLookupContextByTag(cl, tag);
-	if (!prevglxc) {
-	    /*
-	    ** Tag for previous context is invalid.
-	    */
-	    return __glXBadContextTag;
-	}
-    } else {
-	prevglxc = 0;
-    }
-
-    /*
-    ** Lookup new context.  It must not be current for someone else.
-    */
-    if (contextId != None) {
-	dixLookupResourceByType((pointer*) &glxc, contextId, __glXContextRes,
-				NullClient, DixUnknownAccess);
-	if (!glxc) {
-	    client->errorValue = contextId;
-	    return __glXBadContext;
-	}
-	if ((glxc != prevglxc) && glxc->isCurrent) {
-	    /* Context is current to somebody else */
-	    return BadAccess;
-	}
-    } else {
-	/* Switching to no context.  Ignore new drawable. */
-	glxc = 0;
-    }
-
-    if (drawId != None) {
-	rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
-	if (rc == Success) {
-	    if (pDraw->type == DRAWABLE_WINDOW) {
-		/*
-		** Drawable is an X Window.
-		*/
-	        VisualID vid;
-		pWin = (WindowPtr)pDraw;
-		vid = wVisual(pWin);
-
-		new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
-		new_reply.writeType = GLX_WINDOW_TYPE;
-
-		/*
-		** Check if window and context are similar.
-		*/
-		if ((vid != glxc->pVisual->vid) ||
-		    (pWin->drawable.pScreen != glxc->pScreen)) {
-		    client->errorValue = drawId;
-		    return BadMatch;
-		}
-
-		from_screen = to_screen = pWin->drawable.pScreen->myNum;
-
-	    } else {
-		/*
-		** An X Pixmap is not allowed as a parameter (a GLX Pixmap
-		** is, but it must first be created with glxCreateGLXPixmap).
-		*/
-		client->errorValue = drawId;
-		return __glXBadDrawable;
-	    }
-	}
-
-        if (!pDraw) {
-	    dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
-				    __glXPixmapRes, NullClient,
-				    DixUnknownAccess);
-	    if (pGlxPixmap) {
-		/*
-		** Check if pixmap and context are similar.
-		*/
-		if (pGlxPixmap->pScreen != glxc->pScreen ||
-		    pGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
-		    client->errorValue = drawId;
-		    return BadMatch;
-		}
-		pDraw = pGlxPixmap->pDraw;
-
-		new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : 
-		                      pGlxPixmap->pGlxVisual->vid);
-
-		new_reply.writeType = GLX_PIXMAP_TYPE;
-
-		from_screen = to_screen = pGlxPixmap->pScreen->myNum;
-
-	    }
-	}
-
-	if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	   dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
-                                   __glXWindowRes, NullClient,
-                                   DixUnknownAccess);
-            if (pGlxWindow) {
-                /*
-                ** Drawable is a GLXWindow.
-                **
-                ** Check if GLX window and context are similar.
-                */
-                if (pGlxWindow->pScreen != glxc->pScreen ||
-                    pGlxWindow->pGlxFBConfig != glxc->pFBConfig) {
-                    client->errorValue = drawId;
-                    return BadMatch;
-                }
-
-                pDraw = pGlxWindow->pDraw;
-                new_reply.writeVid = pGlxWindow->pGlxFBConfig->id;
-                new_reply.writeType = GLX_GLXWINDOW_TYPE;
-            }
-
-	}
-
-	if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	   dixLookupResourceByType((pointer*) &pGlxPbuffer, drawId,
-                                   __glXPbufferRes, NullClient,
-                                   DixUnknownAccess);
-	   if (pGlxPbuffer) {
-                if (pGlxPbuffer->pScreen != glxc->pScreen ||
-                    pGlxPbuffer->pFBConfig != glxc->pFBConfig) {
-                    client->errorValue = drawId;
-                    return BadMatch;
-                }
-
-		pDraw = (DrawablePtr)pGlxPbuffer;
-                new_reply.writeVid = pGlxPbuffer->pFBConfig->id;
-                new_reply.writeType = GLX_PBUFFER_TYPE;
-	   }
-	}
-
-	if (!pDraw) {
-	   /*
-    	    ** Drawable is not a Window , GLXWindow or a GLXPixmap.
-	    */
-	   client->errorValue = drawId;
-	   return __glXBadDrawable;
-	}
-
-    } else {
-	pDraw = 0;
-    }
-
-    if (readId != None && readId != drawId ) {
-	rc = dixLookupDrawable(&pReadDraw, readId, client, 0, DixReadAccess);
-	if (rc == Success) {
-	    if (pReadDraw->type == DRAWABLE_WINDOW) {
-		/*
-		** Drawable is an X Window.
-		*/
-	        VisualID vid;
-		pReadWin = (WindowPtr)pDraw;
-		vid = wVisual(pReadWin);
-
-		new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
-		new_reply.readType = GLX_WINDOW_TYPE;
-
-		/*
-		** Check if window and context are similar.
-		*/
-		if ((vid != glxc->pVisual->vid) ||
-		    (pReadWin->drawable.pScreen != glxc->pScreen)) {
-		    client->errorValue = readId;
-		    return BadMatch;
-		}
-
-	    } else {
-
-		/*
-		** An X Pixmap is not allowed as a parameter (a GLX Pixmap
-		** is, but it must first be created with glxCreateGLXPixmap).
-		*/
-		client->errorValue = readId;
-		return __glXBadDrawable;
-	    }
-	}
-
-	if (!pReadDraw) {
-	    dixLookupResourceByType((pointer*) &pReadGlxPixmap, readId,
-				    __glXPixmapRes, NullClient,
-				    DixUnknownAccess);
-	    if (pReadGlxPixmap) {
-		/*
-		** Check if pixmap and context are similar.
-		*/
-		if (pReadGlxPixmap->pScreen != glxc->pScreen ||
-		    pReadGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
-		    client->errorValue = readId;
-		    return BadMatch;
-		}
-		pReadDraw = pReadGlxPixmap->pDraw;
-
-		new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id :
-		                     pReadGlxPixmap->pGlxVisual->vid );
-		new_reply.readType = GLX_PIXMAP_TYPE;
-
-	    }
-	}
-
-	if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	   dixLookupResourceByType((pointer*) &pGlxReadWindow, readId,
-                                   __glXWindowRes, NullClient,
-                                   DixUnknownAccess);
-            if (pGlxReadWindow) {
-                /*
-                ** Drawable is a GLXWindow.
-                **
-                ** Check if GLX window and context are similar.
-                */
-                if (pGlxReadWindow->pScreen != glxc->pScreen ||
-                    pGlxReadWindow->pGlxFBConfig != glxc->pFBConfig) {
-                    client->errorValue = readId;
-                    return BadMatch;
-                }
-
-                pReadDraw = pGlxReadWindow->pDraw;
-                new_reply.readVid = pGlxReadWindow->pGlxFBConfig->id;
-                new_reply.readType = GLX_GLXWINDOW_TYPE;
-            }
-	}
-
-	if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	   dixLookupResourceByType((pointer*) &pGlxReadPbuffer, readId,
-                                   __glXPbufferRes, NullClient,
-                                   DixUnknownAccess);
-	   if (pGlxReadPbuffer) {
-                if (pGlxReadPbuffer->pScreen != glxc->pScreen ||
-                    pGlxReadPbuffer->pFBConfig != glxc->pFBConfig) {
-                    client->errorValue = drawId;
-                    return BadMatch;
-                }
-
-		pReadDraw = (DrawablePtr)pGlxReadPbuffer;
-                new_reply.readVid = pGlxReadPbuffer->pFBConfig->id;
-                new_reply.readType = GLX_PBUFFER_TYPE;
-	   }
-	}
-
-	if (!pReadDraw) {
-	   /*
-    	    ** Drawable is neither a Window nor a GLXPixmap.
-	    */
-	   client->errorValue = readId;
-	   return __glXBadDrawable;
-	}
-
-    } else {
-	pReadDraw = pDraw;
-	pReadGlxPixmap = pGlxPixmap;
-	pReadWin = pWin;
-	new_reply.readVid = new_reply.writeVid;
-	new_reply.readType = new_reply.writeType;
-    }
-
-    if (prevglxc) {
-
-	if (prevglxc->pGlxPixmap) {
-	    /*
-	    ** The previous drawable was a glx pixmap, release it.
-	    */
-	    prevglxc->pGlxPixmap->refcnt--;
-	    __glXFreeGLXPixmap( prevglxc->pGlxPixmap );
-	    prevglxc->pGlxPixmap = 0;
-	}
-
-	if (prevglxc->pGlxReadPixmap) {
-	    /*
-	    ** The previous drawable was a glx pixmap, release it.
-	    */
-	    prevglxc->pGlxReadPixmap->refcnt--;
-	    __glXFreeGLXPixmap( prevglxc->pGlxReadPixmap );
-	    prevglxc->pGlxReadPixmap = 0;
-	}
-
-	if (prevglxc->pGlxWindow) {
-	    /*
-	    ** The previous drawable was a glx window, release it.
-	    */
-	    prevglxc->pGlxWindow->refcnt--;
-	    __glXFreeGLXWindow( prevglxc->pGlxWindow );
-	    prevglxc->pGlxWindow = 0;   
-	}
-
-	if (prevglxc->pGlxReadWindow) {
-	    /*
-	    ** The previous drawable was a glx window, release it.
-	    */
-	    prevglxc->pGlxReadWindow->refcnt--;
-	    __glXFreeGLXWindow( prevglxc->pGlxReadWindow );
-	    prevglxc->pGlxReadWindow = 0;   
-	}
-
-	if (prevglxc->pGlxPbuffer) {
-	    /*
-	    ** The previous drawable was a glx Pbuffer, release it.
-	    */
-	    prevglxc->pGlxPbuffer->refcnt--;
-	    __glXFreeGLXPbuffer( prevglxc->pGlxPbuffer );
-	    prevglxc->pGlxPbuffer = 0;   
-	}
-
-	if (prevglxc->pGlxReadPbuffer) {
-	    /*
-	    ** The previous drawable was a glx Pbuffer, release it.
-	    */
-	    prevglxc->pGlxReadPbuffer->refcnt--;
-	    __glXFreeGLXPbuffer( prevglxc->pGlxReadPbuffer );
-	    prevglxc->pGlxReadPbuffer = 0;   
-	}
-
-	ChangeCurrentContext(cl, glxc, tag);
-	ChangeCurrentContext(cl, glxc, tag);
-	StopUsingContext(prevglxc);
-    } else {
-	tag = AddCurrentContext(cl, glxc, pDraw);
-    }
-    if (glxc) {
-
-       glxc->pGlxPixmap = pGlxPixmap;
-       glxc->pGlxReadPixmap = pReadGlxPixmap;
-       glxc->pGlxWindow = pGlxWindow;
-       glxc->pGlxReadWindow = pGlxReadWindow;
-       glxc->pGlxPbuffer = pGlxPbuffer;
-       glxc->pGlxReadPbuffer = pGlxReadPbuffer;
-
-	if (pGlxPixmap) {
-	    pGlxPixmap->refcnt++;
-	}
-
-	if (pReadGlxPixmap) {
-	    pReadGlxPixmap->refcnt++;
-	}
-
-	if (pGlxWindow) {
-	   pGlxWindow->refcnt++;
-	}
-
-	if (pGlxReadWindow) {
-	   pGlxReadWindow->refcnt++;
-	}
-
-	if (pGlxPbuffer) {
-	   pGlxPbuffer->refcnt++;
-	}
-
-	if (pGlxReadPbuffer) {
-	   pGlxReadPbuffer->refcnt++;
-	}
-
-	StartUsingContext(cl, glxc);
-	new_reply.contextTag = tag;
-    } else {
-	new_reply.contextTag = 0;
-    }
-    new_reply.length = 0;
-    new_reply.type = X_Reply;
-    new_reply.sequenceNumber = client->sequence;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-
-       if (pDraw && new_reply.writeType != GLX_PBUFFER_TYPE) {
-	  dixLookupResourceByClass((pointer*) &pXinDraw,
-				   pDraw->id, XRC_DRAWABLE,
-				   client, DixReadAccess);
-       }
-
-       if (pReadDraw && pReadDraw != pDraw && 
-	     new_reply.readType != GLX_PBUFFER_TYPE) {
-	  dixLookupResourceByClass((pointer*) &pXinReadDraw,
-				   pReadDraw->id, XRC_DRAWABLE,
-				   client, DixReadAccess);
-       }
-       else {
-	  pXinReadDraw = pXinDraw;
-       }
-    }
-#endif
-
-
-    /* send the MakeCurrent request to all required
-     * back-end servers.
-     */
-    for (s = from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-       unsigned int be_draw = None;
-       unsigned int be_read_draw = None;
-
-       if (pGlxPixmap) {
-	   be_draw = pGlxPixmap->be_xids[s];
-       }
-       else if (pGlxPbuffer) {
-	  be_draw = pGlxPbuffer->be_xids[s];
-       }
-#ifdef PANORAMIX
-       else if (pXinDraw) {
-	  dixLookupWindow(&pWin, pXinDraw->info[s].id, client, DixReadAccess);
-       }
-#endif
-       else if (pGlxWindow) {
-	  pWin = (WindowPtr)pGlxWindow->pDraw;
-       }
-
-       if (pWin && be_draw == None) {
-	   be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   if (!be_draw) {
-	      /* it might be that the window did not created yet on the */
-	      /* back-end server (lazy window creation option), force   */
-	      /* creation of the window */
-	      dmxCreateAndRealizeWindow( pWin, TRUE );
-	      be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   }
-       }
-
-       /*
-	* Before sending the MakeCurrent request - sync the
-	* X11 connection to the back-end servers to make sure
-	* that drawable is already created
-	*/
-       dmxSync( dmxScreen, 1 ); 
-
-       if (drawId == readId) {
-	  LockDisplay(dpy);
-	  GetReq(GLXMakeCurrent, be_req);
-	  be_req->reqType = dmxScreen->glxMajorOpcode;
-	  be_req->glxCode = X_GLXMakeCurrent;
-	  be_req->drawable = be_draw;
-	  be_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
-	  be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
-	  if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) {
-
-	     /* The make current failed */
-	     UnlockDisplay(dpy);
-	     SyncHandle();
-	     return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
-	  }
-
-	  UnlockDisplay(dpy);
-       	  SyncHandle();
-
-	  SetCurrentBackEndTag( cl, tag, s, be_reply.contextTag );
-       }
-       else {
-
-	  if (pReadGlxPixmap) {
-	     be_read_draw = pReadGlxPixmap->be_xids[s];
-	  }
-	  else if (pGlxReadPbuffer) {
-	     be_read_draw = pGlxReadPbuffer->be_xids[s];
-	  }
-#ifdef PANORAMIX
-	  else if (pXinReadDraw) {
-	     dixLookupWindow(&pReadWin, pXinReadDraw->info[s].id, client,
-			     DixReadAccess);
-   	  }
-#endif
-	  else if (pGlxReadWindow) {
-	     pReadWin = (WindowPtr)pGlxReadWindow->pDraw;
-	  }
-
-      	  if (pReadWin && be_read_draw == None) {
-  	     be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
-	   if (!be_read_draw) {
-	      /* it might be that the window did not created yet on the */
-	      /* back-end server (lazy window creation option), force   */
-	      /* creation of the window */
-	      dmxCreateAndRealizeWindow( pReadWin, TRUE );
-	      be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
-              dmxSync( dmxScreen, 1 ); 
-	   }
-     	  }
-
-	  if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-	     LockDisplay(dpy);
-	     GetReq(GLXMakeContextCurrent, be_new_req);
-	     be_new_req->reqType = dmxScreen->glxMajorOpcode;
-	     be_new_req->glxCode = X_GLXMakeContextCurrent;
-	     be_new_req->drawable = be_draw;
-	     be_new_req->readdrawable = be_read_draw;
-	     be_new_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
-	     be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
-	     if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) {
-
-		/* The make current failed */
-		UnlockDisplay(dpy);
-   		SyncHandle();
-   		return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
-   	     }
-
-   	     UnlockDisplay(dpy);
-      	     SyncHandle();
-
-   	     SetCurrentBackEndTag( cl, tag, s, be_new_reply.contextTag );
-	  }
-	  else if (glxIsExtensionSupported("GLX_SGI_make_current_read")) {
-	     xGLXMakeCurrentReadSGIReq *ext_req;
-	     xGLXVendorPrivateWithReplyReq *vpreq;
-             xGLXMakeCurrentReadSGIReply ext_reply;
-
-	     LockDisplay(dpy);
-	     GetReqExtra(GLXVendorPrivateWithReply, 
-		         sz_xGLXMakeCurrentReadSGIReq - sz_xGLXVendorPrivateWithReplyReq,
-		         vpreq);
-	     ext_req = (xGLXMakeCurrentReadSGIReq *)vpreq;
-	     ext_req->reqType = dmxScreen->glxMajorOpcode;
-	     ext_req->glxCode = X_GLXVendorPrivateWithReply;
-	     ext_req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
-	     ext_req->drawable = be_draw;
-	     ext_req->readable = be_read_draw;
-	     ext_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
-	     ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
-	     if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) {
-
-		/* The make current failed */
-		UnlockDisplay(dpy);
-   		SyncHandle();
-   		return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
-   	     }
-
-   	     UnlockDisplay(dpy);
-      	     SyncHandle();
-
-   	     SetCurrentBackEndTag( cl, tag, s, ext_reply.contextTag );
-
-	  }
-	  else {
-	     return BadMatch;
-	  }
-       }
-
-       XFlush( dpy );
-    }
-
-    if (client->swapped) {
-	__glXSwapMakeCurrentReply(client, &new_reply);
-    } else {
-	WriteToClient(client, sz_xGLXMakeContextCurrentReply, (char *)&new_reply);
-    }
-
-    return Success;
-}
-
-int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
-
-    return( MakeCurrent(cl, req->drawable, req->drawable,
-	                req->context, req->oldContextTag ) );
-}
-
-int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
-
-    return( MakeCurrent(cl, req->drawable, req->readdrawable,
-	                req->context, req->oldContextTag ) );
-}
-
-int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
-
-    return( MakeCurrent(cl, req->drawable, req->readable,
-	                req->context, req->oldContextTag ) );
-}
-
-int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
-    xGLXIsDirectReply reply;
-    __GLXcontext *glxc;
-
-    /*
-    ** Find the GL context.
-    */
-    dixLookupResourceByType((pointer*) &glxc, req->context, __glXContextRes,
-                            NullClient, DixUnknownAccess);
-    if (!glxc) {
-	client->errorValue = req->context;
-	return __glXBadContext;
-    }
-
-    reply.isDirect = 0;
-    reply.length = 0;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    if (client->swapped) {
-	__glXSwapIsDirectReply(client, &reply);
-    } else {
-	WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
-    }
-
-    return Success;
-}
-
-int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-/*    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; */
-    xGLXQueryVersionReply reply;
-
-    /*
-    ** Server should take into consideration the version numbers sent by the
-    ** client if it wants to work with older clients; however, in this
-    ** implementation the server just returns its version number.
-    */
-    reply.majorVersion = __glXVersionMajor;
-    reply.minorVersion = __glXVersionMinor;
-    reply.length = 0;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    if (client->swapped) {
-	__glXSwapQueryVersionReply(client, &reply);
-    } else {
-	WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
-    }
-    return Success;
-}
-
-int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
-    xGLXWaitGLReq *be_req = (xGLXWaitGLReq *)pc;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-    __GLXcontext *glxc = NULL;
-    
-    if (req->contextTag != 0) {
-	glxc = __glXLookupContextByTag(cl, req->contextTag);
-	if (glxc) {
-	   from_screen = to_screen = glxc->pScreen->myNum;
-	}
-    }
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReq(GLXWaitGL,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXWaitGL;
-       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       XSync(dpy, False);
-    }
-    
-    return Success;
-}
-
-int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
-    xGLXWaitXReq *be_req;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-    __GLXcontext *glxc = NULL;
-    
-    if (req->contextTag != 0) {
-	glxc = __glXLookupContextByTag(cl, req->contextTag);
-	if (glxc) {
-	   from_screen = to_screen = glxc->pScreen->myNum;
-	}
-    }
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       dmxSync( dmxScreen, 1 );
-
-       LockDisplay(dpy);
-       GetReq(GLXWaitX,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXWaitX;
-       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       XFlush( dpy );
-    }
-
-    return Success;
-}
-
-int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXCopyContextReq *be_req;
-    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
-    GLXContextID source = req->source;
-    GLXContextID dest = req->dest;
-    GLXContextTag tag = req->contextTag;
-    unsigned long mask = req->mask;
-    __GLXcontext *src, *dst;
-    int s;
-    int from_screen = 0;
-    int to_screen = 0;
-
-    /*
-    ** Check that each context exists.
-    */
-    dixLookupResourceByType((pointer*) &src, source, __glXContextRes,
-                            NullClient, DixUnknownAccess);
-    if (!src) {
-	client->errorValue = source;
-	return __glXBadContext;
-    }
-    dixLookupResourceByType((pointer*) &dst, dest, __glXContextRes,
-                            NullClient, DixUnknownAccess);
-    if (!dst) {
-	client->errorValue = dest;
-	return __glXBadContext;
-    }
-
-    /*
-    ** They must be in the same address space, and same screen.
-    */
-    if (src->pGlxScreen != dst->pGlxScreen) {
-	client->errorValue = source;
-	return BadMatch;
-    }
-
-    /*
-    ** The destination context must not be current for any client.
-    */
-    if (dst->isCurrent) {
-	client->errorValue = dest;
-	return BadAccess;
-    }
-
-    if (tag) {
-	__GLXcontext *tagcx = __glXLookupContextByTag(cl, tag);
-	
-	if (!tagcx) {
-	    return __glXBadContextTag;
-	}
-	if (tagcx != src) {
-	    /*
-	    ** This would be caused by a faulty implementation of the client
-	    ** library.
-	    */
-	    return BadMatch;
-	}
-    }
-
-    from_screen = to_screen = src->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReq(GLXCopyContext,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXCopyContext;
-       be_req->source = (unsigned int)src->real_ids[s-from_screen];
-       be_req->dest = (unsigned int)dst->real_ids[s-from_screen];
-       be_req->mask = mask;
-       be_req->contextTag = (tag ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    return Success;
-}
-
-int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
-    xGLXGetVisualConfigsReply reply;
-    __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
-    CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
-    int i, p;
-
-    screen = req->screen;
-    if (screen >= screenInfo.numScreens) {
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
-    }
-    pGlxScreen = &__glXActiveScreens[screen];
-
-    reply.numVisuals = pGlxScreen->numGLXVisuals;
-    reply.numProps = __GLX_TOTAL_CONFIG;
-    reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
-		    __GLX_TOTAL_CONFIG) >> 2;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
-
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
-	    /* not a usable visual */
-	    continue;
-	}
-	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
-	/* 
-	** Add token/value pairs for extensions.
-	*/
-	buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-	buf[p++] = pGlxVisual->visualRating;
-	buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-	buf[p++] = pGlxVisual->transparentPixel;
-	buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentRed;
-	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentGreen;
-	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentBlue;
-	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentAlpha;
-	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-	buf[p++] = pGlxVisual->transparentIndex;
-	buf[p++] = GLX_SAMPLES_SGIS;
-	buf[p++] = pGlxVisual->multiSampleSize;
-	buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
-	buf[p++] = pGlxVisual->nMultiSampleBuffers;
-	buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
-	buf[p++] = pGlxVisual->visualSelectGroup;
-
-	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
-		(char *)buf);
-    }
-    return Success;
-}
-
-/*
-** Create a GLX Pixmap from an X Pixmap.
-*/
-static int CreateGLXPixmap(__GLXclientState *cl,
-                    VisualID visual, GLXFBConfigID fbconfigId,
-		    int screenNum, XID pixmapId, XID glxpixmapId )
-{
-    ClientPtr client = cl->client;
-    xGLXCreateGLXPixmapReq *be_req;
-    xGLXCreatePixmapReq *be_new_req;
-    DrawablePtr pDraw;
-    ScreenPtr pScreen;
-    VisualPtr pVisual;
-    __GLXpixmap *pGlxPixmap;
-    __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
-    __GLXFBConfig *pFBConfig;
-    int i, s, rc;
-    int from_screen, to_screen;
-#ifdef PANORAMIX
-    PanoramiXRes *pXinDraw = NULL;
-#endif
-
-    rc = dixLookupDrawable(&pDraw, pixmapId, client, M_DRAWABLE_PIXMAP,
-			   DixAddAccess);
-    if (rc != Success)
-	return rc;
-
-    /*
-    ** Check if screen of visual matches screen of pixmap.
-    */
-    pScreen = pDraw->pScreen;
-    if (screenNum != pScreen->myNum) {
-	return BadMatch;
-    }
-
-    if (fbconfigId == 0 && visual == 0) {
-	  return BadValue;
-    }
-
-    if (fbconfigId != None) {
-       pFBConfig = glxLookupFBConfig( fbconfigId );
-       if (!pFBConfig) {
-	  client->errorValue = fbconfigId;
-	  return BadValue;
-       }
-       visual = pFBConfig->associatedVisualId;
-    }
-    else {
-       pFBConfig = NULL;
-    }
-
-    if (visual != None) {
-       /*
-	** Find the VisualRec for this visual.
-	*/
-       pVisual = pScreen->visuals;
-       for (i=0; i < pScreen->numVisuals; i++, pVisual++) {
-	  if (pVisual->vid == visual) {
-	     break;
-	  }
-       }
-       if (i == pScreen->numVisuals) {
-	  client->errorValue = visual;
-	  return BadValue;
-       }
-       /*
-	** Check if depth of visual matches depth of pixmap.
-	*/
-       if (pVisual->nplanes != pDraw->depth) {
-	  client->errorValue = visual;
-	  return BadMatch;
-       }
-
-       /*
-	** Get configuration of the visual.
-	*/
-       pGlxScreen = &__glXActiveScreens[screenNum];
-       pGlxVisual = pGlxScreen->pGlxVisual;
-       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
-	  if (pGlxVisual->vid == visual) {
-	     break;
-	  }
-       }
-       if (i == pGlxScreen->numVisuals) {
-	  /*
-	   ** Visual not support on this screen by this OpenGL implementation.
-	   */
-	  client->errorValue = visual;
-	  return BadValue;
-       }
-
-
-       /* find the FBConfig for that visual (if any) */
-       if ( pFBConfig == NULL ) {
-	   pFBConfig = glxLookupFBConfigByVID( visual );
-
-	   if ( pFBConfig == NULL ) {
-	      /*
-               * visual does not have an FBConfig ???
-	      client->errorValue = visual;
-	      return BadValue;
-	       */
-	   }
-       }
-    }
-    else {
-       pVisual = NULL;
-       pGlxVisual = NULL;
-       pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
-    }
-
-    pGlxPixmap = (__GLXpixmap *) malloc(sizeof(__GLXpixmap));
-    if (!pGlxPixmap) {
-	return BadAlloc;
-    }
-    pGlxPixmap->be_xids = (XID *) malloc(sizeof(XID) * screenInfo.numScreens);
-    if (!pGlxPixmap->be_xids) {
-        free( pGlxPixmap );
-	return BadAlloc;
-    }
-
-    pGlxPixmap->pDraw = pDraw;
-    pGlxPixmap->pGlxScreen = pGlxScreen;
-    pGlxPixmap->pGlxVisual = pGlxVisual;
-    pGlxPixmap->pFBConfig = pFBConfig;
-    pGlxPixmap->pScreen = pScreen;
-    pGlxPixmap->idExists = True;
-    pGlxPixmap->refcnt = 0;
-
-    /*
-    ** Bump the ref count on the X pixmap so it won't disappear.
-    */
-    ((PixmapPtr) pDraw)->refcnt++;
-
-    /*
-     * send the request to the back-end server(s)
-     */
-    from_screen = to_screen = screenNum;
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-
-       dixLookupResourceByClass((pointer*) &pXinDraw,
-				pDraw->id, XRC_DRAWABLE,
-				client, DixReadAccess);
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-       Pixmap  be_pixmap;
-       DrawablePtr pRealDraw = pDraw;
-
-#ifdef PANORAMIX
-       if (pXinDraw) {
-	   dixLookupDrawable(&pRealDraw, pXinDraw->info[s].id, client, 0,
-			     DixAddAccess);
-       }
-#endif
-
-       be_pixmap = (DMX_GET_PIXMAP_PRIV((PixmapPtr)pRealDraw))->pixmap;
-
-       /* make sure pixmap already created on back-end */
-       dmxSync( dmxScreen, 1 );
-
-       if ( pFBConfig && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-       	  __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
-	  
-	  LockDisplay(dpy);
-	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
-	  GetReq(GLXCreatePixmap,be_new_req);
-	  be_new_req->reqType = dmxScreen->glxMajorOpcode;
-	  be_new_req->glxCode = X_GLXCreatePixmap;
-	  be_new_req->screen = DefaultScreen(dpy);
-	  be_new_req->fbconfig = be_FBConfig->id;
-	  be_new_req->pixmap = (unsigned int)be_pixmap;
-	  be_new_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
-	  be_new_req->numAttribs = 0;
-	  UnlockDisplay(dpy);
-	  SyncHandle();
-       }
-       else if (pFBConfig && glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
-	  __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
-	  xGLXCreateGLXPixmapWithConfigSGIXReq *ext_req;
-	  xGLXVendorPrivateReq *vpreq;
-	  
-	  LockDisplay(dpy);
-	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
-	  GetReqExtra(GLXVendorPrivate,
-		      sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateReq,
-		      vpreq);
-	  ext_req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
-	  ext_req->reqType = dmxScreen->glxMajorOpcode;
-	  ext_req->glxCode = X_GLXVendorPrivate;
-	  ext_req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
-	  ext_req->screen = DefaultScreen(dpy);
-	  ext_req->fbconfig = be_FBConfig->id;
-	  ext_req->pixmap = (unsigned int)be_pixmap;
-	  ext_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
-	  UnlockDisplay(dpy);
-	  SyncHandle();
-       }
-       else if (pGlxVisual) {
-	  LockDisplay(dpy);
-	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
-	  GetReq(GLXCreateGLXPixmap,be_req);
-	  be_req->reqType = dmxScreen->glxMajorOpcode;
-	  be_req->glxCode = X_GLXCreateGLXPixmap;
-	  be_req->screen = DefaultScreen(dpy);
-	  be_req->visual = (unsigned int)glxMatchGLXVisualInConfigList( 
-	 	pGlxVisual,
-		dmxScreen->glxVisuals,
-		dmxScreen->numGlxVisuals );
-   	  be_req->pixmap = (unsigned int)be_pixmap;
-      	  be_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
-	  UnlockDisplay(dpy);
-	  SyncHandle();
-       }
-       else {
-	  client->errorValue = ( visual ? visual : fbconfigId );
-          free( pGlxPixmap );
-	  return BadValue;
-       }
-
-       XFlush( dpy );
-    }
-
-    if (!(AddResource(glxpixmapId, __glXPixmapRes, pGlxPixmap))) {
-        free( pGlxPixmap );
-	return BadAlloc;
-    }
-
-    return Success;
-}
-
-int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
-
-    return( CreateGLXPixmap(cl, req->visual, None,
-	                    req->screen, req->pixmap, req->glxpixmap) );
-}
-
-int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
-
-    return( CreateGLXPixmap(cl, None, req->fbconfig,
-	                    req->screen, req->pixmap, req->glxpixmap) );
-}
-
-int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
-    XID glxpixmap = req->glxpixmap;
-    __GLXpixmap *pGlxPixmap;
-    int s;
-    int from_screen, to_screen;
-
-    /*
-    ** Check if it's a valid GLX pixmap.
-    */
-    dixLookupResourceByType((pointer*) &pGlxPixmap, glxpixmap,
-                            __glXPixmapRes, NullClient, DixUnknownAccess);
-    if (!pGlxPixmap) {
-	client->errorValue = glxpixmap;
-	return __glXBadPixmap;
-    }
-    FreeResource(glxpixmap, FALSE);
-
-    /*
-     * destroy the pixmap on the back-end server(s).
-     */
-    from_screen = to_screen = pGlxPixmap->pDraw->pScreen->myNum;
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       /* make sure pixmap exist in back-end */
-       dmxSync( dmxScreen, 1 );
-
-       LockDisplay(dpy);
-       GetReq(GLXDestroyGLXPixmap,req);
-       req->reqType = dmxScreen->glxMajorOpcode;
-       req->glxCode = X_GLXDestroyGLXPixmap;
-       req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    
-    return Success;
-}
-
-/*****************************************************************************/
-
-/*
-** NOTE: There is no portable implementation for swap buffers as of
-** this time that is of value.  Consequently, this code must be
-** implemented by somebody other than SGI.
-*/
-int __glXDoSwapBuffers(__GLXclientState *cl, XID drawId, GLXContextTag tag)
-{
-    ClientPtr client = cl->client;
-    DrawablePtr pDraw;
-    xGLXSwapBuffersReq *be_req;
-    WindowPtr pWin = NULL;
-    __GLXpixmap *pGlxPixmap = NULL;
-    __GLXcontext *glxc = NULL;
-#ifdef PANORAMIX
-    PanoramiXRes *pXinDraw = NULL;
-#endif
-    __glXWindow *pGlxWindow = NULL;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s, rc;
-    
-    /*
-    ** Check that the GLX drawable is valid.
-    */
-    rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
-    if (rc == Success) {
-        from_screen = to_screen = pDraw->pScreen->myNum;
-
-	if (pDraw->type == DRAWABLE_WINDOW) {
-	    /*
-	    ** Drawable is an X window.
-	    */
-	   pWin = (WindowPtr)pDraw;
-	} else {
-	    /*
-	    ** Drawable is an X pixmap, which is not allowed.
-	    */
-	    client->errorValue = drawId;
-	    return __glXBadDrawable;
-	}
-    } 
-
-    if (!pDraw) {
-	dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
-				__glXPixmapRes, NullClient, DixUnknownAccess);
-	if (pGlxPixmap) {
-	    /*
-	    ** Drawable is a GLX pixmap.
-	    */
-	   pDraw = pGlxPixmap->pDraw;
-	   from_screen = to_screen = pGlxPixmap->pScreen->myNum;
-	}
-    }
-
-    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-       dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
-                               __glXWindowRes, NullClient, DixUnknownAccess);
-       if (pGlxWindow) {
-	  /*
-	   ** Drawable is a GLXWindow.
-	   */
-	  pDraw = pGlxWindow->pDraw;
-	  from_screen = to_screen = pGlxWindow->pScreen->myNum;
-       }
-    }
-
-    if (!pDraw) {
-       /*
-	** Drawable is neither a X window nor a GLX pixmap.
-	*/
-       client->errorValue = drawId;
-       return __glXBadDrawable;
-    }
-
-    if (tag) {
-	glxc = __glXLookupContextByTag(cl, tag);
-	if (!glxc) {
-	    return __glXBadContextTag;
-	}
-    }
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-       dixLookupResourceByClass((pointer*) &pXinDraw,
-				pDraw->id, XRC_DRAWABLE,
-				client, DixReadAccess);
-    }
-#endif
-
-    /* If requested, send a glFinish to all back-end servers before swapping. */
-    if (dmxGLXFinishSwap) {
-	for (s=from_screen; s<=to_screen; s++) {
-	    Display *dpy = GetBackEndDisplay(cl,s);
-	    DMXScreenInfo *dmxScreen = &dmxScreens[s];
-	    xGLXSingleReq *finishReq;
-	    xGLXSingleReply reply;
-
-#define X_GLXSingle 0    /* needed by GetReq below */
-
-	    LockDisplay(dpy);
-	    GetReq(GLXSingle,finishReq);
-	    finishReq->reqType = dmxScreen->glxMajorOpcode;
-	    finishReq->glxCode = X_GLsop_Finish;
-	    finishReq->contextTag = (tag ? GetCurrentBackEndTag(cl,tag,s) : 0);
-	    (void) _XReply(dpy, (xReply*) &reply, 0, False);
-	    UnlockDisplay(dpy);
-	    SyncHandle();
-	}
-    }
-
-    /* If requested, send an XSync to all back-end servers before swapping. */
-    if (dmxGLXSyncSwap) {
-	for (s=from_screen; s<=to_screen; s++)
-	    XSync(GetBackEndDisplay(cl,s), False);
-    }
-
-
-    /* send the SwapBuffers request to all back-end servers */
-
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-       unsigned int be_draw = 0;
-
-       if (pGlxPixmap) {
-	  be_draw = (unsigned int)pGlxPixmap->be_xids[s];
-       }
-#ifdef PANORAMIX
-       else if (pXinDraw) {
-	  dixLookupWindow(&pWin, pXinDraw->info[s].id, client, DixReadAccess);
-       }
-#endif
-       else if (pGlxWindow) {
-	  pWin = (WindowPtr)pGlxWindow->pDraw;
-       }
-
-       if (pWin && !be_draw) {
-	   be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   if (!be_draw) {
-	      /* it might be that the window did not created yet on the */
-	      /* back-end server (lazy window creation option), force   */
-	      /* creation of the window */
-	      dmxCreateAndRealizeWindow( pWin, TRUE );
-	      be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   }
-       }
-
-       dmxSync( dmxScreen, 1 );
-
-       LockDisplay(dpy);
-       GetReq(GLXSwapBuffers,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXSwapBuffers;
-       be_req->drawable = be_draw;
-       be_req->contextTag = ( tag ? GetCurrentBackEndTag(cl,tag,s) : 0 );
-       UnlockDisplay(dpy);
-       SyncHandle();
-       XFlush(dpy);
-    }
-
-    return Success;
-}
-
-int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    DrawablePtr pDraw;
-    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
-    GLXContextTag tag = req->contextTag;
-    XID drawId = req->drawable;
-    __GLXpixmap *pGlxPixmap = NULL;
-    __GLXcontext *glxc = NULL;
-    __glXWindow *pGlxWindow = NULL;
-    int rc;
-    
-    /*
-    ** Check that the GLX drawable is valid.
-    */
-    rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
-    if (rc == Success) {
-	if (pDraw->type != DRAWABLE_WINDOW) {
-	    /*
-	    ** Drawable is an X pixmap, which is not allowed.
-	    */
-	    client->errorValue = drawId;
-	    return __glXBadDrawable;
-	}
-    } 
-
-    if (!pDraw) {
-	dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
-				__glXPixmapRes, NullClient, DixUnknownAccess);
-	if (pGlxPixmap) {
-	    /*
-	    ** Drawable is a GLX pixmap.
-	    */
-	   pDraw = pGlxPixmap->pDraw;
-	}
-    }
-
-    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
-       dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
-                               __glXWindowRes, NullClient, DixUnknownAccess);
-       if (pGlxWindow) {
-	  /*
-	   ** Drawable is a GLXWindow.
-	   */
-	  pDraw = pGlxWindow->pDraw;
-       }
-    }
-
-    if (!pDraw) {
-       /*
-	** Drawable is neither a X window nor a GLX pixmap.
-	*/
-       client->errorValue = drawId;
-       return __glXBadDrawable;
-    }
-
-    if (tag) {
-	glxc = __glXLookupContextByTag(cl, tag);
-	if (!glxc) {
-	    return __glXBadContextTag;
-	}
-    }
-
-    if (pDraw &&
-	pDraw->type == DRAWABLE_WINDOW &&
-	DMX_GET_WINDOW_PRIV((WindowPtr)pDraw)->swapGroup) {
-	return SGSwapBuffers(cl, drawId, tag, pDraw);
-    }
-
-    return __glXDoSwapBuffers(cl, drawId, tag);
-}
-
-
-/************************************************************************/
-
-/*
-** Render and Renderlarge are not in the GLX API.  They are used by the GLX
-** client library to send batches of GL rendering commands.
-*/
-
-/*
-** Execute all the drawing commands in a request.
-*/
-int __glXRender(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXRenderReq *req;
-    xGLXRenderReq *be_req;
-    int size;
-    __GLXcontext *glxc;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-
-    /*
-    ** NOTE: much of this code also appears in the byteswapping version of this
-    ** routine, __glXSwapRender().  Any changes made here should also be
-    ** duplicated there.
-    */
-    
-    req = (xGLXRenderReq *) pc;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXRenderReq;
-    size = (req->length << 2) - sz_xGLXRenderReq;
-
-    /*
-     * just forward the request to back-end server(s)
-     */
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReq(GLXRender,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXRender;
-       be_req->length = req->length;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       _XSend(dpy, (const char *)pc, size);
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    return Success;
-}
-
-/*
-** Execute a large rendering request (one that spans multiple X requests).
-*/
-int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXRenderLargeReq *req;
-    xGLXRenderLargeReq *be_req;
-    __GLXcontext *glxc;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-
-    /*
-    ** NOTE: much of this code also appears in the byteswapping version of this
-    ** routine, __glXSwapRenderLarge().  Any changes made here should also be
-    ** duplicated there.
-    */
-    
-    req = (xGLXRenderLargeReq *) pc;
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXRenderLargeReq;
-
-    /*
-     * just forward the request to back-end server(s)
-     */
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       GetReq(GLXRenderLarge,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXRenderLarge;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       be_req->length = req->length;
-       be_req->requestNumber = req->requestNumber;
-       be_req->requestTotal = req->requestTotal;
-       be_req->dataBytes = req->dataBytes;
-       Data(dpy, (const char *)pc, req->dataBytes);
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-    }
-
-    return Success;
-}
-
-
-/************************************************************************/
-
-int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq *req;
-
-    req = (xGLXVendorPrivateReq *) pc;
-
-    switch( req->vendorCode ) {
-
-       case X_GLvop_DeleteTexturesEXT:
-	  return __glXVForwardSingleReq( cl, pc );
-	  break;
-
-       case X_GLXvop_SwapIntervalSGI:
-	  if (glxIsExtensionSupported("SGI_swap_control")) {
-	     return __glXVForwardSingleReq( cl, pc );
-	  }
-	  else {
-	     return Success;
-	  }
-	  break;
-
-#if 0 /* glx 1.3 */
-       case X_GLXvop_CreateGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXPbufferSGIX:
-	  break;
-       case X_GLXvop_ChangeDrawableAttributesSGIX:
-	  break;
-#endif
-
-       case X_GLXvop_BindSwapBarrierSGIX:
-	  return __glXBindSwapBarrierSGIX( cl, pc );
-	  break;
-
-       case X_GLXvop_JoinSwapGroupSGIX:
-	  return __glXJoinSwapGroupSGIX( cl, pc );
-	  break;
-
-       case X_GLXvop_CreateContextWithConfigSGIX:
-	  return __glXCreateContextWithConfigSGIX( cl, pc );
-	  break;
-
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
-    }
-
-    cl->client->errorValue = req->vendorCode;
-    return __glXUnsupportedPrivateRequest;
-
-}
-
-int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateWithReplyReq *req;
-
-    req = (xGLXVendorPrivateWithReplyReq *) pc;
-
-    switch( req->vendorCode ) {
-
-       case X_GLvop_GetConvolutionFilterEXT:
-       case X_GLvop_GetConvolutionParameterfvEXT:
-       case X_GLvop_GetConvolutionParameterivEXT:
-       case X_GLvop_GetSeparableFilterEXT:
-       case X_GLvop_GetHistogramEXT:
-       case X_GLvop_GetHistogramParameterivEXT:
-       case X_GLvop_GetMinmaxEXT:
-       case X_GLvop_GetMinmaxParameterfvEXT:
-       case X_GLvop_GetMinmaxParameterivEXT:
-       case X_GLvop_AreTexturesResidentEXT:
-       case X_GLvop_IsTextureEXT:
-	  return( __glXVForwardPipe0WithReply(cl, pc) );
-	  break;
-
-       case X_GLvop_GenTexturesEXT:
-	  return( __glXVForwardAllWithReply(cl, pc) );
-	  break;
-
-
-#if 0 /* glx1.3 */
-       case X_GLvop_GetDetailTexFuncSGIS:
-       case X_GLvop_GetSharpenTexFuncSGIS:
-       case X_GLvop_GetColorTableSGI:
-       case X_GLvop_GetColorTableParameterfvSGI:
-       case X_GLvop_GetColorTableParameterivSGI:
-       case X_GLvop_GetTexFilterFuncSGIS:
-       case X_GLvop_GetInstrumentsSGIX:
-       case X_GLvop_InstrumentsBufferSGIX:
-       case X_GLvop_PollInstrumentsSGIX:
-       case X_GLvop_FlushRasterSGIX:
-       case X_GLXvop_CreateGLXPbufferSGIX:
-       case X_GLXvop_GetDrawableAttributesSGIX:
-       case X_GLXvop_QueryHyperpipeNetworkSGIX:
-       case X_GLXvop_QueryHyperpipeConfigSGIX:
-       case X_GLXvop_HyperpipeConfigSGIX:
-       case X_GLXvop_DestroyHyperpipeConfigSGIX:
-#endif
-       case X_GLXvop_QueryMaxSwapBarriersSGIX:
-	  return( __glXQueryMaxSwapBarriersSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_GetFBConfigsSGIX:
-	  return( __glXGetFBConfigsSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_MakeCurrentReadSGI:
-	  return( __glXMakeCurrentReadSGI(cl, pc) );
-	  break;
-
-       case X_GLXvop_QueryContextInfoEXT:
-	  return( __glXQueryContextInfoEXT(cl,pc) );
-	  break;
-
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
-    }
-
-}
-
-int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
-    xGLXQueryExtensionsStringReply reply;
-    GLint screen;
-    size_t length;
-    int len, numbytes;
-    char *be_buf;
-
-#ifdef FWD_QUERY_REQ
-    xGLXQueryExtensionsStringReq *be_req;
-    xGLXQueryExtensionsStringReply be_reply;
-    DMXScreenInfo *dmxScreen;
-    Display *dpy;
-    int slop;
-#endif
-
-    screen = req->screen;
-
-    /*
-    ** Check if screen exists.
-    */
-    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
-	client->errorValue = screen;
-	return BadValue;
-    }
-
-#ifdef FWD_QUERY_REQ
-    dmxScreen = &dmxScreens[screen];
-
-    /* Send the glXQueryServerString request */
-    dpy = GetBackEndDisplay(cl,screen);
-    LockDisplay(dpy);
-    GetReq(GLXQueryExtensionsString,be_req);
-    be_req->reqType = dmxScreen->glxMajorOpcode;
-    be_req->glxCode = X_GLXQueryServerString;
-    be_req->screen = DefaultScreen(dpy);
-    _XReply(dpy, (xReply*) &be_reply, 0, False);
-    len = (int)be_reply.length;
-    numbytes = (int)be_reply.n;
-    slop = numbytes * __GLX_SIZE_INT8 & 3;
-    be_buf = (char *)malloc(numbytes);
-    if (!be_buf) {
-        /* Throw data on the floor */
-        _XEatData(dpy, len);
-    } else {
-        _XRead(dpy, (char *)be_buf, numbytes);
-        if (slop) _XEatData(dpy,4-slop);
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-#else
-
-    be_buf = __glXGetServerString(GLX_EXTENSIONS);
-    numbytes = strlen(be_buf) + 1;
-    len = __GLX_PAD(numbytes) >> 2;
-
-#endif
-
-    length = len;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = len;
-    reply.n = numbytes;
-
-    if (client->swapped) {
-        glxSwapQueryExtensionsStringReply(client, &reply, be_buf);
-    } else {
-        WriteToClient(client, sz_xGLXQueryExtensionsStringReply,(char *)&reply);
-        WriteToClient(client, (int)(length << 2), (char *)be_buf);
-    }
-
-    return Success;
-}
-
-int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
-    xGLXQueryServerStringReply reply;
-    int name;
-    GLint screen;
-    size_t length;
-    int len, numbytes;
-    char *be_buf;
-#ifdef FWD_QUERY_REQ
-    xGLXQueryServerStringReq *be_req;
-    xGLXQueryServerStringReply be_reply;
-    DMXScreenInfo *dmxScreen;
-    Display *dpy;
-    int  slop;
-#endif
-
-    name = req->name;
-    screen = req->screen;
-    /*
-    ** Check if screen exists.
-    */
-    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
-	client->errorValue = screen;
-	return BadValue;
-    }
-
-#ifdef FWD_QUERY_REQ
-    dmxScreen = &dmxScreens[screen];
-
-    /* Send the glXQueryServerString request */
-    dpy = GetBackEndDisplay(cl,screen);
-    LockDisplay(dpy);
-    GetReq(GLXQueryServerString,be_req);
-    be_req->reqType = dmxScreen->glxMajorOpcode;
-    be_req->glxCode = X_GLXQueryServerString;
-    be_req->screen = DefaultScreen(dpy);
-    be_req->name = name;
-    _XReply(dpy, (xReply*) &be_reply, 0, False);
-    len = (int)be_reply.length;
-    numbytes = (int)be_reply.n;
-    slop = numbytes * __GLX_SIZE_INT8 & 3;
-    be_buf = (char *)malloc(numbytes);
-    if (!be_buf) {
-        /* Throw data on the floor */
-        _XEatData(dpy, len);
-    } else {
-        _XRead(dpy, (char *)be_buf, numbytes);
-        if (slop) _XEatData(dpy,4-slop);
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-#else
-    be_buf = __glXGetServerString(name);
-    numbytes = strlen(be_buf) + 1;
-    len = __GLX_PAD(numbytes) >> 2;
-#endif
-
-    length = len;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = length;
-    reply.n = numbytes;
-
-    if (client->swapped) {
-        glxSwapQueryServerStringReply(client, &reply, be_buf);
-    } else {
-        WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)&reply);
-        WriteToClient(client, (int)(length << 2), be_buf);
-    }
-
-    return Success;
-}
-
-int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
-    xGLXClientInfoReq *be_req;
-    const char *buf;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-   
-    cl->GLClientmajorVersion = req->major;
-    cl->GLClientminorVersion = req->minor;
-    free(cl->GLClientextensions);
-    buf = (const char *)(req+1);
-    cl->GLClientextensions = strdup(buf);
-
-    to_screen = screenInfo.numScreens - 1;
-
-    for (s=from_screen; s<=to_screen; s++)
-    {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReq(GLXClientInfo,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXClientInfo;
-       be_req->major = req->major;
-       be_req->minor = req->minor;
-       be_req->length = req->length;
-       be_req->numbytes = req->numbytes;
-       Data(dpy, buf, req->numbytes);
-
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    return Success;
-}
-
-int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXUseXFontReq *req;
-    xGLXUseXFontReq *be_req;
-    FontPtr pFont;
-    __GLXcontext *glxc = NULL;
-    int from_screen = 0;
-    int to_screen = 0;
-    int s;
-    dmxFontPrivPtr  pFontPriv;
-    DMXScreenInfo *dmxScreen;
-    Display *dpy;
-
-    req = (xGLXUseXFontReq *) pc;
-
-    if (req->contextTag != 0) {
-	glxc = __glXLookupContextByTag(cl, req->contextTag);
-	if (glxc) {
-	   from_screen = to_screen = glxc->pScreen->myNum;
-	}
-    }
-
-    /*
-    ** Font can actually be either the ID of a font or the ID of a GC
-    ** containing a font.
-    */
-    dixLookupResourceByType((pointer*) &pFont, req->font, RT_FONT,
-                            NullClient, DixUnknownAccess);
-    if (!pFont) {
-        GC *pGC;
-        dixLookupResourceByType((pointer*) &pGC, req->font,
-				RT_GC, NullClient,
-				DixUnknownAccess);
-        if (!pGC) {
-	    client->errorValue = req->font;
-            return BadFont;
-	}
-	pFont = pGC->font;
-    }
-
-    pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-
-    for (s=from_screen; s<=to_screen; s++) {
-       dmxScreen = &dmxScreens[s];
-       dpy = GetBackEndDisplay(cl,s);
-
-       dmxSync( dmxScreen, 1 );
-
-       LockDisplay(dpy);
-       GetReq(GLXUseXFont,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXUseXFont;
-       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
-       be_req->font = pFontPriv->font[s]->fid;
-       be_req->first = req->first;
-       be_req->count = req->count;
-       be_req->listBase = req->listBase;
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       XSync( dpy, False );
-    }
-
-    return Success;
-}
-
-/*
- * start GLX 1.3 here
- */
-
-int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
-    xGLXGetFBConfigsReply reply;
-    __GLXFBConfig *pFBConfig;
-    CARD32 buf[2 * __GLX_TOTAL_FBCONFIG_PROPS];
-    int numAttribs = __GLX_TOTAL_FBCONFIG_PROPS;
-    unsigned int screen = req->screen;
-    int numFBConfigs, i, p;
-    __GLXscreenInfo *pGlxScreen;
-
-    if (screen >= screenInfo.numScreens) {
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
-    }
-
-    pGlxScreen = &__glXActiveScreens[screen];
-    numFBConfigs = __glXNumFBConfigs;
-
-    reply.numFBConfigs = numFBConfigs;
-    reply.numAttribs = numAttribs;
-    reply.length = (numFBConfigs * 2 * numAttribs * __GLX_SIZE_CARD32) >> 2;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    if (client->swapped) {
-	__GLX_DECLARE_SWAP_VARIABLES;
-	__GLX_SWAP_SHORT(&reply.sequenceNumber);
-	__GLX_SWAP_INT(&reply.length);
-	__GLX_SWAP_INT(&reply.numFBConfigs);
-	__GLX_SWAP_INT(&reply.numAttribs);
-    }
-    WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);
-
-    for (i=0; i < numFBConfigs; i++) {
-       int associatedVisualId = 0;
-       int drawableTypeIndex;
-       pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1) ];
-
-	p = 0;
-	/* core attributes */
-	buf[p++] = GLX_FBCONFIG_ID;
-	buf[p++] = pFBConfig->id;
-	buf[p++] = GLX_BUFFER_SIZE;
-	buf[p++] = pFBConfig->indexBits;
-	buf[p++] = GLX_LEVEL;
-	buf[p++] = pFBConfig->level;
-	buf[p++] = GLX_DOUBLEBUFFER;
-	buf[p++] = pFBConfig->doubleBufferMode;
-	buf[p++] = GLX_STEREO;
-	buf[p++] = pFBConfig->stereoMode;
-	buf[p++] = GLX_AUX_BUFFERS;
-	buf[p++] = pFBConfig->maxAuxBuffers;
-	buf[p++] = GLX_RED_SIZE;
-	buf[p++] = pFBConfig->redBits;
-	buf[p++] = GLX_GREEN_SIZE;
-	buf[p++] = pFBConfig->greenBits;
-	buf[p++] = GLX_BLUE_SIZE;
-	buf[p++] = pFBConfig->blueBits;
-	buf[p++] = GLX_ALPHA_SIZE;
-	buf[p++] = pFBConfig->alphaBits;
-	buf[p++] = GLX_DEPTH_SIZE;
-	buf[p++] = pFBConfig->depthBits;
-	buf[p++] = GLX_STENCIL_SIZE;
-	buf[p++] = pFBConfig->stencilBits;
-	buf[p++] = GLX_ACCUM_RED_SIZE;
-	buf[p++] = pFBConfig->accumRedBits;
-	buf[p++] = GLX_ACCUM_GREEN_SIZE;
-	buf[p++] = pFBConfig->accumGreenBits;
-	buf[p++] = GLX_ACCUM_BLUE_SIZE;
-	buf[p++] = pFBConfig->accumBlueBits;
-	buf[p++] = GLX_ACCUM_ALPHA_SIZE;
-	buf[p++] = pFBConfig->accumAlphaBits;
-	buf[p++] = GLX_RENDER_TYPE;
-	buf[p++] = pFBConfig->renderType;
-	buf[p++] = GLX_DRAWABLE_TYPE;
-	drawableTypeIndex = p;
-	buf[p++] = pFBConfig->drawableType;
-	buf[p++] = GLX_X_VISUAL_TYPE;
-	buf[p++] = pFBConfig->visualType;
-	buf[p++] = GLX_CONFIG_CAVEAT;
-	buf[p++] = pFBConfig->visualCaveat;
-	buf[p++] = GLX_TRANSPARENT_TYPE;
-	buf[p++] = pFBConfig->transparentType;
-	buf[p++] = GLX_TRANSPARENT_RED_VALUE;
-	buf[p++] = pFBConfig->transparentRed;
-	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
-	buf[p++] = pFBConfig->transparentGreen;
-	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
-	buf[p++] = pFBConfig->transparentBlue;
-	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
-	buf[p++] = pFBConfig->transparentAlpha;
-	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
-	buf[p++] = pFBConfig->transparentIndex;
-	buf[p++] = GLX_MAX_PBUFFER_WIDTH;
-	buf[p++] = pFBConfig->maxPbufferWidth;
-	buf[p++] = GLX_MAX_PBUFFER_HEIGHT;
-	buf[p++] = pFBConfig->maxPbufferHeight;
-	buf[p++] = GLX_MAX_PBUFFER_PIXELS;
-	buf[p++] = pFBConfig->maxPbufferPixels;
-
-	/*
-         * find the visual of the back-end server and match a visual
-	 * on the proxy.
-	 * do only once - if a visual is not yet associated.
-	 */
-	if (pFBConfig->associatedVisualId == (unsigned int)-1) {
-	   DMXScreenInfo *dmxScreen = &dmxScreens[screen];
-	   __GLXFBConfig *be_pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1)+screen+1 ];
-	   __GLXvisualConfig *pGlxVisual = NULL;
-	   int v;
-	   int found = 0;
-	   for (v=0; v<dmxScreen->numGlxVisuals; v++) {
-	      if (dmxScreen->glxVisuals[v].vid == be_pFBConfig->associatedVisualId) {
-		 pGlxVisual = &dmxScreen->glxVisuals[v];
-		 break;
-	      }
-	   }
-
-	   if (pGlxVisual) {
-	      for (v=0; v<pGlxScreen->numVisuals; v++) {
-		 if (glxVisualsMatch(&pGlxScreen->pGlxVisual[v], pGlxVisual)) {
-		    associatedVisualId = pGlxScreen->pGlxVisual[v].vid;
-		    found = 1;
-		    break;
-		 }
-	      }
-	   }
-
-	   if (!found) {
-	      associatedVisualId = 0;
-	      pFBConfig->drawableType &= ~(GLX_WINDOW_BIT);
-	      buf[drawableTypeIndex] = pFBConfig->drawableType;
-	   }
-#ifdef PANORAMIX
-	   else if (!noPanoramiXExtension) {
-	      /* convert the associated visualId to the panoramix one */
-	      pFBConfig->associatedVisualId =
-		  PanoramiXTranslateVisualID(screen, v);
-	   }
-#endif
-	}
-	else {
-	   associatedVisualId = pFBConfig->associatedVisualId;
-	}
-
-	buf[p++] = GLX_VISUAL_ID;
-	buf[p++] = associatedVisualId;
-
-	/* SGIS_multisample attributes */
-	buf[p++] = GLX_SAMPLES_SGIS;
-	buf[p++] = pFBConfig->multiSampleSize;
-	buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
-	buf[p++] = pFBConfig->nMultiSampleBuffers;
-
-	/* SGIX_pbuffer specific attributes */
-	buf[p++] = GLX_OPTIMAL_PBUFFER_WIDTH_SGIX;
-	buf[p++] = pFBConfig->optimalPbufferWidth;
-	buf[p++] = GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX;
-	buf[p++] = pFBConfig->optimalPbufferHeight;
-
-	buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
-	buf[p++] = pFBConfig->visualSelectGroup;
-
-	if (client->swapped) {
-	    __GLX_DECLARE_SWAP_VARIABLES;
-	    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-	    __GLX_SWAP_INT_ARRAY((int *)buf, 2*numAttribs);
-	}
-	WriteToClient(client, 2*numAttribs * __GLX_SIZE_CARD32, (char *)buf);
-    }
-    return Success;
-}
-
-int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
-   xGLXGetFBConfigsReq new_req;
-
-   new_req.reqType = req->reqType;
-   new_req.glxCode = req->glxCode;
-   new_req.length = req->length;
-   new_req.screen = req->screen;
-
-   return( __glXGetFBConfigs( cl, (GLbyte *)&new_req ) );
-}
-
-
-int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
-    int screen = req->screen;
-    GLXFBConfigID fbconfigId = req->fbconfig;
-    XID windowId = req->window;
-    XID glxwindowId = req->glxwindow;
-    DrawablePtr pDraw;
-    ScreenPtr pScreen;
-    __glXWindow *pGlxWindow;
-    __GLXFBConfig *pGlxFBConfig = NULL;
-    VisualPtr pVisual;
-    VisualID visId;
-    int i, rc;
-    pointer val;
-
-    /*
-    ** Check if windowId is valid 
-    */
-    rc = dixLookupDrawable(&pDraw, windowId, client, M_DRAWABLE_WINDOW,
-			   DixAddAccess);
-    if (rc != Success)
-	return rc;
-
-    /*
-    ** Check if screen of window matches screen of fbconfig.
-    */
-    pScreen = pDraw->pScreen;
-    if (screen != pScreen->myNum) {
-	return BadMatch;
-    }
-
-    /*
-    ** Find the FBConfigRec for this fbconfigid.
-    */
-    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
-	client->errorValue = fbconfigId;
-	return __glXBadFBConfig;
-    }
-    visId = pGlxFBConfig->associatedVisualId;
-
-    /*
-    ** Check if the fbconfig supports rendering to windows 
-    */
-    if( !(pGlxFBConfig->drawableType & GLX_WINDOW_BIT) ) {
-	return BadMatch;	
-    }
-
-    if (visId != None) {
-       /*
-	** Check if the visual ID is valid for this screen.
-	*/
-       pVisual = pScreen->visuals;
-       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
-	  if (pVisual->vid == visId) {
-	     break;
-	  }
-       }
-       if (i == pScreen->numVisuals) {
-	  client->errorValue = visId;
-	  return BadValue;
-       }
-	
-        /*
-        ** Check if color buffer depth of fbconfig matches depth 
-	** of window.
-        */
-        if (pVisual->nplanes != pDraw->depth) {
-	    return BadMatch;
-	}
-    } else
-	/*
-	** The window was created with no visual that corresponds
-	** to fbconfig 
-	*/
-	return BadMatch;
-
-    /*
-    ** Check if there is already a fbconfig associated with this window
-    */
-    if (Success == dixLookupResourceByType(&val,
-					   glxwindowId, __glXWindowRes,
-					   NullClient, DixUnknownAccess)) {
-	client->errorValue = glxwindowId;
-	return BadAlloc;
-    }
-
-    pGlxWindow = (__glXWindow *) malloc(sizeof(__glXWindow));
-    if (!pGlxWindow) {
-	return BadAlloc;
-    }
-
-    /*
-    ** Register this GLX window as a resource
-    */
-    if (!(AddResource(glxwindowId, __glXWindowRes, pGlxWindow))) {
-	return BadAlloc;
-    }
-
-    pGlxWindow->pDraw = pDraw;
-    pGlxWindow->type = GLX_GLXWINDOW_TYPE;
-    pGlxWindow->idExists = True;
-    pGlxWindow->refcnt = 0;
-    pGlxWindow->pGlxFBConfig = pGlxFBConfig;
-    pGlxWindow->pScreen = pScreen;
-
-    return Success;
-}
-
-int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
-    XID glxwindow = req->glxwindow;
-    pointer val;
-
-    /*
-    ** Check if it's a valid GLX window.
-    */
-    if (Success != dixLookupResourceByType(&val,
-					   glxwindow, __glXWindowRes,
-					   NullClient, DixUnknownAccess)) {
-	client->errorValue = glxwindow;
-	return __glXBadDrawable;
-    }
-    /*
-    ** The glx window destructor will check whether it's current before
-    ** freeing anything.
-    */
-    FreeResource(glxwindow, RT_NONE);	
-
-    return Success;
-}
-
-int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    __GLXcontext *ctx;
-    xGLXQueryContextReq *req;
-    xGLXQueryContextReply reply;
-    int nProps;
-    int *sendBuf, *pSendBuf;
-    int nReplyBytes;
-
-    req = (xGLXQueryContextReq *)pc;
-    dixLookupResourceByType((pointer*) &ctx, req->context, __glXContextRes,
-                            NullClient, DixUnknownAccess);
-    if (!ctx) {
-        client->errorValue = req->context;
-        return __glXBadContext;
-    }
-
-    nProps = 3;
-
-    reply.length = nProps << 1;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.n = nProps;
-
-    nReplyBytes = reply.length << 2;
-    sendBuf = (int *)malloc(nReplyBytes);
-    pSendBuf = sendBuf;
-    *pSendBuf++ = GLX_FBCONFIG_ID;
-    *pSendBuf++ = (int)(ctx->pFBConfig->id);
-    *pSendBuf++ = GLX_RENDER_TYPE;
-    *pSendBuf++ = (int)(ctx->pFBConfig->renderType);
-    *pSendBuf++ = GLX_SCREEN;
-    *pSendBuf++ = (int)(ctx->pScreen->myNum);
-
-    if (client->swapped) {
-        __glXSwapQueryContextReply(client, &reply, sendBuf);
-    } else {
-        WriteToClient(client, sz_xGLXQueryContextReply, (char *)&reply);
-        WriteToClient(client, nReplyBytes, (char *)sendBuf);
-    }
-    free((char *)sendBuf);
-
-    return Success;
-}
-
-int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    __GLXcontext *ctx;
-    xGLXQueryContextInfoEXTReq *req;
-    xGLXQueryContextInfoEXTReply reply;
-    int nProps;
-    int *sendBuf, *pSendBuf;
-    int nReplyBytes;
-
-    req = (xGLXQueryContextInfoEXTReq *)pc;
-    dixLookupResourceByType((pointer*) &ctx,
-			    req->context, __glXContextRes,
-			    client,  DixReadAccess);
-
-    if (!ctx) {
-        client->errorValue = req->context;
-        return __glXBadContext;
-    }
-
-    nProps = 4;
-
-    reply.length = nProps << 1;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.n = nProps;
-
-    nReplyBytes = reply.length << 2;
-    sendBuf = (int *)malloc(nReplyBytes);
-    pSendBuf = sendBuf;
-    *pSendBuf++ = GLX_SHARE_CONTEXT_EXT;
-    *pSendBuf++ = (int)(ctx->share_id);
-    *pSendBuf++ = GLX_VISUAL_ID_EXT;
-    *pSendBuf++ = (int)(ctx->pVisual ? ctx->pVisual->vid : 0);
-    *pSendBuf++ = GLX_SCREEN_EXT;
-    *pSendBuf++ = (int)(ctx->pScreen->myNum);
-    *pSendBuf++ = GLX_FBCONFIG_ID;
-    *pSendBuf++ = (int)(ctx->pFBConfig ? ctx->pFBConfig->id : 0);
-
-    if (client->swapped) {
-        __glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
-    } else {
-        WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)&reply);
-        WriteToClient(client, nReplyBytes, (char *)sendBuf);
-    }
-    free((char *)sendBuf);
-
-    return Success;
-}
-
-int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
-    xGLXCreatePbufferReq *be_req;
-    int screen = req->screen;
-    GLXFBConfigID fbconfigId = req->fbconfig;
-    GLXPbuffer pbuffer = req->pbuffer;
-    __glXPbuffer *pGlxPbuffer;
-    int numAttribs = req->numAttribs;
-    int *attr;
-    ScreenPtr pScreen;
-    __GLXFBConfig *pGlxFBConfig;
-    __GLXFBConfig *be_pGlxFBConfig;
-    XID be_xid;
-    Display *dpy;
-    DMXScreenInfo *dmxScreen;
-    int s;
-    int from_screen, to_screen;
-
-   /*
-    ** Look up screen and FBConfig.
-    */
-    if (screen >= screenInfo.numScreens) {
-        /* The client library must send a valid screen number. */
-        client->errorValue = screen;
-        return BadValue;
-    }
-    pScreen = screenInfo.screens[screen];
-
-    /*
-    ** Find the FBConfigRec for this fbconfigid.
-    */
-    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
-	client->errorValue = fbconfigId;
-	return __glXBadFBConfig;
-    }
-
-    /*
-    ** Create the GLX part of the Pbuffer.
-    */
-    pGlxPbuffer = (__glXPbuffer *) malloc(sizeof(__glXPbuffer));
-    if (!pGlxPbuffer) {
-        return BadAlloc;
-    }
-
-    pGlxPbuffer->be_xids = (XID *) malloc( sizeof(XID) * screenInfo.numScreens );
-    if (!pGlxPbuffer->be_xids) {
-        free(pGlxPbuffer);
-        return BadAlloc;
-    }
-
-    /*
-     * Allocate an XID on the back-end server(s) and send him the request
-     */
-    from_screen = to_screen = screen;
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       dpy = GetBackEndDisplay(cl,s);
-       be_xid = XAllocID(dpy);
-       dmxScreen = &dmxScreens[s];
-       be_pGlxFBConfig = glxLookupBackEndFBConfig( pGlxFBConfig->id, s );
-       
-       attr = (int *)( req+1 );
-
-       LockDisplay(dpy);
-       GetReqExtra(GLXCreatePbuffer, 2 * numAttribs * __GLX_SIZE_CARD32, be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXCreatePbuffer;
-       be_req->screen = be_pGlxFBConfig->screen;
-       be_req->fbconfig = be_pGlxFBConfig->id;
-       be_req->pbuffer = be_xid;
-       be_req->numAttribs = numAttribs;
-    
-       /* Send attributes */
-       if ( attr != NULL ) {
-	  CARD32 *pc = (CARD32 *)(be_req + 1);
-
-	  while (numAttribs-- > 0) {
-	     *pc++ = *attr++;     /* token */
-	     *pc++ = *attr++;     /* value */
-	  }
-       }
-
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       pGlxPbuffer->be_xids[s] = be_xid;
-    }
-
-
-    pGlxPbuffer->idExists = True;
-    pGlxPbuffer->refcnt = 0;
-    pGlxPbuffer->pFBConfig = pGlxFBConfig;
-    pGlxPbuffer->pScreen = pScreen;
-
-    /*
-    ** Register the resource.
-    */
-    if (!(AddResource(pbuffer, __glXPbufferRes, pGlxPbuffer))) {
-        return BadAlloc;
-    }
-
-    return Success;
-
-}
-
-int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    ClientPtr client = cl->client;
-    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
-    xGLXDestroyPbufferReq *be_req;
-    GLXPbuffer pbuffer = req->pbuffer;
-    Display *dpy;
-    int screen;
-    DMXScreenInfo *dmxScreen;
-    __glXPbuffer *pGlxPbuffer;
-    int s;
-    int from_screen, to_screen;
-
-    /*
-    ** Check if it's a valid Pbuffer
-    */
-    dixLookupResourceByType((pointer*) &pGlxPbuffer, pbuffer,
-                            __glXPbufferRes, NullClient, DixUnknownAccess);
-    if (!pGlxPbuffer) {
-	client->errorValue = pbuffer;
-	return __glXBadPbuffer;
-    }
-
-    screen = pGlxPbuffer->pScreen->myNum;
-
-    from_screen = to_screen = screen;
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    for (s=from_screen; s<=to_screen; s++) {
-       dpy = GetBackEndDisplay(cl,s);
-       dmxScreen = &dmxScreens[s];
-
-       /* send the destroy request to the back-end server */
-       LockDisplay(dpy);
-       GetReq(GLXDestroyPbuffer, be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = X_GLXDestroyPbuffer;
-       be_req->pbuffer = pGlxPbuffer->be_xids[s];
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    FreeResource(pbuffer, RT_NONE);	
-
-    return Success;
-}
-
-int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
-   xGLXGetDrawableAttributesReq *be_req;
-   xGLXGetDrawableAttributesReply reply;
-   ClientPtr client = cl->client;
-   GLXDrawable drawId = req->drawable;
-   GLXDrawable be_drawable = 0;
-   DrawablePtr pDraw = NULL;
-   Display *dpy;
-   int screen, rc;
-   DMXScreenInfo *dmxScreen;
-   CARD32 *attribs = NULL;
-   int attribs_size = 0;
-#ifdef PANORAMIX
-    PanoramiXRes *pXinDraw = NULL;
-#endif
-
-   if (drawId != None) {
-      rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixGetAttrAccess);
-      if (rc == Success && pDraw->type == DRAWABLE_WINDOW) {
-	 WindowPtr pWin = (WindowPtr)pDraw;
-	 be_drawable = 0;
-	 screen = pWin->drawable.pScreen->myNum;
-      } else {
-	 /*
-	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
-	  */
-	 client->errorValue = drawId;
-	 return __glXBadDrawable;
-      }
-
-      if (!pDraw) {
-	 __GLXpixmap *pGlxPixmap;
-	 dixLookupResourceByType((pointer*) &pGlxPixmap,
-				 drawId, __glXPixmapRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxPixmap) {
-		pDraw = pGlxPixmap->pDraw;
-		screen = pGlxPixmap->pScreen->myNum;
-                be_drawable = pGlxPixmap->be_xids[screen];
-	 }
-      }
-
-      if (!pDraw) {
-	 __glXWindow *pGlxWindow;
-	 dixLookupResourceByType((pointer*) &pGlxWindow,
-				 drawId, __glXWindowRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxWindow) {
-	    pDraw = pGlxWindow->pDraw;
-	    screen = pGlxWindow->pScreen->myNum;
-	    be_drawable = 0;
-     	 }
-      }
-
-      if (!pDraw) {
-	 __glXPbuffer *pGlxPbuffer;
-	 dixLookupResourceByType((pointer*) &pGlxPbuffer,
-				 drawId, __glXPbufferRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxPbuffer) {
-    	    pDraw = (DrawablePtr)pGlxPbuffer;
-	    screen = pGlxPbuffer->pScreen->myNum;
-	    be_drawable = pGlxPbuffer->be_xids[screen];
-	 }
-      }
-    }
-
-    if (!pDraw) {
-	/*
-	 ** Drawable is not a Window , GLXWindow or a GLXPixmap.
-	 */
-	client->errorValue = drawId;
-	return __glXBadDrawable;
-   }
-
-   /* if the drawable is a window or GLXWindow - 
-    * we need to find the base id on the back-end server
-    */
-   if (!be_drawable) {
-       WindowPtr pWin = (WindowPtr)pDraw;
-
-#ifdef PANORAMIX
-       if (!noPanoramiXExtension) {
-	  if (Success != dixLookupResourceByClass((pointer*) &pXinDraw,
-						  pDraw->id, XRC_DRAWABLE,
-						  client, DixReadAccess)) {
-	     client->errorValue = drawId;
-	     return __glXBadDrawable;
-	  }
-
-	  dixLookupWindow(&pWin, pXinDraw->info[screen].id, client,
-			  DixReadAccess);
-       }
-#endif
-
-       if (pWin) {
-	   be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   if (!be_drawable) {
-	      /* it might be that the window did not created yet on the */
-	      /* back-end server (lazy window creation option), force   */
-	      /* creation of the window */
-	      dmxCreateAndRealizeWindow( pWin, TRUE );
-	      be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   }
-       }
-       else {
-	  client->errorValue = drawId;
-	  return __glXBadDrawable;
-       }
-   }
-
-
-   /* send the request to the back-end server */
-   dpy = GetBackEndDisplay(cl,screen);
-   dmxScreen = &dmxScreens[screen];
-
-   /* make sure drawable exists on back-end */
-   dmxSync( dmxScreen, 1 );
-
-   LockDisplay(dpy);
-   GetReq(GLXGetDrawableAttributes, be_req);
-   be_req->reqType = dmxScreen->glxMajorOpcode;
-   be_req->glxCode = X_GLXGetDrawableAttributes;
-   be_req->drawable = be_drawable;
-   be_req->length = req->length;
-   if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
-   }
-
-   if (reply.numAttribs) {
-      attribs_size = 2 * reply.numAttribs * __GLX_SIZE_CARD32;
-      attribs = (CARD32 *) malloc(attribs_size);
-      if (attribs == NULL) {
-	 UnlockDisplay(dpy);
-	 SyncHandle();
-	 return BadAlloc;
-      }
-
-      _XRead(dpy, (char *) attribs, attribs_size);
-   }
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-
-   /* send the reply back to the client */
-   reply.sequenceNumber = client->sequence;
-   if (client->swapped) {
-      __glXSwapGetDrawableAttributesReply(client, &reply, (int *)attribs);
-   }
-   else {
-      WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)&reply);
-      WriteToClient(client, attribs_size, (char *)attribs);
-   }
-
-   free(attribs);
-
-   return Success;
-}
-
-int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
-{
-   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
-   xGLXChangeDrawableAttributesReq *be_req;
-   ClientPtr client = cl->client;
-   GLXDrawable drawId = req->drawable;
-   GLXDrawable be_drawable = 0;
-   DrawablePtr pDraw = NULL;
-   Display *dpy;
-   int screen, rc;
-   DMXScreenInfo *dmxScreen;
-
-   if (drawId != None) {
-      rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixSetAttrAccess);
-      if (rc == Success && pDraw->type == DRAWABLE_WINDOW) {
-	  be_drawable = 0;
-	  screen = pDraw->pScreen->myNum;
-      } else {
-	 /*
-	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
-	  */
-	 client->errorValue = drawId;
-	 return __glXBadDrawable;
-      }
-
-      if (!pDraw) {
-	 __GLXpixmap *pGlxPixmap;
-	 dixLookupResourceByType((pointer*) &pGlxPixmap,
-				 drawId, __glXPixmapRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxPixmap) {
-		pDraw = pGlxPixmap->pDraw;
-		screen = pGlxPixmap->pScreen->myNum;
-                be_drawable = pGlxPixmap->be_xids[screen];
-	 }
-      }
-
-      if (!pDraw) {
-	 __glXWindow *pGlxWindow;
-	 dixLookupResourceByType((pointer*) &pGlxWindow,
-				 drawId, __glXWindowRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxWindow) {
-	    pDraw = pGlxWindow->pDraw;
-	    screen = pGlxWindow->pScreen->myNum;
-	    be_drawable = 0;
-     	 }
-      }
-
-      if (!pDraw) {
-	 __glXPbuffer *pGlxPbuffer;
-	 dixLookupResourceByType((pointer*) &pGlxPbuffer,
-				 drawId, __glXPbufferRes,
-				 NullClient, DixUnknownAccess);
-	 if (pGlxPbuffer) {
-    	    pDraw = (DrawablePtr)pGlxPbuffer;
-	    screen = pGlxPbuffer->pScreen->myNum;
-	    be_drawable = pGlxPbuffer->be_xids[screen];
-	 }
-      }
-   }
-
-   if (!pDraw) {
-	 /*
-	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
-	  */
-	 client->errorValue = drawId;
-	 return __glXBadDrawable;
-   }
-
-   /* if the drawable is a window or GLXWindow - 
-    * we need to find the base id on the back-end server
-    */
-   if (!be_drawable) {
-       WindowPtr pWin = (WindowPtr)pDraw;
-
-#ifdef PANORAMIX
-       if (!noPanoramiXExtension) {
-	  PanoramiXRes *pXinDraw;
-	  if (Success != dixLookupResourceByClass((pointer*) &pXinDraw,
-						  pDraw->id, XRC_DRAWABLE,
-						  client, DixReadAccess)) {
-	     client->errorValue = drawId;
-	     return __glXBadDrawable;
-	  }
-
-	  dixLookupWindow(&pWin, pXinDraw->info[screen].id, client,
-			  DixReadAccess);
-       }
-#endif
-
-       if (pWin) {
-	   be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   if (!be_drawable) {
-	      /* it might be that the window did not created yet on the */
-	      /* back-end server (lazy window creation option), force   */
-	      /* creation of the window */
-	      dmxCreateAndRealizeWindow( pWin, TRUE );
-	      be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
-	   }
-       }
-       else {
-	  client->errorValue = drawId;
-	  return __glXBadDrawable;
-       }
-   }
-
-
-   /* send the request to the back-end server */
-   dpy = GetBackEndDisplay(cl,screen);
-   dmxScreen = &dmxScreens[screen];
-
-   /* make sure drawable exists on back-end */
-   dmxSync( dmxScreen, 1 );
-
-   LockDisplay(dpy);
-   GetReqExtra(GLXChangeDrawableAttributes,
-                        2 * req->numAttribs * __GLX_SIZE_CARD32, be_req);
-   be_req->reqType = dmxScreen->glxMajorOpcode;
-   be_req->glxCode = X_GLXChangeDrawableAttributes;
-   be_req->drawable = be_drawable;
-   be_req->numAttribs = req->numAttribs;
-   be_req->length = req->length;
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return Success;
-}
-
-int __glXSendLargeCommand(__GLXclientState *cl, GLXContextTag contextTag)
-{
-   ClientPtr client = cl->client;
-    xGLXRenderLargeReq *req;
-    GLint maxSize, amount;
-    GLint totalRequests, requestNumber;
-    GLint dataLen;
-    GLbyte *data;
-    __GLXcontext *glxc;
-    int s;
-    int from_screen, to_screen;
-
-    maxSize = cl->largeCmdMaxReqDataSize - (GLint)sizeof(xGLXRenderLargeReq);
-    dataLen = cl->largeCmdBytesTotal;
-    totalRequests = (dataLen / maxSize);
-    if (dataLen % maxSize) totalRequests++;
-
-    glxc = __glXLookupContextByTag(cl, contextTag);
-    if (!glxc) {
-       client->errorValue = contextTag;
-       return __glXBadContext;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    /*
-    ** Send enough requests until the whole array is sent.
-    */
-    requestNumber = 1;
-    data = cl->largeCmdBuf;
-    while (dataLen > 0) {
-	amount = dataLen;
-	if (amount > maxSize) {
-	    amount = maxSize;
-	}
-
-	for (s=from_screen; s<=to_screen; s++) {
-
-	   Display *dpy = GetBackEndDisplay(cl,s);
-	   DMXScreenInfo *dmxScreen = &dmxScreens[s];
-
-	   LockDisplay(dpy);
-	   GetReq(GLXRenderLarge,req); 
-	   req->reqType = dmxScreen->glxMajorOpcode;
-	   req->glxCode = X_GLXRenderLarge; 
-	   req->contextTag = GetCurrentBackEndTag(cl,contextTag,s);
-	   req->length += (amount + 3) >> 2;
-	   req->requestNumber = requestNumber++;
-	   req->requestTotal = totalRequests;
-	   req->dataBytes = amount;
-	   Data(dpy, ((const char*)data), amount);
-	   dataLen -= amount;
-	   data = ((GLbyte *) data) + amount;
-	   UnlockDisplay(dpy);
-	   SyncHandle();
-	}
-    }
-
-    return Success;
-}
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxwindow.h"
+#include "dmxpixmap.h"
+#include "dmxfont.h"
+#include "dmxsync.h"
+
+#include "glxserver.h"
+#include <GL/glxtokens.h>
+#include "g_disptab.h"
+#include <pixmapstr.h>
+#include <windowstr.h>
+#include "glxutil.h"
+#include "glxext.h"
+#include "unpack.h"
+
+#include "GL/glxproto.h"
+#include "glxvendor.h"
+#include "glxvisuals.h"
+#include "glxswap.h"
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.h"
+#endif
+
+extern __GLXFBConfig **__glXFBConfigs;
+extern int            __glXNumFBConfigs;
+
+extern __GLXFBConfig *glxLookupFBConfig( GLXFBConfigID id );
+extern __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid );
+extern __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen );
+extern int glxIsExtensionSupported( char *ext );
+extern int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
+
+#define BE_TO_CLIENT_ERROR(x) \
+           ( (x) >= __glXerrorBase ? \
+             (x) - dmxScreen->glxErrorBase + __glXerrorBase \
+	     : (x) )
+
+Display *GetBackEndDisplay( __GLXclientState *cl, int s )
+{
+   if (! cl->be_displays[s] ) {
+      cl->be_displays[s] = XOpenDisplay( DisplayString(dmxScreens[s].beDisplay) );
+   }
+   return cl->be_displays[s];
+}
+
+/*
+** Create a GL context with the given properties.
+*/
+static int CreateContext(__GLXclientState *cl, 
+                         GLXContextID gcId,
+			 VisualID vid, GLXFBConfigID fbconfigId,
+			 int screen,
+			 GLXContextID shareList,
+			 int isDirect )
+{
+    ClientPtr client = cl->client;
+    xGLXCreateContextReq *be_req;
+    xGLXCreateNewContextReq *be_new_req;
+    VisualPtr pVisual;
+    ScreenPtr pScreen;
+    __GLXcontext *glxc, *shareglxc;
+    __GLXvisualConfig *pGlxVisual;
+    __GLXscreenInfo *pGlxScreen;
+    VisualID visual = vid;
+    GLint i;
+    int from_screen = screen;
+    int to_screen = screen;
+    DMXScreenInfo *dmxScreen;
+    VisualID be_vid = 0;
+    GLXFBConfigID be_fbconfigId = 0;
+    int num_be_screens;
+    Display *dpy;
+    
+    /*
+    ** Check if screen exists.
+    */
+    if (screen >= screenInfo.numScreens) {
+	client->errorValue = screen;
+	return BadValue;
+    }
+
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    /*
+     ** Find the display list space that we want to share.  
+     **
+     */
+    if (shareList == None) {
+       shareglxc = NULL;
+    } else {
+       dixLookupResourceByType((pointer*) &shareglxc, shareList,
+                               __glXContextRes, NullClient, DixUnknownAccess);
+       if (!shareglxc) {
+	  client->errorValue = shareList;
+	  return __glXBadContext;
+       }
+    }
+
+    /*
+    ** Allocate memory for the new context
+    */
+    glxc = calloc(1, sizeof(__GLXcontext));
+    if (!glxc) {
+	return BadAlloc;
+    }
+
+    pScreen = screenInfo.screens[screen];
+    pGlxScreen = &__glXActiveScreens[screen];
+
+    if (fbconfigId != None) {
+       glxc->pFBConfig = glxLookupFBConfig( fbconfigId );
+       if (!glxc->pFBConfig) {
+	  client->errorValue = fbconfigId;
+	  free( glxc );
+	  return BadValue;
+       }
+       visual = glxc->pFBConfig->associatedVisualId;
+    }
+    else {
+       glxc->pFBConfig = NULL;
+    }
+
+    if (visual != None) {
+       /*
+	** Check if the visual ID is valid for this screen.
+	*/
+       pVisual = pScreen->visuals;
+       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
+	  if (pVisual->vid == visual) {
+	     break;
+	  }
+       }
+       if (i == pScreen->numVisuals) {
+	  client->errorValue = visual;
+	  free( glxc );
+	  return BadValue;
+       }
+
+       pGlxVisual = pGlxScreen->pGlxVisual;
+       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
+	  if (pGlxVisual->vid == visual) {
+	     break;
+	  }
+       }
+       if (i == pGlxScreen->numVisuals) {
+	  /*
+	   ** Visual not support on this screen by this OpenGL implementation.
+	   */
+	  client->errorValue = visual;
+	  free( glxc );
+	  return BadValue;
+       }
+
+       if ( glxc->pFBConfig == NULL ) {
+	   glxc->pFBConfig = glxLookupFBConfigByVID( visual );
+
+	   if ( glxc->pFBConfig == NULL ) {
+	      /*
+               * visual does not have an FBConfig ???
+	      client->errorValue = visual;
+	      free( glxc );
+	      return BadValue;
+	       */
+	   }
+       }
+    }
+    else {
+       pVisual = NULL;
+       pGlxVisual = NULL;
+    }
+
+    glxc->pScreen = pScreen;
+    glxc->pGlxScreen = pGlxScreen;
+    glxc->pVisual = pVisual;
+    glxc->pGlxVisual = pGlxVisual;
+
+    /*
+     * allocate memory for back-end servers info
+     */
+    num_be_screens = to_screen - from_screen + 1;
+    glxc->real_ids = (XID *)malloc(sizeof(XID) * num_be_screens);
+    if (!glxc->real_ids) {
+	return BadAlloc;
+    }
+    glxc->real_vids = (XID *)malloc(sizeof(XID) * num_be_screens);
+    if (!glxc->real_vids) {
+	return BadAlloc;
+    }
+
+    for (screen = from_screen; screen <= to_screen; screen++) {
+       int sent = 0;
+       pScreen = screenInfo.screens[screen];
+       pGlxScreen = &__glXActiveScreens[screen];
+       dmxScreen = &dmxScreens[screen];
+
+       if (glxc->pFBConfig) {
+	  __GLXFBConfig *beFBConfig = glxLookupBackEndFBConfig( glxc->pFBConfig->id, 
+		                                                screen );
+	  be_fbconfigId = beFBConfig->id;
+       }
+
+       if (pGlxVisual) {
+
+	  be_vid = glxMatchGLXVisualInConfigList( pGlxVisual,
+	                                    dmxScreen->glxVisuals,
+					    dmxScreen->numGlxVisuals  );
+
+	  if (!be_vid) {
+	     /* visual is not supported on the back-end server */
+	     free( glxc->real_ids );
+	     free( glxc->real_vids );
+	     free( glxc );
+	     return BadValue;
+	  }
+       }
+
+       glxc->real_ids[screen-from_screen] = XAllocID(GetBackEndDisplay(cl,screen));
+
+       /* send the create context request to the back-end server */
+       dpy = GetBackEndDisplay(cl,screen);
+       if (glxc->pFBConfig) {
+	     /*Since for a certain visual both RGB and COLOR INDEX
+	      *can be on then the only parmeter to choose the renderType
+	      * should be the class of the colormap since all 4 first 
+	      * classes does not support RGB mode only COLOR INDEX ,
+	      * and so TrueColor and DirectColor does not support COLOR INDEX*/
+	     int renderType =  glxc->pFBConfig->renderType;  
+	     if ( pVisual ) {
+		 switch ( pVisual->class ){
+		     case PseudoColor:
+                     case StaticColor:
+                     case GrayScale:
+                     case StaticGray:
+                         renderType = GLX_COLOR_INDEX_TYPE;
+                         break;
+                     case TrueColor:
+                     case DirectColor:
+                     default:
+                         renderType = GLX_RGBA_TYPE;
+                     break;
+		 }
+	     }
+	  if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	     LockDisplay(dpy);
+	     GetReq(GLXCreateNewContext,be_new_req);
+	     be_new_req->reqType = dmxScreen->glxMajorOpcode;
+	     be_new_req->glxCode = X_GLXCreateNewContext;
+	     be_new_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
+	     be_new_req->fbconfig = (unsigned int)be_fbconfigId;
+	     be_new_req->screen = DefaultScreen(dpy);
+	     be_new_req->renderType = renderType;  
+
+	     be_new_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
+	     be_new_req->isDirect = 0;
+	     UnlockDisplay(dpy);
+	     glxc->real_vids[screen-from_screen] = be_fbconfigId;
+	     sent = 1;
+	  }
+	  else if (glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
+
+	     xGLXCreateContextWithConfigSGIXReq *ext_req;
+	     xGLXVendorPrivateReq *vpreq;
+	     LockDisplay(dpy);
+	     GetReqExtra(GLXVendorPrivate,
+		         sz_xGLXCreateContextWithConfigSGIXReq - sz_xGLXVendorPrivateReq,
+			vpreq);
+	     ext_req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
+	     ext_req->reqType = dmxScreen->glxMajorOpcode;
+	     ext_req->glxCode = X_GLXVendorPrivate;
+	     ext_req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
+	     ext_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
+	     ext_req->fbconfig = (unsigned int)be_fbconfigId;
+	     ext_req->screen = DefaultScreen(dpy);
+	     ext_req->renderType = renderType;  
+	     ext_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
+	     ext_req->isDirect = 0;
+	     UnlockDisplay(dpy);
+	     glxc->real_vids[screen-from_screen] = be_fbconfigId;
+	     sent = 1;
+	  }
+       }
+
+       if (!sent) {
+	  LockDisplay(dpy);
+	  GetReq(GLXCreateContext,be_req);
+	  be_req->reqType = dmxScreen->glxMajorOpcode;
+	  be_req->glxCode = X_GLXCreateContext;
+	  be_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
+	  be_req->visual = (unsigned int)be_vid;
+	  be_req->screen = DefaultScreen(dpy);
+	  be_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
+	  be_req->isDirect = 0;
+	  UnlockDisplay(dpy);
+	  glxc->real_vids[screen-from_screen] = be_vid;
+       }
+       SyncHandle();
+
+    }
+
+    /*
+    ** Register this context as a resource.
+    */
+    if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
+       free( glxc->real_ids );
+       free( glxc->real_vids );
+       free( glxc );
+	client->errorValue = gcId;
+	return BadAlloc;
+    }
+    
+    /*
+    ** Finally, now that everything is working, setup the rest of the
+    ** context.
+    */
+    glxc->id = gcId;
+    glxc->share_id = shareList;
+    glxc->idExists = GL_TRUE;
+    glxc->isCurrent = GL_FALSE;
+
+    return Success;
+}
+
+int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
+
+    return( CreateContext(cl, req->context,req->visual, None,
+	                  req->screen, req->shareList, req->isDirect) );
+
+}
+
+int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+
+    return( CreateContext(cl, req->context,None, req->fbconfig,
+	                  req->screen, req->shareList, req->isDirect) );
+
+}
+
+int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;
+
+    return( CreateContext(cl, req->context, None, req->fbconfig,
+	                  req->screen, req->shareList, req->isDirect) );
+
+}
+
+int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXQueryMaxSwapBarriersSGIXReq *req =
+	(xGLXQueryMaxSwapBarriersSGIXReq *)pc;
+    xGLXQueryMaxSwapBarriersSGIXReply reply;
+
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = 0;
+    reply.max = QueryMaxSwapBarriersSGIX(req->screen);
+
+    if (client->swapped) {
+	__glXSwapQueryMaxSwapBarriersSGIXReply(client, &reply);
+    } else {
+	WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply,
+		      (char *)&reply);
+    }
+
+    return Success;
+}
+
+int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
+    DrawablePtr pDraw;
+    __GLXpixmap *pGlxPixmap = NULL;
+    __glXWindow *pGlxWindow = NULL;
+    int rc;
+
+    rc = dixLookupDrawable(&pDraw, req->drawable, client, 0, DixGetAttrAccess);
+    if (rc != Success) {
+	dixLookupResourceByType((pointer*) &pGlxPixmap, req->drawable,
+				__glXPixmapRes, NullClient, DixUnknownAccess);
+	if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
+    }
+
+    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+       dixLookupResourceByType((pointer*) &pGlxWindow, req->drawable,
+                               __glXWindowRes, NullClient, DixUnknownAccess);
+       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
+    }
+
+    if (!pDraw) {
+       client->errorValue = req->drawable;
+       return __glXBadDrawable;
+    }
+
+    return BindSwapBarrierSGIX(pDraw, req->barrier);
+}
+
+int __glXJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
+    DrawablePtr pDraw, pMember = NULL;
+    __GLXpixmap *pGlxPixmap = NULL;
+    __glXWindow *pGlxWindow = NULL;
+    int rc;
+
+    rc = dixLookupDrawable(&pDraw, req->drawable, client, 0, DixManageAccess);
+    if (rc != Success) {
+	dixLookupResourceByType((pointer*) &pGlxPixmap, req->drawable,
+				__glXPixmapRes, NullClient, DixUnknownAccess);
+	if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
+    }
+
+    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+       dixLookupResourceByType((pointer*) &pGlxWindow, req->drawable,
+                               __glXWindowRes, NullClient, DixUnknownAccess);
+       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
+    }
+
+    if (!pDraw) {
+       client->errorValue = req->drawable;
+       return __glXBadDrawable;
+    }
+
+    if (req->member != None) {
+	rc = dixLookupDrawable(&pMember, req->member, client, 0,
+			       DixGetAttrAccess);
+	if (rc != Success) {
+	    dixLookupResourceByType((pointer*) &pGlxPixmap, req->member,
+                                    __glXPixmapRes, NullClient,
+                                    DixUnknownAccess);
+	    if (pGlxPixmap) pMember = pGlxPixmap->pDraw;
+	}
+
+	if (!pMember && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	    dixLookupResourceByType((pointer*) &pGlxWindow, req->member,
+                                    __glXWindowRes, NullClient,
+                                    DixUnknownAccess);
+	    if (pGlxWindow) pMember = pGlxWindow->pDraw;
+	}
+
+	if (!pMember) {
+	    client->errorValue = req->member;
+	    return __glXBadDrawable;
+	}
+    }
+
+    return JoinSwapGroupSGIX(pDraw, pMember);
+}
+
+
+/*
+** Destroy a GL context as an X resource.
+*/
+int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
+    xGLXDestroyContextReq *be_req;
+    GLXContextID gcId = req->context;
+    __GLXcontext *glxc;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+    
+    dixLookupResourceByType((pointer*) &glxc, gcId, __glXContextRes,
+			    NullClient, DixUnknownAccess);
+    if (glxc) {
+	/*
+	** Just free the resource; don't actually destroy the context,
+	** because it might be in use.  The
+	** destroy method will be called by the resource destruction routine
+	** if necessary.
+	*/
+	FreeResourceByType(gcId, __glXContextRes, FALSE);
+
+	from_screen = to_screen = glxc->pScreen->myNum;
+
+    } else {
+	client->errorValue = gcId;
+	return __glXBadContext;
+    }
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    /*
+     * send DestroyContext request to all back-end servers
+     */
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReq(GLXDestroyContext,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXDestroyContext;
+       be_req->context = glxc->real_ids[s-from_screen];
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    return Success;
+}
+
+/*****************************************************************************/
+
+/*
+** For each client, the server keeps a table of all the contexts that are
+** current for that client (each thread of a client may have its own current
+** context).  These routines add, change, and lookup contexts in the table.
+*/
+
+/*
+** Add a current context, and return the tag that will be used to refer to it.
+*/
+static int AddCurrentContext(__GLXclientState *cl, __GLXcontext *glxc, DrawablePtr pDraw)
+{
+    int i;
+    int num = cl->numCurrentContexts;
+    __GLXcontext **table = cl->currentContexts;
+
+    if (!glxc) return -1;
+    
+    /*
+    ** Try to find an empty slot and use it.
+    */
+    for (i=0; i < num; i++) {
+	if (!table[i]) {
+	    table[i] = glxc;
+	    return i+1;
+	}
+    }
+    /*
+    ** Didn't find a free slot, so we'll have to grow the table.
+    */
+    if (!num) {
+	table = (__GLXcontext **) malloc(sizeof(__GLXcontext *));
+	cl->currentDrawables = (DrawablePtr *) malloc(sizeof(DrawablePtr));
+	cl->be_currentCTag = (GLXContextTag *) malloc(screenInfo.numScreens *sizeof(GLXContextTag));
+    } else {
+	table = (__GLXcontext **) realloc(table,
+					   (num+1)*sizeof(__GLXcontext *));
+	cl->currentDrawables = (DrawablePtr *) realloc(
+	                                          cl->currentDrawables ,
+						  (num+1)*sizeof(DrawablePtr));
+	cl->be_currentCTag = (GLXContextTag *) realloc(cl->be_currentCTag,
+	            (num+1)*screenInfo.numScreens*sizeof(GLXContextTag));
+    }
+    table[num] = glxc;
+    cl->currentDrawables[num] = pDraw;
+    cl->currentContexts = table;
+    cl->numCurrentContexts++;
+
+    memset(cl->be_currentCTag + num*screenInfo.numScreens, 0, 
+	         screenInfo.numScreens * sizeof(GLXContextTag));
+
+    return num+1;
+}
+
+/*
+** Given a tag, change the current context for the corresponding entry.
+*/
+static void ChangeCurrentContext(__GLXclientState *cl, __GLXcontext *glxc,
+				GLXContextTag tag)
+{
+    __GLXcontext **table = cl->currentContexts;
+    table[tag-1] = glxc;
+}
+
+/*
+** Given a tag, and back-end screen number, retrives the current back-end
+** tag.
+*/
+int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s)
+{
+   if (tag >0) {
+      return( cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] );
+   }
+   else {
+      return 0;
+   }
+}
+
+/*
+** Given a tag, and back-end screen number, sets the current back-end
+** tag.
+*/
+static void SetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s, GLXContextTag be_tag)
+{
+   if (tag >0) {
+      cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] = be_tag;
+   }
+}
+
+/*
+** For this implementation we have chosen to simply use the index of the
+** context's entry in the table as the context tag.  A tag must be greater
+** than 0.
+*/
+__GLXcontext *__glXLookupContextByTag(__GLXclientState *cl, GLXContextTag tag)
+{
+    int num = cl->numCurrentContexts;
+
+    if (tag < 1 || tag > num) {
+	return 0;
+    } else {
+	return cl->currentContexts[tag-1];
+    }
+}
+
+DrawablePtr __glXLookupDrawableByTag(__GLXclientState *cl, GLXContextTag tag)
+{
+    int num = cl->numCurrentContexts;
+
+    if (tag < 1 || tag > num) {
+	return 0;
+    } else {
+	return cl->currentDrawables[tag-1];
+    }
+}
+
+/*****************************************************************************/
+
+static void StopUsingContext(__GLXcontext *glxc)
+{
+    if (glxc) {
+	if (glxc == __glXLastContext) {
+	    /* Tell server GL library */
+	    __glXLastContext = 0;
+	}
+	glxc->isCurrent = GL_FALSE;
+	if (!glxc->idExists) {
+	    __glXFreeContext(glxc);
+	}
+    }
+}
+
+static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
+{
+    glxc->isCurrent = GL_TRUE;
+}
+
+/*****************************************************************************/
+/*
+** Make an OpenGL context and drawable current.
+*/
+static int MakeCurrent(__GLXclientState *cl,
+                       GLXDrawable drawable,
+                       GLXDrawable readdrawable,
+		       GLXContextID context,
+		       GLXContextTag oldContextTag)
+{
+    ClientPtr client = cl->client;
+    DrawablePtr pDraw = NULL;
+    DrawablePtr pReadDraw = NULL;
+    xGLXMakeCurrentReadSGIReply new_reply;
+    xGLXMakeCurrentReq *be_req;
+    xGLXMakeCurrentReply be_reply;
+    xGLXMakeContextCurrentReq *be_new_req;
+    xGLXMakeContextCurrentReply be_new_reply;
+    GLXDrawable drawId = drawable;
+    GLXDrawable readId = readdrawable;
+    GLXContextID contextId = context;
+    __GLXpixmap *pGlxPixmap = 0;
+    __GLXpixmap *pReadGlxPixmap = 0;
+    __GLXcontext *glxc, *prevglxc;
+    GLXContextTag tag = oldContextTag;
+    WindowPtr pWin = NULL;
+    WindowPtr pReadWin = NULL;
+    __glXWindow *pGlxWindow = NULL;
+    __glXWindow *pGlxReadWindow = NULL;
+    __glXPbuffer *pGlxPbuffer = NULL;
+    __glXPbuffer *pGlxReadPbuffer = NULL;
+#ifdef PANORAMIX
+    PanoramiXRes *pXinDraw = NULL;
+    PanoramiXRes *pXinReadDraw = NULL;
+#endif
+    int from_screen = 0;
+    int to_screen = 0;
+    int s, rc;
+
+    /*
+    ** If one is None and the other isn't, it's a bad match.
+    */
+    if ((drawId == None && contextId != None) ||
+	(drawId != None && contextId == None)) {
+	return BadMatch;
+    }
+    
+    /*
+    ** Lookup old context.  If we have one, it must be in a usable state.
+    */
+    if (tag != 0) {
+	prevglxc = __glXLookupContextByTag(cl, tag);
+	if (!prevglxc) {
+	    /*
+	    ** Tag for previous context is invalid.
+	    */
+	    return __glXBadContextTag;
+	}
+    } else {
+	prevglxc = 0;
+    }
+
+    /*
+    ** Lookup new context.  It must not be current for someone else.
+    */
+    if (contextId != None) {
+	dixLookupResourceByType((pointer*) &glxc, contextId, __glXContextRes,
+				NullClient, DixUnknownAccess);
+	if (!glxc) {
+	    client->errorValue = contextId;
+	    return __glXBadContext;
+	}
+	if ((glxc != prevglxc) && glxc->isCurrent) {
+	    /* Context is current to somebody else */
+	    return BadAccess;
+	}
+    } else {
+	/* Switching to no context.  Ignore new drawable. */
+	glxc = 0;
+    }
+
+    if (drawId != None) {
+	rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
+	if (rc == Success) {
+	    if (pDraw->type == DRAWABLE_WINDOW) {
+		/*
+		** Drawable is an X Window.
+		*/
+	        VisualID vid;
+		pWin = (WindowPtr)pDraw;
+		vid = wVisual(pWin);
+
+		new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
+		new_reply.writeType = GLX_WINDOW_TYPE;
+
+		/*
+		** Check if window and context are similar.
+		*/
+		if ((vid != glxc->pVisual->vid) ||
+		    (pWin->drawable.pScreen != glxc->pScreen)) {
+		    client->errorValue = drawId;
+		    return BadMatch;
+		}
+
+		from_screen = to_screen = pWin->drawable.pScreen->myNum;
+
+	    } else {
+		/*
+		** An X Pixmap is not allowed as a parameter (a GLX Pixmap
+		** is, but it must first be created with glxCreateGLXPixmap).
+		*/
+		client->errorValue = drawId;
+		return __glXBadDrawable;
+	    }
+	}
+
+        if (!pDraw) {
+	    dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
+				    __glXPixmapRes, NullClient,
+				    DixUnknownAccess);
+	    if (pGlxPixmap) {
+		/*
+		** Check if pixmap and context are similar.
+		*/
+		if (pGlxPixmap->pScreen != glxc->pScreen ||
+		    pGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
+		    client->errorValue = drawId;
+		    return BadMatch;
+		}
+		pDraw = pGlxPixmap->pDraw;
+
+		new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : 
+		                      pGlxPixmap->pGlxVisual->vid);
+
+		new_reply.writeType = GLX_PIXMAP_TYPE;
+
+		from_screen = to_screen = pGlxPixmap->pScreen->myNum;
+
+	    }
+	}
+
+	if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	   dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
+                                   __glXWindowRes, NullClient,
+                                   DixUnknownAccess);
+            if (pGlxWindow) {
+                /*
+                ** Drawable is a GLXWindow.
+                **
+                ** Check if GLX window and context are similar.
+                */
+                if (pGlxWindow->pScreen != glxc->pScreen ||
+                    pGlxWindow->pGlxFBConfig != glxc->pFBConfig) {
+                    client->errorValue = drawId;
+                    return BadMatch;
+                }
+
+                pDraw = pGlxWindow->pDraw;
+                new_reply.writeVid = pGlxWindow->pGlxFBConfig->id;
+                new_reply.writeType = GLX_GLXWINDOW_TYPE;
+            }
+
+	}
+
+	if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	   dixLookupResourceByType((pointer*) &pGlxPbuffer, drawId,
+                                   __glXPbufferRes, NullClient,
+                                   DixUnknownAccess);
+	   if (pGlxPbuffer) {
+                if (pGlxPbuffer->pScreen != glxc->pScreen ||
+                    pGlxPbuffer->pFBConfig != glxc->pFBConfig) {
+                    client->errorValue = drawId;
+                    return BadMatch;
+                }
+
+		pDraw = (DrawablePtr)pGlxPbuffer;
+                new_reply.writeVid = pGlxPbuffer->pFBConfig->id;
+                new_reply.writeType = GLX_PBUFFER_TYPE;
+	   }
+	}
+
+	if (!pDraw) {
+	   /*
+    	    ** Drawable is not a Window , GLXWindow or a GLXPixmap.
+	    */
+	   client->errorValue = drawId;
+	   return __glXBadDrawable;
+	}
+
+    } else {
+	pDraw = 0;
+    }
+
+    if (readId != None && readId != drawId ) {
+	rc = dixLookupDrawable(&pReadDraw, readId, client, 0, DixReadAccess);
+	if (rc == Success) {
+	    if (pReadDraw->type == DRAWABLE_WINDOW) {
+		/*
+		** Drawable is an X Window.
+		*/
+	        VisualID vid;
+		pReadWin = (WindowPtr)pDraw;
+		vid = wVisual(pReadWin);
+
+		new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
+		new_reply.readType = GLX_WINDOW_TYPE;
+
+		/*
+		** Check if window and context are similar.
+		*/
+		if ((vid != glxc->pVisual->vid) ||
+		    (pReadWin->drawable.pScreen != glxc->pScreen)) {
+		    client->errorValue = readId;
+		    return BadMatch;
+		}
+
+	    } else {
+
+		/*
+		** An X Pixmap is not allowed as a parameter (a GLX Pixmap
+		** is, but it must first be created with glxCreateGLXPixmap).
+		*/
+		client->errorValue = readId;
+		return __glXBadDrawable;
+	    }
+	}
+
+	if (!pReadDraw) {
+	    dixLookupResourceByType((pointer*) &pReadGlxPixmap, readId,
+				    __glXPixmapRes, NullClient,
+				    DixUnknownAccess);
+	    if (pReadGlxPixmap) {
+		/*
+		** Check if pixmap and context are similar.
+		*/
+		if (pReadGlxPixmap->pScreen != glxc->pScreen ||
+		    pReadGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
+		    client->errorValue = readId;
+		    return BadMatch;
+		}
+		pReadDraw = pReadGlxPixmap->pDraw;
+
+		new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id :
+		                     pReadGlxPixmap->pGlxVisual->vid );
+		new_reply.readType = GLX_PIXMAP_TYPE;
+
+	    }
+	}
+
+	if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	   dixLookupResourceByType((pointer*) &pGlxReadWindow, readId,
+                                   __glXWindowRes, NullClient,
+                                   DixUnknownAccess);
+            if (pGlxReadWindow) {
+                /*
+                ** Drawable is a GLXWindow.
+                **
+                ** Check if GLX window and context are similar.
+                */
+                if (pGlxReadWindow->pScreen != glxc->pScreen ||
+                    pGlxReadWindow->pGlxFBConfig != glxc->pFBConfig) {
+                    client->errorValue = readId;
+                    return BadMatch;
+                }
+
+                pReadDraw = pGlxReadWindow->pDraw;
+                new_reply.readVid = pGlxReadWindow->pGlxFBConfig->id;
+                new_reply.readType = GLX_GLXWINDOW_TYPE;
+            }
+	}
+
+	if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	   dixLookupResourceByType((pointer*) &pGlxReadPbuffer, readId,
+                                   __glXPbufferRes, NullClient,
+                                   DixUnknownAccess);
+	   if (pGlxReadPbuffer) {
+                if (pGlxReadPbuffer->pScreen != glxc->pScreen ||
+                    pGlxReadPbuffer->pFBConfig != glxc->pFBConfig) {
+                    client->errorValue = drawId;
+                    return BadMatch;
+                }
+
+		pReadDraw = (DrawablePtr)pGlxReadPbuffer;
+                new_reply.readVid = pGlxReadPbuffer->pFBConfig->id;
+                new_reply.readType = GLX_PBUFFER_TYPE;
+	   }
+	}
+
+	if (!pReadDraw) {
+	   /*
+    	    ** Drawable is neither a Window nor a GLXPixmap.
+	    */
+	   client->errorValue = readId;
+	   return __glXBadDrawable;
+	}
+
+    } else {
+	pReadDraw = pDraw;
+	pReadGlxPixmap = pGlxPixmap;
+	pReadWin = pWin;
+	new_reply.readVid = new_reply.writeVid;
+	new_reply.readType = new_reply.writeType;
+    }
+
+    if (prevglxc) {
+
+	if (prevglxc->pGlxPixmap) {
+	    /*
+	    ** The previous drawable was a glx pixmap, release it.
+	    */
+	    prevglxc->pGlxPixmap->refcnt--;
+	    __glXFreeGLXPixmap( prevglxc->pGlxPixmap );
+	    prevglxc->pGlxPixmap = 0;
+	}
+
+	if (prevglxc->pGlxReadPixmap) {
+	    /*
+	    ** The previous drawable was a glx pixmap, release it.
+	    */
+	    prevglxc->pGlxReadPixmap->refcnt--;
+	    __glXFreeGLXPixmap( prevglxc->pGlxReadPixmap );
+	    prevglxc->pGlxReadPixmap = 0;
+	}
+
+	if (prevglxc->pGlxWindow) {
+	    /*
+	    ** The previous drawable was a glx window, release it.
+	    */
+	    prevglxc->pGlxWindow->refcnt--;
+	    __glXFreeGLXWindow( prevglxc->pGlxWindow );
+	    prevglxc->pGlxWindow = 0;   
+	}
+
+	if (prevglxc->pGlxReadWindow) {
+	    /*
+	    ** The previous drawable was a glx window, release it.
+	    */
+	    prevglxc->pGlxReadWindow->refcnt--;
+	    __glXFreeGLXWindow( prevglxc->pGlxReadWindow );
+	    prevglxc->pGlxReadWindow = 0;   
+	}
+
+	if (prevglxc->pGlxPbuffer) {
+	    /*
+	    ** The previous drawable was a glx Pbuffer, release it.
+	    */
+	    prevglxc->pGlxPbuffer->refcnt--;
+	    __glXFreeGLXPbuffer( prevglxc->pGlxPbuffer );
+	    prevglxc->pGlxPbuffer = 0;   
+	}
+
+	if (prevglxc->pGlxReadPbuffer) {
+	    /*
+	    ** The previous drawable was a glx Pbuffer, release it.
+	    */
+	    prevglxc->pGlxReadPbuffer->refcnt--;
+	    __glXFreeGLXPbuffer( prevglxc->pGlxReadPbuffer );
+	    prevglxc->pGlxReadPbuffer = 0;   
+	}
+
+	ChangeCurrentContext(cl, glxc, tag);
+	ChangeCurrentContext(cl, glxc, tag);
+	StopUsingContext(prevglxc);
+    } else {
+	tag = AddCurrentContext(cl, glxc, pDraw);
+    }
+    if (glxc) {
+
+       glxc->pGlxPixmap = pGlxPixmap;
+       glxc->pGlxReadPixmap = pReadGlxPixmap;
+       glxc->pGlxWindow = pGlxWindow;
+       glxc->pGlxReadWindow = pGlxReadWindow;
+       glxc->pGlxPbuffer = pGlxPbuffer;
+       glxc->pGlxReadPbuffer = pGlxReadPbuffer;
+
+	if (pGlxPixmap) {
+	    pGlxPixmap->refcnt++;
+	}
+
+	if (pReadGlxPixmap) {
+	    pReadGlxPixmap->refcnt++;
+	}
+
+	if (pGlxWindow) {
+	   pGlxWindow->refcnt++;
+	}
+
+	if (pGlxReadWindow) {
+	   pGlxReadWindow->refcnt++;
+	}
+
+	if (pGlxPbuffer) {
+	   pGlxPbuffer->refcnt++;
+	}
+
+	if (pGlxReadPbuffer) {
+	   pGlxReadPbuffer->refcnt++;
+	}
+
+	StartUsingContext(cl, glxc);
+	new_reply.contextTag = tag;
+    } else {
+	new_reply.contextTag = 0;
+    }
+    new_reply.length = 0;
+    new_reply.type = X_Reply;
+    new_reply.sequenceNumber = client->sequence;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+
+       if (pDraw && new_reply.writeType != GLX_PBUFFER_TYPE) {
+	  dixLookupResourceByClass((pointer*) &pXinDraw,
+				   pDraw->id, XRC_DRAWABLE,
+				   client, DixReadAccess);
+       }
+
+       if (pReadDraw && pReadDraw != pDraw && 
+	     new_reply.readType != GLX_PBUFFER_TYPE) {
+	  dixLookupResourceByClass((pointer*) &pXinReadDraw,
+				   pReadDraw->id, XRC_DRAWABLE,
+				   client, DixReadAccess);
+       }
+       else {
+	  pXinReadDraw = pXinDraw;
+       }
+    }
+#endif
+
+
+    /* send the MakeCurrent request to all required
+     * back-end servers.
+     */
+    for (s = from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+       unsigned int be_draw = None;
+       unsigned int be_read_draw = None;
+
+       if (pGlxPixmap) {
+	   be_draw = pGlxPixmap->be_xids[s];
+       }
+       else if (pGlxPbuffer) {
+	  be_draw = pGlxPbuffer->be_xids[s];
+       }
+#ifdef PANORAMIX
+       else if (pXinDraw) {
+	  dixLookupWindow(&pWin, pXinDraw->info[s].id, client, DixReadAccess);
+       }
+#endif
+       else if (pGlxWindow) {
+	  pWin = (WindowPtr)pGlxWindow->pDraw;
+       }
+
+       if (pWin && be_draw == None) {
+	   be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   if (!be_draw) {
+	      /* it might be that the window did not created yet on the */
+	      /* back-end server (lazy window creation option), force   */
+	      /* creation of the window */
+	      dmxCreateAndRealizeWindow( pWin, TRUE );
+	      be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   }
+       }
+
+       /*
+	* Before sending the MakeCurrent request - sync the
+	* X11 connection to the back-end servers to make sure
+	* that drawable is already created
+	*/
+       dmxSync( dmxScreen, 1 ); 
+
+       if (drawId == readId) {
+	  LockDisplay(dpy);
+	  GetReq(GLXMakeCurrent, be_req);
+	  be_req->reqType = dmxScreen->glxMajorOpcode;
+	  be_req->glxCode = X_GLXMakeCurrent;
+	  be_req->drawable = be_draw;
+	  be_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
+	  be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
+	  if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) {
+
+	     /* The make current failed */
+	     UnlockDisplay(dpy);
+	     SyncHandle();
+	     return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
+	  }
+
+	  UnlockDisplay(dpy);
+       	  SyncHandle();
+
+	  SetCurrentBackEndTag( cl, tag, s, be_reply.contextTag );
+       }
+       else {
+
+	  if (pReadGlxPixmap) {
+	     be_read_draw = pReadGlxPixmap->be_xids[s];
+	  }
+	  else if (pGlxReadPbuffer) {
+	     be_read_draw = pGlxReadPbuffer->be_xids[s];
+	  }
+#ifdef PANORAMIX
+	  else if (pXinReadDraw) {
+	     dixLookupWindow(&pReadWin, pXinReadDraw->info[s].id, client,
+			     DixReadAccess);
+   	  }
+#endif
+	  else if (pGlxReadWindow) {
+	     pReadWin = (WindowPtr)pGlxReadWindow->pDraw;
+	  }
+
+      	  if (pReadWin && be_read_draw == None) {
+  	     be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
+	   if (!be_read_draw) {
+	      /* it might be that the window did not created yet on the */
+	      /* back-end server (lazy window creation option), force   */
+	      /* creation of the window */
+	      dmxCreateAndRealizeWindow( pReadWin, TRUE );
+	      be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
+              dmxSync( dmxScreen, 1 ); 
+	   }
+     	  }
+
+	  if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+	     LockDisplay(dpy);
+	     GetReq(GLXMakeContextCurrent, be_new_req);
+	     be_new_req->reqType = dmxScreen->glxMajorOpcode;
+	     be_new_req->glxCode = X_GLXMakeContextCurrent;
+	     be_new_req->drawable = be_draw;
+	     be_new_req->readdrawable = be_read_draw;
+	     be_new_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
+	     be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
+	     if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) {
+
+		/* The make current failed */
+		UnlockDisplay(dpy);
+   		SyncHandle();
+   		return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
+   	     }
+
+   	     UnlockDisplay(dpy);
+      	     SyncHandle();
+
+   	     SetCurrentBackEndTag( cl, tag, s, be_new_reply.contextTag );
+	  }
+	  else if (glxIsExtensionSupported("GLX_SGI_make_current_read")) {
+	     xGLXMakeCurrentReadSGIReq *ext_req;
+	     xGLXVendorPrivateWithReplyReq *vpreq;
+             xGLXMakeCurrentReadSGIReply ext_reply;
+
+	     LockDisplay(dpy);
+	     GetReqExtra(GLXVendorPrivateWithReply, 
+		         sz_xGLXMakeCurrentReadSGIReq - sz_xGLXVendorPrivateWithReplyReq,
+		         vpreq);
+	     ext_req = (xGLXMakeCurrentReadSGIReq *)vpreq;
+	     ext_req->reqType = dmxScreen->glxMajorOpcode;
+	     ext_req->glxCode = X_GLXVendorPrivateWithReply;
+	     ext_req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
+	     ext_req->drawable = be_draw;
+	     ext_req->readable = be_read_draw;
+	     ext_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
+	     ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
+	     if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) {
+
+		/* The make current failed */
+		UnlockDisplay(dpy);
+   		SyncHandle();
+   		return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
+   	     }
+
+   	     UnlockDisplay(dpy);
+      	     SyncHandle();
+
+   	     SetCurrentBackEndTag( cl, tag, s, ext_reply.contextTag );
+
+	  }
+	  else {
+	     return BadMatch;
+	  }
+       }
+
+       XFlush( dpy );
+    }
+
+    if (client->swapped) {
+	__glXSwapMakeCurrentReply(client, &new_reply);
+    } else {
+	WriteToClient(client, sz_xGLXMakeContextCurrentReply, (char *)&new_reply);
+    }
+
+    return Success;
+}
+
+int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
+
+    return( MakeCurrent(cl, req->drawable, req->drawable,
+	                req->context, req->oldContextTag ) );
+}
+
+int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
+
+    return( MakeCurrent(cl, req->drawable, req->readdrawable,
+	                req->context, req->oldContextTag ) );
+}
+
+int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
+
+    return( MakeCurrent(cl, req->drawable, req->readable,
+	                req->context, req->oldContextTag ) );
+}
+
+int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
+    xGLXIsDirectReply reply;
+    __GLXcontext *glxc;
+
+    /*
+    ** Find the GL context.
+    */
+    dixLookupResourceByType((pointer*) &glxc, req->context, __glXContextRes,
+                            NullClient, DixUnknownAccess);
+    if (!glxc) {
+	client->errorValue = req->context;
+	return __glXBadContext;
+    }
+
+    reply.isDirect = 0;
+    reply.length = 0;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if (client->swapped) {
+	__glXSwapIsDirectReply(client, &reply);
+    } else {
+	WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
+    }
+
+    return Success;
+}
+
+int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+/*    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; */
+    xGLXQueryVersionReply reply;
+
+    /*
+    ** Server should take into consideration the version numbers sent by the
+    ** client if it wants to work with older clients; however, in this
+    ** implementation the server just returns its version number.
+    */
+    reply.majorVersion = __glXVersionMajor;
+    reply.minorVersion = __glXVersionMinor;
+    reply.length = 0;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if (client->swapped) {
+	__glXSwapQueryVersionReply(client, &reply);
+    } else {
+	WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
+    }
+    return Success;
+}
+
+int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
+    xGLXWaitGLReq *be_req = (xGLXWaitGLReq *)pc;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+    __GLXcontext *glxc = NULL;
+    
+    if (req->contextTag != 0) {
+	glxc = __glXLookupContextByTag(cl, req->contextTag);
+	if (glxc) {
+	   from_screen = to_screen = glxc->pScreen->myNum;
+	}
+    }
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReq(GLXWaitGL,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXWaitGL;
+       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       XSync(dpy, False);
+    }
+    
+    return Success;
+}
+
+int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
+    xGLXWaitXReq *be_req;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+    __GLXcontext *glxc = NULL;
+    
+    if (req->contextTag != 0) {
+	glxc = __glXLookupContextByTag(cl, req->contextTag);
+	if (glxc) {
+	   from_screen = to_screen = glxc->pScreen->myNum;
+	}
+    }
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       dmxSync( dmxScreen, 1 );
+
+       LockDisplay(dpy);
+       GetReq(GLXWaitX,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXWaitX;
+       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       XFlush( dpy );
+    }
+
+    return Success;
+}
+
+int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXCopyContextReq *be_req;
+    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
+    GLXContextID source = req->source;
+    GLXContextID dest = req->dest;
+    GLXContextTag tag = req->contextTag;
+    unsigned long mask = req->mask;
+    __GLXcontext *src, *dst;
+    int s;
+    int from_screen = 0;
+    int to_screen = 0;
+
+    /*
+    ** Check that each context exists.
+    */
+    dixLookupResourceByType((pointer*) &src, source, __glXContextRes,
+                            NullClient, DixUnknownAccess);
+    if (!src) {
+	client->errorValue = source;
+	return __glXBadContext;
+    }
+    dixLookupResourceByType((pointer*) &dst, dest, __glXContextRes,
+                            NullClient, DixUnknownAccess);
+    if (!dst) {
+	client->errorValue = dest;
+	return __glXBadContext;
+    }
+
+    /*
+    ** They must be in the same address space, and same screen.
+    */
+    if (src->pGlxScreen != dst->pGlxScreen) {
+	client->errorValue = source;
+	return BadMatch;
+    }
+
+    /*
+    ** The destination context must not be current for any client.
+    */
+    if (dst->isCurrent) {
+	client->errorValue = dest;
+	return BadAccess;
+    }
+
+    if (tag) {
+	__GLXcontext *tagcx = __glXLookupContextByTag(cl, tag);
+	
+	if (!tagcx) {
+	    return __glXBadContextTag;
+	}
+	if (tagcx != src) {
+	    /*
+	    ** This would be caused by a faulty implementation of the client
+	    ** library.
+	    */
+	    return BadMatch;
+	}
+    }
+
+    from_screen = to_screen = src->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReq(GLXCopyContext,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXCopyContext;
+       be_req->source = (unsigned int)src->real_ids[s-from_screen];
+       be_req->dest = (unsigned int)dst->real_ids[s-from_screen];
+       be_req->mask = mask;
+       be_req->contextTag = (tag ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    return Success;
+}
+
+int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
+    xGLXGetVisualConfigsReply reply;
+    __GLXscreenInfo *pGlxScreen;
+    __GLXvisualConfig *pGlxVisual;
+    CARD32 buf[__GLX_TOTAL_CONFIG];
+    unsigned int screen;
+    int i, p;
+
+    screen = req->screen;
+    if (screen >= screenInfo.numScreens) {
+	/* The client library must send a valid screen number. */
+	client->errorValue = screen;
+	return BadValue;
+    }
+    pGlxScreen = &__glXActiveScreens[screen];
+
+    reply.numVisuals = pGlxScreen->numGLXVisuals;
+    reply.numProps = __GLX_TOTAL_CONFIG;
+    reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
+		    __GLX_TOTAL_CONFIG) >> 2;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
+
+    for (i=0; i < pGlxScreen->numVisuals; i++) {
+	pGlxVisual = &pGlxScreen->pGlxVisual[i];
+	if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
+	    /* not a usable visual */
+	    continue;
+	}
+	p = 0;
+	buf[p++] = pGlxVisual->vid;
+	buf[p++] = pGlxVisual->class;
+	buf[p++] = pGlxVisual->rgba;
+
+	buf[p++] = pGlxVisual->redSize;
+	buf[p++] = pGlxVisual->greenSize;
+	buf[p++] = pGlxVisual->blueSize;
+	buf[p++] = pGlxVisual->alphaSize;
+	buf[p++] = pGlxVisual->accumRedSize;
+	buf[p++] = pGlxVisual->accumGreenSize;
+	buf[p++] = pGlxVisual->accumBlueSize;
+	buf[p++] = pGlxVisual->accumAlphaSize;
+
+	buf[p++] = pGlxVisual->doubleBuffer;
+	buf[p++] = pGlxVisual->stereo;
+
+	buf[p++] = pGlxVisual->bufferSize;
+	buf[p++] = pGlxVisual->depthSize;
+	buf[p++] = pGlxVisual->stencilSize;
+	buf[p++] = pGlxVisual->auxBuffers;
+	buf[p++] = pGlxVisual->level;
+	/* 
+	** Add token/value pairs for extensions.
+	*/
+	buf[p++] = GLX_VISUAL_CAVEAT_EXT;
+	buf[p++] = pGlxVisual->visualRating;
+	buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
+	buf[p++] = pGlxVisual->transparentPixel;
+	buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
+	buf[p++] = pGlxVisual->transparentRed;
+	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
+	buf[p++] = pGlxVisual->transparentGreen;
+	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
+	buf[p++] = pGlxVisual->transparentBlue;
+	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
+	buf[p++] = pGlxVisual->transparentAlpha;
+	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
+	buf[p++] = pGlxVisual->transparentIndex;
+	buf[p++] = GLX_SAMPLES_SGIS;
+	buf[p++] = pGlxVisual->multiSampleSize;
+	buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
+	buf[p++] = pGlxVisual->nMultiSampleBuffers;
+	buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
+	buf[p++] = pGlxVisual->visualSelectGroup;
+
+	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
+		(char *)buf);
+    }
+    return Success;
+}
+
+/*
+** Create a GLX Pixmap from an X Pixmap.
+*/
+static int CreateGLXPixmap(__GLXclientState *cl,
+                    VisualID visual, GLXFBConfigID fbconfigId,
+		    int screenNum, XID pixmapId, XID glxpixmapId )
+{
+    ClientPtr client = cl->client;
+    xGLXCreateGLXPixmapReq *be_req;
+    xGLXCreatePixmapReq *be_new_req;
+    DrawablePtr pDraw;
+    ScreenPtr pScreen;
+    VisualPtr pVisual;
+    __GLXpixmap *pGlxPixmap;
+    __GLXscreenInfo *pGlxScreen;
+    __GLXvisualConfig *pGlxVisual;
+    __GLXFBConfig *pFBConfig;
+    int i, s, rc;
+    int from_screen, to_screen;
+#ifdef PANORAMIX
+    PanoramiXRes *pXinDraw = NULL;
+#endif
+
+    rc = dixLookupDrawable(&pDraw, pixmapId, client, M_DRAWABLE_PIXMAP,
+			   DixAddAccess);
+    if (rc != Success)
+	return rc;
+
+    /*
+    ** Check if screen of visual matches screen of pixmap.
+    */
+    pScreen = pDraw->pScreen;
+    if (screenNum != pScreen->myNum) {
+	return BadMatch;
+    }
+
+    if (fbconfigId == 0 && visual == 0) {
+	  return BadValue;
+    }
+
+    if (fbconfigId != None) {
+       pFBConfig = glxLookupFBConfig( fbconfigId );
+       if (!pFBConfig) {
+	  client->errorValue = fbconfigId;
+	  return BadValue;
+       }
+       visual = pFBConfig->associatedVisualId;
+    }
+    else {
+       pFBConfig = NULL;
+    }
+
+    if (visual != None) {
+       /*
+	** Find the VisualRec for this visual.
+	*/
+       pVisual = pScreen->visuals;
+       for (i=0; i < pScreen->numVisuals; i++, pVisual++) {
+	  if (pVisual->vid == visual) {
+	     break;
+	  }
+       }
+       if (i == pScreen->numVisuals) {
+	  client->errorValue = visual;
+	  return BadValue;
+       }
+       /*
+	** Check if depth of visual matches depth of pixmap.
+	*/
+       if (pVisual->nplanes != pDraw->depth) {
+	  client->errorValue = visual;
+	  return BadMatch;
+       }
+
+       /*
+	** Get configuration of the visual.
+	*/
+       pGlxScreen = &__glXActiveScreens[screenNum];
+       pGlxVisual = pGlxScreen->pGlxVisual;
+       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
+	  if (pGlxVisual->vid == visual) {
+	     break;
+	  }
+       }
+       if (i == pGlxScreen->numVisuals) {
+	  /*
+	   ** Visual not support on this screen by this OpenGL implementation.
+	   */
+	  client->errorValue = visual;
+	  return BadValue;
+       }
+
+
+       /* find the FBConfig for that visual (if any) */
+       if ( pFBConfig == NULL ) {
+	   pFBConfig = glxLookupFBConfigByVID( visual );
+
+	   if ( pFBConfig == NULL ) {
+	      /*
+               * visual does not have an FBConfig ???
+	      client->errorValue = visual;
+	      return BadValue;
+	       */
+	   }
+       }
+    }
+    else {
+       pVisual = NULL;
+       pGlxVisual = NULL;
+       pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
+    }
+
+    pGlxPixmap = (__GLXpixmap *) malloc(sizeof(__GLXpixmap));
+    if (!pGlxPixmap) {
+	return BadAlloc;
+    }
+    pGlxPixmap->be_xids = (XID *) malloc(sizeof(XID) * screenInfo.numScreens);
+    if (!pGlxPixmap->be_xids) {
+        free( pGlxPixmap );
+	return BadAlloc;
+    }
+
+    pGlxPixmap->pDraw = pDraw;
+    pGlxPixmap->pGlxScreen = pGlxScreen;
+    pGlxPixmap->pGlxVisual = pGlxVisual;
+    pGlxPixmap->pFBConfig = pFBConfig;
+    pGlxPixmap->pScreen = pScreen;
+    pGlxPixmap->idExists = True;
+    pGlxPixmap->refcnt = 0;
+
+    /*
+    ** Bump the ref count on the X pixmap so it won't disappear.
+    */
+    ((PixmapPtr) pDraw)->refcnt++;
+
+    /*
+     * send the request to the back-end server(s)
+     */
+    from_screen = to_screen = screenNum;
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+
+       dixLookupResourceByClass((pointer*) &pXinDraw,
+				pDraw->id, XRC_DRAWABLE,
+				client, DixReadAccess);
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+       Pixmap  be_pixmap;
+       DrawablePtr pRealDraw = pDraw;
+
+#ifdef PANORAMIX
+       if (pXinDraw) {
+	   dixLookupDrawable(&pRealDraw, pXinDraw->info[s].id, client, 0,
+			     DixAddAccess);
+       }
+#endif
+
+       be_pixmap = (DMX_GET_PIXMAP_PRIV((PixmapPtr)pRealDraw))->pixmap;
+
+       /* make sure pixmap already created on back-end */
+       dmxSync( dmxScreen, 1 );
+
+       if ( pFBConfig && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+       	  __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
+	  
+	  LockDisplay(dpy);
+	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
+	  GetReq(GLXCreatePixmap,be_new_req);
+	  be_new_req->reqType = dmxScreen->glxMajorOpcode;
+	  be_new_req->glxCode = X_GLXCreatePixmap;
+	  be_new_req->screen = DefaultScreen(dpy);
+	  be_new_req->fbconfig = be_FBConfig->id;
+	  be_new_req->pixmap = (unsigned int)be_pixmap;
+	  be_new_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
+	  be_new_req->numAttribs = 0;
+	  UnlockDisplay(dpy);
+	  SyncHandle();
+       }
+       else if (pFBConfig && glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
+	  __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
+	  xGLXCreateGLXPixmapWithConfigSGIXReq *ext_req;
+	  xGLXVendorPrivateReq *vpreq;
+	  
+	  LockDisplay(dpy);
+	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
+	  GetReqExtra(GLXVendorPrivate,
+		      sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateReq,
+		      vpreq);
+	  ext_req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
+	  ext_req->reqType = dmxScreen->glxMajorOpcode;
+	  ext_req->glxCode = X_GLXVendorPrivate;
+	  ext_req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
+	  ext_req->screen = DefaultScreen(dpy);
+	  ext_req->fbconfig = be_FBConfig->id;
+	  ext_req->pixmap = (unsigned int)be_pixmap;
+	  ext_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
+	  UnlockDisplay(dpy);
+	  SyncHandle();
+       }
+       else if (pGlxVisual) {
+	  LockDisplay(dpy);
+	  pGlxPixmap->be_xids[s] = XAllocID(dpy);
+	  GetReq(GLXCreateGLXPixmap,be_req);
+	  be_req->reqType = dmxScreen->glxMajorOpcode;
+	  be_req->glxCode = X_GLXCreateGLXPixmap;
+	  be_req->screen = DefaultScreen(dpy);
+	  be_req->visual = (unsigned int)glxMatchGLXVisualInConfigList( 
+	 	pGlxVisual,
+		dmxScreen->glxVisuals,
+		dmxScreen->numGlxVisuals );
+   	  be_req->pixmap = (unsigned int)be_pixmap;
+      	  be_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
+	  UnlockDisplay(dpy);
+	  SyncHandle();
+       }
+       else {
+	  client->errorValue = ( visual ? visual : fbconfigId );
+          free( pGlxPixmap );
+	  return BadValue;
+       }
+
+       XFlush( dpy );
+    }
+
+    if (!(AddResource(glxpixmapId, __glXPixmapRes, pGlxPixmap))) {
+        free( pGlxPixmap );
+	return BadAlloc;
+    }
+
+    return Success;
+}
+
+int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
+
+    return( CreateGLXPixmap(cl, req->visual, None,
+	                    req->screen, req->pixmap, req->glxpixmap) );
+}
+
+int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+
+    return( CreateGLXPixmap(cl, None, req->fbconfig,
+	                    req->screen, req->pixmap, req->glxpixmap) );
+}
+
+int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
+    XID glxpixmap = req->glxpixmap;
+    __GLXpixmap *pGlxPixmap;
+    int s;
+    int from_screen, to_screen;
+
+    /*
+    ** Check if it's a valid GLX pixmap.
+    */
+    dixLookupResourceByType((pointer*) &pGlxPixmap, glxpixmap,
+                            __glXPixmapRes, NullClient, DixUnknownAccess);
+    if (!pGlxPixmap) {
+	client->errorValue = glxpixmap;
+	return __glXBadPixmap;
+    }
+    FreeResource(glxpixmap, FALSE);
+
+    /*
+     * destroy the pixmap on the back-end server(s).
+     */
+    from_screen = to_screen = pGlxPixmap->pDraw->pScreen->myNum;
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       /* make sure pixmap exist in back-end */
+       dmxSync( dmxScreen, 1 );
+
+       LockDisplay(dpy);
+       GetReq(GLXDestroyGLXPixmap,req);
+       req->reqType = dmxScreen->glxMajorOpcode;
+       req->glxCode = X_GLXDestroyGLXPixmap;
+       req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    
+    return Success;
+}
+
+/*****************************************************************************/
+
+/*
+** NOTE: There is no portable implementation for swap buffers as of
+** this time that is of value.  Consequently, this code must be
+** implemented by somebody other than SGI.
+*/
+int __glXDoSwapBuffers(__GLXclientState *cl, XID drawId, GLXContextTag tag)
+{
+    ClientPtr client = cl->client;
+    DrawablePtr pDraw;
+    xGLXSwapBuffersReq *be_req;
+    WindowPtr pWin = NULL;
+    __GLXpixmap *pGlxPixmap = NULL;
+    __GLXcontext *glxc = NULL;
+#ifdef PANORAMIX
+    PanoramiXRes *pXinDraw = NULL;
+#endif
+    __glXWindow *pGlxWindow = NULL;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s, rc;
+    
+    /*
+    ** Check that the GLX drawable is valid.
+    */
+    rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
+    if (rc == Success) {
+        from_screen = to_screen = pDraw->pScreen->myNum;
+
+	if (pDraw->type == DRAWABLE_WINDOW) {
+	    /*
+	    ** Drawable is an X window.
+	    */
+	   pWin = (WindowPtr)pDraw;
+	} else {
+	    /*
+	    ** Drawable is an X pixmap, which is not allowed.
+	    */
+	    client->errorValue = drawId;
+	    return __glXBadDrawable;
+	}
+    } 
+
+    if (!pDraw) {
+	dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
+				__glXPixmapRes, NullClient, DixUnknownAccess);
+	if (pGlxPixmap) {
+	    /*
+	    ** Drawable is a GLX pixmap.
+	    */
+	   pDraw = pGlxPixmap->pDraw;
+	   from_screen = to_screen = pGlxPixmap->pScreen->myNum;
+	}
+    }
+
+    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+       dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
+                               __glXWindowRes, NullClient, DixUnknownAccess);
+       if (pGlxWindow) {
+	  /*
+	   ** Drawable is a GLXWindow.
+	   */
+	  pDraw = pGlxWindow->pDraw;
+	  from_screen = to_screen = pGlxWindow->pScreen->myNum;
+       }
+    }
+
+    if (!pDraw) {
+       /*
+	** Drawable is neither a X window nor a GLX pixmap.
+	*/
+       client->errorValue = drawId;
+       return __glXBadDrawable;
+    }
+
+    if (tag) {
+	glxc = __glXLookupContextByTag(cl, tag);
+	if (!glxc) {
+	    return __glXBadContextTag;
+	}
+    }
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+       dixLookupResourceByClass((pointer*) &pXinDraw,
+				pDraw->id, XRC_DRAWABLE,
+				client, DixReadAccess);
+    }
+#endif
+
+    /* If requested, send a glFinish to all back-end servers before swapping. */
+    if (dmxGLXFinishSwap) {
+	for (s=from_screen; s<=to_screen; s++) {
+	    Display *dpy = GetBackEndDisplay(cl,s);
+	    DMXScreenInfo *dmxScreen = &dmxScreens[s];
+	    xGLXSingleReq *finishReq;
+	    xGLXSingleReply reply;
+
+#define X_GLXSingle 0    /* needed by GetReq below */
+
+	    LockDisplay(dpy);
+	    GetReq(GLXSingle,finishReq);
+	    finishReq->reqType = dmxScreen->glxMajorOpcode;
+	    finishReq->glxCode = X_GLsop_Finish;
+	    finishReq->contextTag = (tag ? GetCurrentBackEndTag(cl,tag,s) : 0);
+	    (void) _XReply(dpy, (xReply*) &reply, 0, False);
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	}
+    }
+
+    /* If requested, send an XSync to all back-end servers before swapping. */
+    if (dmxGLXSyncSwap) {
+	for (s=from_screen; s<=to_screen; s++)
+	    XSync(GetBackEndDisplay(cl,s), False);
+    }
+
+
+    /* send the SwapBuffers request to all back-end servers */
+
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+       unsigned int be_draw = 0;
+
+       if (pGlxPixmap) {
+	  be_draw = (unsigned int)pGlxPixmap->be_xids[s];
+       }
+#ifdef PANORAMIX
+       else if (pXinDraw) {
+	  dixLookupWindow(&pWin, pXinDraw->info[s].id, client, DixReadAccess);
+       }
+#endif
+       else if (pGlxWindow) {
+	  pWin = (WindowPtr)pGlxWindow->pDraw;
+       }
+
+       if (pWin && !be_draw) {
+	   be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   if (!be_draw) {
+	      /* it might be that the window did not created yet on the */
+	      /* back-end server (lazy window creation option), force   */
+	      /* creation of the window */
+	      dmxCreateAndRealizeWindow( pWin, TRUE );
+	      be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   }
+       }
+
+       dmxSync( dmxScreen, 1 );
+
+       LockDisplay(dpy);
+       GetReq(GLXSwapBuffers,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXSwapBuffers;
+       be_req->drawable = be_draw;
+       be_req->contextTag = ( tag ? GetCurrentBackEndTag(cl,tag,s) : 0 );
+       UnlockDisplay(dpy);
+       SyncHandle();
+       XFlush(dpy);
+    }
+
+    return Success;
+}
+
+int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    DrawablePtr pDraw;
+    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
+    GLXContextTag tag = req->contextTag;
+    XID drawId = req->drawable;
+    __GLXpixmap *pGlxPixmap = NULL;
+    __GLXcontext *glxc = NULL;
+    __glXWindow *pGlxWindow = NULL;
+    int rc;
+    
+    /*
+    ** Check that the GLX drawable is valid.
+    */
+    rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixWriteAccess);
+    if (rc == Success) {
+	if (pDraw->type != DRAWABLE_WINDOW) {
+	    /*
+	    ** Drawable is an X pixmap, which is not allowed.
+	    */
+	    client->errorValue = drawId;
+	    return __glXBadDrawable;
+	}
+    } 
+
+    if (!pDraw) {
+	dixLookupResourceByType((pointer*) &pGlxPixmap, drawId,
+				__glXPixmapRes, NullClient, DixUnknownAccess);
+	if (pGlxPixmap) {
+	    /*
+	    ** Drawable is a GLX pixmap.
+	    */
+	   pDraw = pGlxPixmap->pDraw;
+	}
+    }
+
+    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
+       dixLookupResourceByType((pointer*) &pGlxWindow, drawId,
+                               __glXWindowRes, NullClient, DixUnknownAccess);
+       if (pGlxWindow) {
+	  /*
+	   ** Drawable is a GLXWindow.
+	   */
+	  pDraw = pGlxWindow->pDraw;
+       }
+    }
+
+    if (!pDraw) {
+       /*
+	** Drawable is neither a X window nor a GLX pixmap.
+	*/
+       client->errorValue = drawId;
+       return __glXBadDrawable;
+    }
+
+    if (tag) {
+	glxc = __glXLookupContextByTag(cl, tag);
+	if (!glxc) {
+	    return __glXBadContextTag;
+	}
+    }
+
+    if (pDraw &&
+	pDraw->type == DRAWABLE_WINDOW &&
+	DMX_GET_WINDOW_PRIV((WindowPtr)pDraw)->swapGroup) {
+	return SGSwapBuffers(cl, drawId, tag, pDraw);
+    }
+
+    return __glXDoSwapBuffers(cl, drawId, tag);
+}
+
+
+/************************************************************************/
+
+/*
+** Render and Renderlarge are not in the GLX API.  They are used by the GLX
+** client library to send batches of GL rendering commands.
+*/
+
+/*
+** Execute all the drawing commands in a request.
+*/
+int __glXRender(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXRenderReq *req;
+    xGLXRenderReq *be_req;
+    int size;
+    __GLXcontext *glxc;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+
+    /*
+    ** NOTE: much of this code also appears in the byteswapping version of this
+    ** routine, __glXSwapRender().  Any changes made here should also be
+    ** duplicated there.
+    */
+    
+    req = (xGLXRenderReq *) pc;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXRenderReq;
+    size = (req->length << 2) - sz_xGLXRenderReq;
+
+    /*
+     * just forward the request to back-end server(s)
+     */
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReq(GLXRender,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXRender;
+       be_req->length = req->length;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       _XSend(dpy, (const char *)pc, size);
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    return Success;
+}
+
+/*
+** Execute a large rendering request (one that spans multiple X requests).
+*/
+int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXRenderLargeReq *req;
+    xGLXRenderLargeReq *be_req;
+    __GLXcontext *glxc;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+
+    /*
+    ** NOTE: much of this code also appears in the byteswapping version of this
+    ** routine, __glXSwapRenderLarge().  Any changes made here should also be
+    ** duplicated there.
+    */
+    
+    req = (xGLXRenderLargeReq *) pc;
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXRenderLargeReq;
+
+    /*
+     * just forward the request to back-end server(s)
+     */
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       GetReq(GLXRenderLarge,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXRenderLarge;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       be_req->length = req->length;
+       be_req->requestNumber = req->requestNumber;
+       be_req->requestTotal = req->requestTotal;
+       be_req->dataBytes = req->dataBytes;
+       Data(dpy, (const char *)pc, req->dataBytes);
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+    }
+
+    return Success;
+}
+
+
+/************************************************************************/
+
+int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXVendorPrivateReq *req;
+
+    req = (xGLXVendorPrivateReq *) pc;
+
+    switch( req->vendorCode ) {
+
+       case X_GLvop_DeleteTexturesEXT:
+	  return __glXVForwardSingleReq( cl, pc );
+	  break;
+
+       case X_GLXvop_SwapIntervalSGI:
+	  if (glxIsExtensionSupported("SGI_swap_control")) {
+	     return __glXVForwardSingleReq( cl, pc );
+	  }
+	  else {
+	     return Success;
+	  }
+	  break;
+
+#if 0 /* glx 1.3 */
+       case X_GLXvop_CreateGLXVideoSourceSGIX:
+	  break;
+       case X_GLXvop_DestroyGLXVideoSourceSGIX:
+	  break;
+       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+	  break;
+       case X_GLXvop_DestroyGLXPbufferSGIX:
+	  break;
+       case X_GLXvop_ChangeDrawableAttributesSGIX:
+	  break;
+#endif
+
+       case X_GLXvop_BindSwapBarrierSGIX:
+	  return __glXBindSwapBarrierSGIX( cl, pc );
+	  break;
+
+       case X_GLXvop_JoinSwapGroupSGIX:
+	  return __glXJoinSwapGroupSGIX( cl, pc );
+	  break;
+
+       case X_GLXvop_CreateContextWithConfigSGIX:
+	  return __glXCreateContextWithConfigSGIX( cl, pc );
+	  break;
+
+       default:
+	  /*
+	   ** unsupported private request
+	   */
+	  cl->client->errorValue = req->vendorCode;
+	  return __glXUnsupportedPrivateRequest;
+    }
+
+    cl->client->errorValue = req->vendorCode;
+    return __glXUnsupportedPrivateRequest;
+
+}
+
+int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXVendorPrivateWithReplyReq *req;
+
+    req = (xGLXVendorPrivateWithReplyReq *) pc;
+
+    switch( req->vendorCode ) {
+
+       case X_GLvop_GetConvolutionFilterEXT:
+       case X_GLvop_GetConvolutionParameterfvEXT:
+       case X_GLvop_GetConvolutionParameterivEXT:
+       case X_GLvop_GetSeparableFilterEXT:
+       case X_GLvop_GetHistogramEXT:
+       case X_GLvop_GetHistogramParameterivEXT:
+       case X_GLvop_GetMinmaxEXT:
+       case X_GLvop_GetMinmaxParameterfvEXT:
+       case X_GLvop_GetMinmaxParameterivEXT:
+       case X_GLvop_AreTexturesResidentEXT:
+       case X_GLvop_IsTextureEXT:
+	  return( __glXVForwardPipe0WithReply(cl, pc) );
+	  break;
+
+       case X_GLvop_GenTexturesEXT:
+	  return( __glXVForwardAllWithReply(cl, pc) );
+	  break;
+
+
+#if 0 /* glx1.3 */
+       case X_GLvop_GetDetailTexFuncSGIS:
+       case X_GLvop_GetSharpenTexFuncSGIS:
+       case X_GLvop_GetColorTableSGI:
+       case X_GLvop_GetColorTableParameterfvSGI:
+       case X_GLvop_GetColorTableParameterivSGI:
+       case X_GLvop_GetTexFilterFuncSGIS:
+       case X_GLvop_GetInstrumentsSGIX:
+       case X_GLvop_InstrumentsBufferSGIX:
+       case X_GLvop_PollInstrumentsSGIX:
+       case X_GLvop_FlushRasterSGIX:
+       case X_GLXvop_CreateGLXPbufferSGIX:
+       case X_GLXvop_GetDrawableAttributesSGIX:
+       case X_GLXvop_QueryHyperpipeNetworkSGIX:
+       case X_GLXvop_QueryHyperpipeConfigSGIX:
+       case X_GLXvop_HyperpipeConfigSGIX:
+       case X_GLXvop_DestroyHyperpipeConfigSGIX:
+#endif
+       case X_GLXvop_QueryMaxSwapBarriersSGIX:
+	  return( __glXQueryMaxSwapBarriersSGIX(cl, pc) );
+	  break;
+
+       case X_GLXvop_GetFBConfigsSGIX:
+	  return( __glXGetFBConfigsSGIX(cl, pc) );
+	  break;
+
+       case X_GLXvop_MakeCurrentReadSGI:
+	  return( __glXMakeCurrentReadSGI(cl, pc) );
+	  break;
+
+       case X_GLXvop_QueryContextInfoEXT:
+	  return( __glXQueryContextInfoEXT(cl,pc) );
+	  break;
+
+       default:
+	  /*
+	   ** unsupported private request
+	   */
+	  cl->client->errorValue = req->vendorCode;
+	  return __glXUnsupportedPrivateRequest;
+    }
+
+}
+
+int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
+    xGLXQueryExtensionsStringReply reply;
+    GLint screen;
+    size_t length;
+    int len, numbytes;
+    char *be_buf;
+
+#ifdef FWD_QUERY_REQ
+    xGLXQueryExtensionsStringReq *be_req;
+    xGLXQueryExtensionsStringReply be_reply;
+    DMXScreenInfo *dmxScreen;
+    Display *dpy;
+    int slop;
+#endif
+
+    screen = req->screen;
+
+    /*
+    ** Check if screen exists.
+    */
+    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
+	client->errorValue = screen;
+	return BadValue;
+    }
+
+#ifdef FWD_QUERY_REQ
+    dmxScreen = &dmxScreens[screen];
+
+    /* Send the glXQueryServerString request */
+    dpy = GetBackEndDisplay(cl,screen);
+    LockDisplay(dpy);
+    GetReq(GLXQueryExtensionsString,be_req);
+    be_req->reqType = dmxScreen->glxMajorOpcode;
+    be_req->glxCode = X_GLXQueryServerString;
+    be_req->screen = DefaultScreen(dpy);
+    _XReply(dpy, (xReply*) &be_reply, 0, False);
+    len = (int)be_reply.length;
+    numbytes = (int)be_reply.n;
+    slop = numbytes * __GLX_SIZE_INT8 & 3;
+    be_buf = (char *)malloc(numbytes);
+    if (!be_buf) {
+        /* Throw data on the floor */
+        _XEatData(dpy, len);
+    } else {
+        _XRead(dpy, (char *)be_buf, numbytes);
+        if (slop) _XEatData(dpy,4-slop);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+#else
+
+    be_buf = __glXGetServerString(GLX_EXTENSIONS);
+    numbytes = strlen(be_buf) + 1;
+    len = __GLX_PAD(numbytes) >> 2;
+
+#endif
+
+    length = len;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = len;
+    reply.n = numbytes;
+
+    if (client->swapped) {
+        glxSwapQueryExtensionsStringReply(client, &reply, be_buf);
+    } else {
+        WriteToClient(client, sz_xGLXQueryExtensionsStringReply,(char *)&reply);
+        WriteToClient(client, (int)(length << 2), (char *)be_buf);
+    }
+
+    return Success;
+}
+
+int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
+    xGLXQueryServerStringReply reply;
+    int name;
+    GLint screen;
+    size_t length;
+    int len, numbytes;
+    char *be_buf;
+#ifdef FWD_QUERY_REQ
+    xGLXQueryServerStringReq *be_req;
+    xGLXQueryServerStringReply be_reply;
+    DMXScreenInfo *dmxScreen;
+    Display *dpy;
+    int  slop;
+#endif
+
+    name = req->name;
+    screen = req->screen;
+    /*
+    ** Check if screen exists.
+    */
+    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
+	client->errorValue = screen;
+	return BadValue;
+    }
+
+#ifdef FWD_QUERY_REQ
+    dmxScreen = &dmxScreens[screen];
+
+    /* Send the glXQueryServerString request */
+    dpy = GetBackEndDisplay(cl,screen);
+    LockDisplay(dpy);
+    GetReq(GLXQueryServerString,be_req);
+    be_req->reqType = dmxScreen->glxMajorOpcode;
+    be_req->glxCode = X_GLXQueryServerString;
+    be_req->screen = DefaultScreen(dpy);
+    be_req->name = name;
+    _XReply(dpy, (xReply*) &be_reply, 0, False);
+    len = (int)be_reply.length;
+    numbytes = (int)be_reply.n;
+    slop = numbytes * __GLX_SIZE_INT8 & 3;
+    be_buf = (char *)malloc(numbytes);
+    if (!be_buf) {
+        /* Throw data on the floor */
+        _XEatData(dpy, len);
+    } else {
+        _XRead(dpy, (char *)be_buf, numbytes);
+        if (slop) _XEatData(dpy,4-slop);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+#else
+    be_buf = __glXGetServerString(name);
+    numbytes = strlen(be_buf) + 1;
+    len = __GLX_PAD(numbytes) >> 2;
+#endif
+
+    length = len;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = length;
+    reply.n = numbytes;
+
+    if (client->swapped) {
+        glxSwapQueryServerStringReply(client, &reply, be_buf);
+    } else {
+        WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)&reply);
+        WriteToClient(client, (int)(length << 2), be_buf);
+    }
+
+    return Success;
+}
+
+int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
+    xGLXClientInfoReq *be_req;
+    const char *buf;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+   
+    cl->GLClientmajorVersion = req->major;
+    cl->GLClientminorVersion = req->minor;
+    free(cl->GLClientextensions);
+    buf = (const char *)(req+1);
+    cl->GLClientextensions = strdup(buf);
+
+    to_screen = screenInfo.numScreens - 1;
+
+    for (s=from_screen; s<=to_screen; s++)
+    {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReq(GLXClientInfo,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXClientInfo;
+       be_req->major = req->major;
+       be_req->minor = req->minor;
+       be_req->length = req->length;
+       be_req->numbytes = req->numbytes;
+       Data(dpy, buf, req->numbytes);
+
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    return Success;
+}
+
+int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXUseXFontReq *req;
+    xGLXUseXFontReq *be_req;
+    FontPtr pFont;
+    __GLXcontext *glxc = NULL;
+    int from_screen = 0;
+    int to_screen = 0;
+    int s;
+    dmxFontPrivPtr  pFontPriv;
+    DMXScreenInfo *dmxScreen;
+    Display *dpy;
+
+    req = (xGLXUseXFontReq *) pc;
+
+    if (req->contextTag != 0) {
+	glxc = __glXLookupContextByTag(cl, req->contextTag);
+	if (glxc) {
+	   from_screen = to_screen = glxc->pScreen->myNum;
+	}
+    }
+
+    /*
+    ** Font can actually be either the ID of a font or the ID of a GC
+    ** containing a font.
+    */
+    dixLookupResourceByType((pointer*) &pFont, req->font, RT_FONT,
+                            NullClient, DixUnknownAccess);
+    if (!pFont) {
+        GC *pGC;
+        dixLookupResourceByType((pointer*) &pGC, req->font,
+				RT_GC, NullClient,
+				DixUnknownAccess);
+        if (!pGC) {
+	    client->errorValue = req->font;
+            return BadFont;
+	}
+	pFont = pGC->font;
+    }
+
+    pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+
+    for (s=from_screen; s<=to_screen; s++) {
+       dmxScreen = &dmxScreens[s];
+       dpy = GetBackEndDisplay(cl,s);
+
+       dmxSync( dmxScreen, 1 );
+
+       LockDisplay(dpy);
+       GetReq(GLXUseXFont,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXUseXFont;
+       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
+       be_req->font = pFontPriv->font[s]->fid;
+       be_req->first = req->first;
+       be_req->count = req->count;
+       be_req->listBase = req->listBase;
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       XSync( dpy, False );
+    }
+
+    return Success;
+}
+
+/*
+ * start GLX 1.3 here
+ */
+
+int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
+    xGLXGetFBConfigsReply reply;
+    __GLXFBConfig *pFBConfig;
+    CARD32 buf[2 * __GLX_TOTAL_FBCONFIG_PROPS];
+    int numAttribs = __GLX_TOTAL_FBCONFIG_PROPS;
+    unsigned int screen = req->screen;
+    int numFBConfigs, i, p;
+    __GLXscreenInfo *pGlxScreen;
+
+    if (screen >= screenInfo.numScreens) {
+	/* The client library must send a valid screen number. */
+	client->errorValue = screen;
+	return BadValue;
+    }
+
+    pGlxScreen = &__glXActiveScreens[screen];
+    numFBConfigs = __glXNumFBConfigs;
+
+    reply.numFBConfigs = numFBConfigs;
+    reply.numAttribs = numAttribs;
+    reply.length = (numFBConfigs * 2 * numAttribs * __GLX_SIZE_CARD32) >> 2;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if (client->swapped) {
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_SWAP_SHORT(&reply.sequenceNumber);
+	__GLX_SWAP_INT(&reply.length);
+	__GLX_SWAP_INT(&reply.numFBConfigs);
+	__GLX_SWAP_INT(&reply.numAttribs);
+    }
+    WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);
+
+    for (i=0; i < numFBConfigs; i++) {
+       int associatedVisualId = 0;
+       int drawableTypeIndex;
+       pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1) ];
+
+	p = 0;
+	/* core attributes */
+	buf[p++] = GLX_FBCONFIG_ID;
+	buf[p++] = pFBConfig->id;
+	buf[p++] = GLX_BUFFER_SIZE;
+	buf[p++] = pFBConfig->indexBits;
+	buf[p++] = GLX_LEVEL;
+	buf[p++] = pFBConfig->level;
+	buf[p++] = GLX_DOUBLEBUFFER;
+	buf[p++] = pFBConfig->doubleBufferMode;
+	buf[p++] = GLX_STEREO;
+	buf[p++] = pFBConfig->stereoMode;
+	buf[p++] = GLX_AUX_BUFFERS;
+	buf[p++] = pFBConfig->maxAuxBuffers;
+	buf[p++] = GLX_RED_SIZE;
+	buf[p++] = pFBConfig->redBits;
+	buf[p++] = GLX_GREEN_SIZE;
+	buf[p++] = pFBConfig->greenBits;
+	buf[p++] = GLX_BLUE_SIZE;
+	buf[p++] = pFBConfig->blueBits;
+	buf[p++] = GLX_ALPHA_SIZE;
+	buf[p++] = pFBConfig->alphaBits;
+	buf[p++] = GLX_DEPTH_SIZE;
+	buf[p++] = pFBConfig->depthBits;
+	buf[p++] = GLX_STENCIL_SIZE;
+	buf[p++] = pFBConfig->stencilBits;
+	buf[p++] = GLX_ACCUM_RED_SIZE;
+	buf[p++] = pFBConfig->accumRedBits;
+	buf[p++] = GLX_ACCUM_GREEN_SIZE;
+	buf[p++] = pFBConfig->accumGreenBits;
+	buf[p++] = GLX_ACCUM_BLUE_SIZE;
+	buf[p++] = pFBConfig->accumBlueBits;
+	buf[p++] = GLX_ACCUM_ALPHA_SIZE;
+	buf[p++] = pFBConfig->accumAlphaBits;
+	buf[p++] = GLX_RENDER_TYPE;
+	buf[p++] = pFBConfig->renderType;
+	buf[p++] = GLX_DRAWABLE_TYPE;
+	drawableTypeIndex = p;
+	buf[p++] = pFBConfig->drawableType;
+	buf[p++] = GLX_X_VISUAL_TYPE;
+	buf[p++] = pFBConfig->visualType;
+	buf[p++] = GLX_CONFIG_CAVEAT;
+	buf[p++] = pFBConfig->visualCaveat;
+	buf[p++] = GLX_TRANSPARENT_TYPE;
+	buf[p++] = pFBConfig->transparentType;
+	buf[p++] = GLX_TRANSPARENT_RED_VALUE;
+	buf[p++] = pFBConfig->transparentRed;
+	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
+	buf[p++] = pFBConfig->transparentGreen;
+	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
+	buf[p++] = pFBConfig->transparentBlue;
+	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
+	buf[p++] = pFBConfig->transparentAlpha;
+	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
+	buf[p++] = pFBConfig->transparentIndex;
+	buf[p++] = GLX_MAX_PBUFFER_WIDTH;
+	buf[p++] = pFBConfig->maxPbufferWidth;
+	buf[p++] = GLX_MAX_PBUFFER_HEIGHT;
+	buf[p++] = pFBConfig->maxPbufferHeight;
+	buf[p++] = GLX_MAX_PBUFFER_PIXELS;
+	buf[p++] = pFBConfig->maxPbufferPixels;
+
+	/*
+         * find the visual of the back-end server and match a visual
+	 * on the proxy.
+	 * do only once - if a visual is not yet associated.
+	 */
+	if (pFBConfig->associatedVisualId == (unsigned int)-1) {
+	   DMXScreenInfo *dmxScreen = &dmxScreens[screen];
+	   __GLXFBConfig *be_pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1)+screen+1 ];
+	   __GLXvisualConfig *pGlxVisual = NULL;
+	   int v;
+	   int found = 0;
+	   for (v=0; v<dmxScreen->numGlxVisuals; v++) {
+	      if (dmxScreen->glxVisuals[v].vid == be_pFBConfig->associatedVisualId) {
+		 pGlxVisual = &dmxScreen->glxVisuals[v];
+		 break;
+	      }
+	   }
+
+	   if (pGlxVisual) {
+	      for (v=0; v<pGlxScreen->numVisuals; v++) {
+		 if (glxVisualsMatch(&pGlxScreen->pGlxVisual[v], pGlxVisual)) {
+		    associatedVisualId = pGlxScreen->pGlxVisual[v].vid;
+		    found = 1;
+		    break;
+		 }
+	      }
+	   }
+
+	   if (!found) {
+	      associatedVisualId = 0;
+	      pFBConfig->drawableType &= ~(GLX_WINDOW_BIT);
+	      buf[drawableTypeIndex] = pFBConfig->drawableType;
+	   }
+#ifdef PANORAMIX
+	   else if (!noPanoramiXExtension) {
+	      /* convert the associated visualId to the panoramix one */
+	      pFBConfig->associatedVisualId =
+		  PanoramiXTranslateVisualID(screen, v);
+	   }
+#endif
+	}
+	else {
+	   associatedVisualId = pFBConfig->associatedVisualId;
+	}
+
+	buf[p++] = GLX_VISUAL_ID;
+	buf[p++] = associatedVisualId;
+
+	/* SGIS_multisample attributes */
+	buf[p++] = GLX_SAMPLES_SGIS;
+	buf[p++] = pFBConfig->multiSampleSize;
+	buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
+	buf[p++] = pFBConfig->nMultiSampleBuffers;
+
+	/* SGIX_pbuffer specific attributes */
+	buf[p++] = GLX_OPTIMAL_PBUFFER_WIDTH_SGIX;
+	buf[p++] = pFBConfig->optimalPbufferWidth;
+	buf[p++] = GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX;
+	buf[p++] = pFBConfig->optimalPbufferHeight;
+
+	buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
+	buf[p++] = pFBConfig->visualSelectGroup;
+
+	if (client->swapped) {
+	    __GLX_DECLARE_SWAP_VARIABLES;
+	    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+	    __GLX_SWAP_INT_ARRAY((int *)buf, 2*numAttribs);
+	}
+	WriteToClient(client, 2*numAttribs * __GLX_SIZE_CARD32, (char *)buf);
+    }
+    return Success;
+}
+
+int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
+   xGLXGetFBConfigsReq new_req;
+
+   new_req.reqType = req->reqType;
+   new_req.glxCode = req->glxCode;
+   new_req.length = req->length;
+   new_req.screen = req->screen;
+
+   return( __glXGetFBConfigs( cl, (GLbyte *)&new_req ) );
+}
+
+
+int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
+    int screen = req->screen;
+    GLXFBConfigID fbconfigId = req->fbconfig;
+    XID windowId = req->window;
+    XID glxwindowId = req->glxwindow;
+    DrawablePtr pDraw;
+    ScreenPtr pScreen;
+    __glXWindow *pGlxWindow;
+    __GLXFBConfig *pGlxFBConfig = NULL;
+    VisualPtr pVisual;
+    VisualID visId;
+    int i, rc;
+    pointer val;
+
+    /*
+    ** Check if windowId is valid 
+    */
+    rc = dixLookupDrawable(&pDraw, windowId, client, M_DRAWABLE_WINDOW,
+			   DixAddAccess);
+    if (rc != Success)
+	return rc;
+
+    /*
+    ** Check if screen of window matches screen of fbconfig.
+    */
+    pScreen = pDraw->pScreen;
+    if (screen != pScreen->myNum) {
+	return BadMatch;
+    }
+
+    /*
+    ** Find the FBConfigRec for this fbconfigid.
+    */
+    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
+	client->errorValue = fbconfigId;
+	return __glXBadFBConfig;
+    }
+    visId = pGlxFBConfig->associatedVisualId;
+
+    /*
+    ** Check if the fbconfig supports rendering to windows 
+    */
+    if( !(pGlxFBConfig->drawableType & GLX_WINDOW_BIT) ) {
+	return BadMatch;	
+    }
+
+    if (visId != None) {
+       /*
+	** Check if the visual ID is valid for this screen.
+	*/
+       pVisual = pScreen->visuals;
+       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
+	  if (pVisual->vid == visId) {
+	     break;
+	  }
+       }
+       if (i == pScreen->numVisuals) {
+	  client->errorValue = visId;
+	  return BadValue;
+       }
+	
+        /*
+        ** Check if color buffer depth of fbconfig matches depth 
+	** of window.
+        */
+        if (pVisual->nplanes != pDraw->depth) {
+	    return BadMatch;
+	}
+    } else
+	/*
+	** The window was created with no visual that corresponds
+	** to fbconfig 
+	*/
+	return BadMatch;
+
+    /*
+    ** Check if there is already a fbconfig associated with this window
+    */
+    if (Success == dixLookupResourceByType(&val,
+					   glxwindowId, __glXWindowRes,
+					   NullClient, DixUnknownAccess)) {
+	client->errorValue = glxwindowId;
+	return BadAlloc;
+    }
+
+    pGlxWindow = (__glXWindow *) malloc(sizeof(__glXWindow));
+    if (!pGlxWindow) {
+	return BadAlloc;
+    }
+
+    /*
+    ** Register this GLX window as a resource
+    */
+    if (!(AddResource(glxwindowId, __glXWindowRes, pGlxWindow))) {
+	return BadAlloc;
+    }
+
+    pGlxWindow->pDraw = pDraw;
+    pGlxWindow->type = GLX_GLXWINDOW_TYPE;
+    pGlxWindow->idExists = True;
+    pGlxWindow->refcnt = 0;
+    pGlxWindow->pGlxFBConfig = pGlxFBConfig;
+    pGlxWindow->pScreen = pScreen;
+
+    return Success;
+}
+
+int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
+    XID glxwindow = req->glxwindow;
+    pointer val;
+
+    /*
+    ** Check if it's a valid GLX window.
+    */
+    if (Success != dixLookupResourceByType(&val,
+					   glxwindow, __glXWindowRes,
+					   NullClient, DixUnknownAccess)) {
+	client->errorValue = glxwindow;
+	return __glXBadDrawable;
+    }
+    /*
+    ** The glx window destructor will check whether it's current before
+    ** freeing anything.
+    */
+    FreeResource(glxwindow, RT_NONE);	
+
+    return Success;
+}
+
+int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    __GLXcontext *ctx;
+    xGLXQueryContextReq *req;
+    xGLXQueryContextReply reply;
+    int nProps;
+    int *sendBuf, *pSendBuf;
+    int nReplyBytes;
+
+    req = (xGLXQueryContextReq *)pc;
+    dixLookupResourceByType((pointer*) &ctx, req->context, __glXContextRes,
+                            NullClient, DixUnknownAccess);
+    if (!ctx) {
+        client->errorValue = req->context;
+        return __glXBadContext;
+    }
+
+    nProps = 3;
+
+    reply.length = nProps << 1;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.n = nProps;
+
+    nReplyBytes = reply.length << 2;
+    sendBuf = (int *)malloc(nReplyBytes);
+    pSendBuf = sendBuf;
+    *pSendBuf++ = GLX_FBCONFIG_ID;
+    *pSendBuf++ = (int)(ctx->pFBConfig->id);
+    *pSendBuf++ = GLX_RENDER_TYPE;
+    *pSendBuf++ = (int)(ctx->pFBConfig->renderType);
+    *pSendBuf++ = GLX_SCREEN;
+    *pSendBuf++ = (int)(ctx->pScreen->myNum);
+
+    if (client->swapped) {
+        __glXSwapQueryContextReply(client, &reply, sendBuf);
+    } else {
+        WriteToClient(client, sz_xGLXQueryContextReply, (char *)&reply);
+        WriteToClient(client, nReplyBytes, (char *)sendBuf);
+    }
+    free((char *)sendBuf);
+
+    return Success;
+}
+
+int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    __GLXcontext *ctx;
+    xGLXQueryContextInfoEXTReq *req;
+    xGLXQueryContextInfoEXTReply reply;
+    int nProps;
+    int *sendBuf, *pSendBuf;
+    int nReplyBytes;
+
+    req = (xGLXQueryContextInfoEXTReq *)pc;
+    dixLookupResourceByType((pointer*) &ctx,
+			    req->context, __glXContextRes,
+			    client,  DixReadAccess);
+
+    if (!ctx) {
+        client->errorValue = req->context;
+        return __glXBadContext;
+    }
+
+    nProps = 4;
+
+    reply.length = nProps << 1;
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.n = nProps;
+
+    nReplyBytes = reply.length << 2;
+    sendBuf = (int *)malloc(nReplyBytes);
+    pSendBuf = sendBuf;
+    *pSendBuf++ = GLX_SHARE_CONTEXT_EXT;
+    *pSendBuf++ = (int)(ctx->share_id);
+    *pSendBuf++ = GLX_VISUAL_ID_EXT;
+    *pSendBuf++ = (int)(ctx->pVisual ? ctx->pVisual->vid : 0);
+    *pSendBuf++ = GLX_SCREEN_EXT;
+    *pSendBuf++ = (int)(ctx->pScreen->myNum);
+    *pSendBuf++ = GLX_FBCONFIG_ID;
+    *pSendBuf++ = (int)(ctx->pFBConfig ? ctx->pFBConfig->id : 0);
+
+    if (client->swapped) {
+        __glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
+    } else {
+        WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)&reply);
+        WriteToClient(client, nReplyBytes, (char *)sendBuf);
+    }
+    free((char *)sendBuf);
+
+    return Success;
+}
+
+int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
+    xGLXCreatePbufferReq *be_req;
+    int screen = req->screen;
+    GLXFBConfigID fbconfigId = req->fbconfig;
+    GLXPbuffer pbuffer = req->pbuffer;
+    __glXPbuffer *pGlxPbuffer;
+    int numAttribs = req->numAttribs;
+    int *attr;
+    ScreenPtr pScreen;
+    __GLXFBConfig *pGlxFBConfig;
+    __GLXFBConfig *be_pGlxFBConfig;
+    XID be_xid;
+    Display *dpy;
+    DMXScreenInfo *dmxScreen;
+    int s;
+    int from_screen, to_screen;
+
+   /*
+    ** Look up screen and FBConfig.
+    */
+    if (screen >= screenInfo.numScreens) {
+        /* The client library must send a valid screen number. */
+        client->errorValue = screen;
+        return BadValue;
+    }
+    pScreen = screenInfo.screens[screen];
+
+    /*
+    ** Find the FBConfigRec for this fbconfigid.
+    */
+    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
+	client->errorValue = fbconfigId;
+	return __glXBadFBConfig;
+    }
+
+    /*
+    ** Create the GLX part of the Pbuffer.
+    */
+    pGlxPbuffer = (__glXPbuffer *) malloc(sizeof(__glXPbuffer));
+    if (!pGlxPbuffer) {
+        return BadAlloc;
+    }
+
+    pGlxPbuffer->be_xids = (XID *) malloc( sizeof(XID) * screenInfo.numScreens );
+    if (!pGlxPbuffer->be_xids) {
+        free(pGlxPbuffer);
+        return BadAlloc;
+    }
+
+    /*
+     * Allocate an XID on the back-end server(s) and send him the request
+     */
+    from_screen = to_screen = screen;
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       dpy = GetBackEndDisplay(cl,s);
+       be_xid = XAllocID(dpy);
+       dmxScreen = &dmxScreens[s];
+       be_pGlxFBConfig = glxLookupBackEndFBConfig( pGlxFBConfig->id, s );
+       
+       attr = (int *)( req+1 );
+
+       LockDisplay(dpy);
+       GetReqExtra(GLXCreatePbuffer, 2 * numAttribs * __GLX_SIZE_CARD32, be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXCreatePbuffer;
+       be_req->screen = be_pGlxFBConfig->screen;
+       be_req->fbconfig = be_pGlxFBConfig->id;
+       be_req->pbuffer = be_xid;
+       be_req->numAttribs = numAttribs;
+    
+       /* Send attributes */
+       if ( attr != NULL ) {
+	  CARD32 *pc = (CARD32 *)(be_req + 1);
+
+	  while (numAttribs-- > 0) {
+	     *pc++ = *attr++;     /* token */
+	     *pc++ = *attr++;     /* value */
+	  }
+       }
+
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       pGlxPbuffer->be_xids[s] = be_xid;
+    }
+
+
+    pGlxPbuffer->idExists = True;
+    pGlxPbuffer->refcnt = 0;
+    pGlxPbuffer->pFBConfig = pGlxFBConfig;
+    pGlxPbuffer->pScreen = pScreen;
+
+    /*
+    ** Register the resource.
+    */
+    if (!(AddResource(pbuffer, __glXPbufferRes, pGlxPbuffer))) {
+        return BadAlloc;
+    }
+
+    return Success;
+
+}
+
+int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
+{
+    ClientPtr client = cl->client;
+    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
+    xGLXDestroyPbufferReq *be_req;
+    GLXPbuffer pbuffer = req->pbuffer;
+    Display *dpy;
+    int screen;
+    DMXScreenInfo *dmxScreen;
+    __glXPbuffer *pGlxPbuffer;
+    int s;
+    int from_screen, to_screen;
+
+    /*
+    ** Check if it's a valid Pbuffer
+    */
+    dixLookupResourceByType((pointer*) &pGlxPbuffer, pbuffer,
+                            __glXPbufferRes, NullClient, DixUnknownAccess);
+    if (!pGlxPbuffer) {
+	client->errorValue = pbuffer;
+	return __glXBadPbuffer;
+    }
+
+    screen = pGlxPbuffer->pScreen->myNum;
+
+    from_screen = to_screen = screen;
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    for (s=from_screen; s<=to_screen; s++) {
+       dpy = GetBackEndDisplay(cl,s);
+       dmxScreen = &dmxScreens[s];
+
+       /* send the destroy request to the back-end server */
+       LockDisplay(dpy);
+       GetReq(GLXDestroyPbuffer, be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = X_GLXDestroyPbuffer;
+       be_req->pbuffer = pGlxPbuffer->be_xids[s];
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    FreeResource(pbuffer, RT_NONE);	
+
+    return Success;
+}
+
+int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
+{
+   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
+   xGLXGetDrawableAttributesReq *be_req;
+   xGLXGetDrawableAttributesReply reply;
+   ClientPtr client = cl->client;
+   GLXDrawable drawId = req->drawable;
+   GLXDrawable be_drawable = 0;
+   DrawablePtr pDraw = NULL;
+   Display *dpy;
+   int screen, rc;
+   DMXScreenInfo *dmxScreen;
+   CARD32 *attribs = NULL;
+   int attribs_size = 0;
+#ifdef PANORAMIX
+    PanoramiXRes *pXinDraw = NULL;
+#endif
+
+   if (drawId != None) {
+      rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixGetAttrAccess);
+      if (rc == Success && pDraw->type == DRAWABLE_WINDOW) {
+	 WindowPtr pWin = (WindowPtr)pDraw;
+	 be_drawable = 0;
+	 screen = pWin->drawable.pScreen->myNum;
+      } else {
+	 /*
+	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
+	  */
+	 client->errorValue = drawId;
+	 return __glXBadDrawable;
+      }
+
+      if (!pDraw) {
+	 __GLXpixmap *pGlxPixmap;
+	 dixLookupResourceByType((pointer*) &pGlxPixmap,
+				 drawId, __glXPixmapRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxPixmap) {
+		pDraw = pGlxPixmap->pDraw;
+		screen = pGlxPixmap->pScreen->myNum;
+                be_drawable = pGlxPixmap->be_xids[screen];
+	 }
+      }
+
+      if (!pDraw) {
+	 __glXWindow *pGlxWindow;
+	 dixLookupResourceByType((pointer*) &pGlxWindow,
+				 drawId, __glXWindowRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxWindow) {
+	    pDraw = pGlxWindow->pDraw;
+	    screen = pGlxWindow->pScreen->myNum;
+	    be_drawable = 0;
+     	 }
+      }
+
+      if (!pDraw) {
+	 __glXPbuffer *pGlxPbuffer;
+	 dixLookupResourceByType((pointer*) &pGlxPbuffer,
+				 drawId, __glXPbufferRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxPbuffer) {
+    	    pDraw = (DrawablePtr)pGlxPbuffer;
+	    screen = pGlxPbuffer->pScreen->myNum;
+	    be_drawable = pGlxPbuffer->be_xids[screen];
+	 }
+      }
+    }
+
+    if (!pDraw) {
+	/*
+	 ** Drawable is not a Window , GLXWindow or a GLXPixmap.
+	 */
+	client->errorValue = drawId;
+	return __glXBadDrawable;
+   }
+
+   /* if the drawable is a window or GLXWindow - 
+    * we need to find the base id on the back-end server
+    */
+   if (!be_drawable) {
+       WindowPtr pWin = (WindowPtr)pDraw;
+
+#ifdef PANORAMIX
+       if (!noPanoramiXExtension) {
+	  if (Success != dixLookupResourceByClass((pointer*) &pXinDraw,
+						  pDraw->id, XRC_DRAWABLE,
+						  client, DixReadAccess)) {
+	     client->errorValue = drawId;
+	     return __glXBadDrawable;
+	  }
+
+	  dixLookupWindow(&pWin, pXinDraw->info[screen].id, client,
+			  DixReadAccess);
+       }
+#endif
+
+       if (pWin) {
+	   be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   if (!be_drawable) {
+	      /* it might be that the window did not created yet on the */
+	      /* back-end server (lazy window creation option), force   */
+	      /* creation of the window */
+	      dmxCreateAndRealizeWindow( pWin, TRUE );
+	      be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   }
+       }
+       else {
+	  client->errorValue = drawId;
+	  return __glXBadDrawable;
+       }
+   }
+
+
+   /* send the request to the back-end server */
+   dpy = GetBackEndDisplay(cl,screen);
+   dmxScreen = &dmxScreens[screen];
+
+   /* make sure drawable exists on back-end */
+   dmxSync( dmxScreen, 1 );
+
+   LockDisplay(dpy);
+   GetReq(GLXGetDrawableAttributes, be_req);
+   be_req->reqType = dmxScreen->glxMajorOpcode;
+   be_req->glxCode = X_GLXGetDrawableAttributes;
+   be_req->drawable = be_drawable;
+   be_req->length = req->length;
+   if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
+      UnlockDisplay(dpy);
+      SyncHandle();
+      return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
+   }
+
+   if (reply.numAttribs) {
+      attribs_size = 2 * reply.numAttribs * __GLX_SIZE_CARD32;
+      attribs = (CARD32 *) malloc(attribs_size);
+      if (attribs == NULL) {
+	 UnlockDisplay(dpy);
+	 SyncHandle();
+	 return BadAlloc;
+      }
+
+      _XRead(dpy, (char *) attribs, attribs_size);
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+
+   /* send the reply back to the client */
+   reply.sequenceNumber = client->sequence;
+   if (client->swapped) {
+      __glXSwapGetDrawableAttributesReply(client, &reply, (int *)attribs);
+   }
+   else {
+      WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)&reply);
+      WriteToClient(client, attribs_size, (char *)attribs);
+   }
+
+   free(attribs);
+
+   return Success;
+}
+
+int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
+{
+   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
+   xGLXChangeDrawableAttributesReq *be_req;
+   ClientPtr client = cl->client;
+   GLXDrawable drawId = req->drawable;
+   GLXDrawable be_drawable = 0;
+   DrawablePtr pDraw = NULL;
+   Display *dpy;
+   int screen, rc;
+   DMXScreenInfo *dmxScreen;
+
+   if (drawId != None) {
+      rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixSetAttrAccess);
+      if (rc == Success && pDraw->type == DRAWABLE_WINDOW) {
+	  be_drawable = 0;
+	  screen = pDraw->pScreen->myNum;
+      } else {
+	 /*
+	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
+	  */
+	 client->errorValue = drawId;
+	 return __glXBadDrawable;
+      }
+
+      if (!pDraw) {
+	 __GLXpixmap *pGlxPixmap;
+	 dixLookupResourceByType((pointer*) &pGlxPixmap,
+				 drawId, __glXPixmapRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxPixmap) {
+		pDraw = pGlxPixmap->pDraw;
+		screen = pGlxPixmap->pScreen->myNum;
+                be_drawable = pGlxPixmap->be_xids[screen];
+	 }
+      }
+
+      if (!pDraw) {
+	 __glXWindow *pGlxWindow;
+	 dixLookupResourceByType((pointer*) &pGlxWindow,
+				 drawId, __glXWindowRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxWindow) {
+	    pDraw = pGlxWindow->pDraw;
+	    screen = pGlxWindow->pScreen->myNum;
+	    be_drawable = 0;
+     	 }
+      }
+
+      if (!pDraw) {
+	 __glXPbuffer *pGlxPbuffer;
+	 dixLookupResourceByType((pointer*) &pGlxPbuffer,
+				 drawId, __glXPbufferRes,
+				 NullClient, DixUnknownAccess);
+	 if (pGlxPbuffer) {
+    	    pDraw = (DrawablePtr)pGlxPbuffer;
+	    screen = pGlxPbuffer->pScreen->myNum;
+	    be_drawable = pGlxPbuffer->be_xids[screen];
+	 }
+      }
+   }
+
+   if (!pDraw) {
+	 /*
+	  ** Drawable is not a Window , GLXWindow or a GLXPixmap.
+	  */
+	 client->errorValue = drawId;
+	 return __glXBadDrawable;
+   }
+
+   /* if the drawable is a window or GLXWindow - 
+    * we need to find the base id on the back-end server
+    */
+   if (!be_drawable) {
+       WindowPtr pWin = (WindowPtr)pDraw;
+
+#ifdef PANORAMIX
+       if (!noPanoramiXExtension) {
+	  PanoramiXRes *pXinDraw;
+	  if (Success != dixLookupResourceByClass((pointer*) &pXinDraw,
+						  pDraw->id, XRC_DRAWABLE,
+						  client, DixReadAccess)) {
+	     client->errorValue = drawId;
+	     return __glXBadDrawable;
+	  }
+
+	  dixLookupWindow(&pWin, pXinDraw->info[screen].id, client,
+			  DixReadAccess);
+       }
+#endif
+
+       if (pWin) {
+	   be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   if (!be_drawable) {
+	      /* it might be that the window did not created yet on the */
+	      /* back-end server (lazy window creation option), force   */
+	      /* creation of the window */
+	      dmxCreateAndRealizeWindow( pWin, TRUE );
+	      be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
+	   }
+       }
+       else {
+	  client->errorValue = drawId;
+	  return __glXBadDrawable;
+       }
+   }
+
+
+   /* send the request to the back-end server */
+   dpy = GetBackEndDisplay(cl,screen);
+   dmxScreen = &dmxScreens[screen];
+
+   /* make sure drawable exists on back-end */
+   dmxSync( dmxScreen, 1 );
+
+   LockDisplay(dpy);
+   GetReqExtra(GLXChangeDrawableAttributes,
+                        2 * req->numAttribs * __GLX_SIZE_CARD32, be_req);
+   be_req->reqType = dmxScreen->glxMajorOpcode;
+   be_req->glxCode = X_GLXChangeDrawableAttributes;
+   be_req->drawable = be_drawable;
+   be_req->numAttribs = req->numAttribs;
+   be_req->length = req->length;
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return Success;
+}
+
+int __glXSendLargeCommand(__GLXclientState *cl, GLXContextTag contextTag)
+{
+   ClientPtr client = cl->client;
+    xGLXRenderLargeReq *req;
+    GLint maxSize, amount;
+    GLint totalRequests, requestNumber;
+    GLint dataLen;
+    GLbyte *data;
+    __GLXcontext *glxc;
+    int s;
+    int from_screen, to_screen;
+
+    maxSize = cl->largeCmdMaxReqDataSize - (GLint)sizeof(xGLXRenderLargeReq);
+    dataLen = cl->largeCmdBytesTotal;
+    totalRequests = (dataLen / maxSize);
+    if (dataLen % maxSize) totalRequests++;
+
+    glxc = __glXLookupContextByTag(cl, contextTag);
+    if (!glxc) {
+       client->errorValue = contextTag;
+       return __glXBadContext;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    /*
+    ** Send enough requests until the whole array is sent.
+    */
+    requestNumber = 1;
+    data = cl->largeCmdBuf;
+    while (dataLen > 0) {
+	amount = dataLen;
+	if (amount > maxSize) {
+	    amount = maxSize;
+	}
+
+	for (s=from_screen; s<=to_screen; s++) {
+
+	   Display *dpy = GetBackEndDisplay(cl,s);
+	   DMXScreenInfo *dmxScreen = &dmxScreens[s];
+
+	   LockDisplay(dpy);
+	   GetReq(GLXRenderLarge,req); 
+	   req->reqType = dmxScreen->glxMajorOpcode;
+	   req->glxCode = X_GLXRenderLarge; 
+	   req->contextTag = GetCurrentBackEndTag(cl,contextTag,s);
+	   req->length += (amount + 3) >> 2;
+	   req->requestNumber = requestNumber++;
+	   req->requestTotal = totalRequests;
+	   req->dataBytes = amount;
+	   Data(dpy, ((const char*)data), amount);
+	   dataLen -= amount;
+	   data = ((GLbyte *) data) + amount;
+	   UnlockDisplay(dpy);
+	   SyncHandle();
+	}
+    }
+
+    return Success;
+}
diff --git a/xorg-server/hw/dmx/glxProxy/glxsingle.c b/xorg-server/hw/dmx/glxProxy/glxsingle.c
index 33cc612a7..834c7b8d9 100644
--- a/xorg-server/hw/dmx/glxProxy/glxsingle.c
+++ b/xorg-server/hw/dmx/glxProxy/glxsingle.c
@@ -1,1016 +1,1016 @@
-/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxwindow.h"
-#include "dmxpixmap.h"
-#include "dmxfont.h"
-#include "dmxcb.h"
-
-#include "glxserver.h"
-#include "glxext.h"
-#include "g_disptab.h"
-/* #include "g_disptab_EXT.h" */
-#include "unpack.h"
-#include "glxutil.h"
-
-#include "GL/glxproto.h"
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-#endif
-
-/*
- * GetReqSingle - this is the equivalent of GetReq macro
- *    from Xlibint.h but it does not set the reqType field (the opcode).
- *    this is because the GL single opcodes has different naming convension
- *    the other X opcodes (ie. X_GLsop_GetFloatv).
- */
-#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
-#define GetReqSingle(name, req) \
-        WORD64ALIGN\
-	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
-		_XFlush(dpy);\
-	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
-	req->length = (SIZEOF(x##name##Req))>>2;\
-	dpy->bufptr += SIZEOF(x##name##Req);\
-	dpy->request++
-
-#else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
-#define GetReqSingle(name, req) \
-        WORD64ALIGN\
-	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
-		_XFlush(dpy);\
-	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
-	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
-	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
-	dpy->request++
-#endif
-
-#define X_GLXSingle 0   /* needed by GetReqExtra */
-
-extern Display *GetBackEndDisplay( __GLXclientState *cl, int s );
-extern int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s);
-
-static int swap_vec_element_size = 0;
-
-static void SendSwappedReply( ClientPtr client,
-                              xGLXSingleReply *reply, 
-			      char *buf,
-			      int   buf_size )
-{
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_SWAP_SHORT(&reply->sequenceNumber);
-   __GLX_SWAP_INT(&reply->length);
-   __GLX_SWAP_INT(&reply->retval);
-   __GLX_SWAP_INT(&reply->size);
-
-   if ( (buf_size == 0) && (swap_vec_element_size > 0) ) {
-      /*
-       * the reply has single component - need to swap pad3
-       */
-      if (swap_vec_element_size == 2) {
-	 __GLX_SWAP_SHORT(&reply->pad3);
-      }
-      else if (swap_vec_element_size == 4) {
-	 __GLX_SWAP_INT(&reply->pad3);
-	 __GLX_SWAP_INT(&reply->pad4);    /* some requests use also pad4
-                                          * i.e GetConvolutionFilter
-					  */
-      }
-      else if (swap_vec_element_size == 8) {
-	 __GLX_SWAP_DOUBLE(&reply->pad3);
-      }
-   }
-   else if ( (buf_size > 0) && (swap_vec_element_size > 0) ) {
-      /*
-       * the reply has vector of elements which needs to be swapped
-       */
-      int vsize = buf_size / swap_vec_element_size;
-      char *p = buf;
-      int i;
-
-      for (i=0; i<vsize; i++) {
-	 if (swap_vec_element_size == 2) {
-	    __GLX_SWAP_SHORT(p);
-	 }
-	 else if (swap_vec_element_size == 4) {
-	    __GLX_SWAP_INT(p);
-	 }
-	 else if (swap_vec_element_size == 8) {
-	    __GLX_SWAP_DOUBLE(p);
-	 }
-
-	 p += swap_vec_element_size;
-      }
-
-      /*
-       * swap pad words as well - for case that some single reply uses
-       * them as well
-       */
-      __GLX_SWAP_INT(&reply->pad3);
-      __GLX_SWAP_INT(&reply->pad4);
-      __GLX_SWAP_INT(&reply->pad5);
-      __GLX_SWAP_INT(&reply->pad6);
-
-   }
-
-    WriteToClient(client, sizeof(xGLXSingleReply),(char *)reply);
-    if (buf_size > 0)
-       WriteToClient(client, buf_size, (char *)buf);
-
-}
-
-int __glXForwardSingleReq( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   xGLXSingleReq *be_req;
-    __GLXcontext *glxc;
-   int from_screen = 0;
-   int to_screen = 0;
-   int buf_size;
-   int s;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXSingleReq;
-    buf_size = (req->length << 2) - sz_xGLXSingleReq;
-
-    /*
-     * just forward the request to back-end server(s)
-     */
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReqSingle(GLXSingle,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = req->glxCode;
-       be_req->length = req->length;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       if (buf_size > 0) 
-	  _XSend(dpy, (const char *)pc, buf_size);
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       if (req->glxCode == X_GLsop_Flush) {
-	  XFlush(dpy);
-       }
-
-    }
-
-    return Success;
-}
-
-int __glXForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
-{
-   ClientPtr client = cl->client;
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   xGLXSingleReq *be_req;
-   xGLXSingleReply reply;
-   xGLXSingleReply be_reply;
-    __GLXcontext *glxc;
-   int buf_size;
-   char *be_buf = NULL;
-   int   be_buf_size;
-   DMXScreenInfo *dmxScreen;
-   Display *dpy;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return __glXBadContext;
-    }
-
-    pc += sz_xGLXSingleReq;
-    buf_size = (req->length << 2) - sz_xGLXSingleReq;
-
-    dmxScreen = &dmxScreens[glxc->pScreen->myNum];
-    dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
-
-    /* 
-     * send the request to the first back-end server
-     */
-    LockDisplay(dpy);
-    GetReqSingle(GLXSingle,be_req);
-    be_req->reqType = dmxScreen->glxMajorOpcode;
-    be_req->glxCode = req->glxCode;
-    be_req->length = req->length;
-    be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,glxc->pScreen->myNum);
-    if (buf_size > 0) 
-       _XSend(dpy, (const char *)pc, buf_size);
-
-    /*
-     * get the reply from the back-end server
-     */
-    _XReply(dpy, (xReply*) &be_reply, 0, False);
-    be_buf_size = be_reply.length << 2;
-    if (be_buf_size > 0) {
-       be_buf = (char *)malloc( be_buf_size );
-       if (be_buf) {
-	  _XRead(dpy, be_buf, be_buf_size);
-       }
-       else {
-	  /* Throw data on the floor */
-	  _XEatData(dpy, be_buf_size);
-	  return BadAlloc;
-       }
-    }
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-    /*
-     * send the reply to the client
-     */
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = be_reply.length;
-    reply.retval = be_reply.retval;
-    reply.size = be_reply.size;
-    reply.pad3 = be_reply.pad3;
-    reply.pad4 = be_reply.pad4;
-
-    if (client->swapped) {
-       SendSwappedReply( client, &reply, be_buf, be_buf_size );
-    }
-    else {
-       WriteToClient(client, sizeof(xGLXSingleReply),(char *)&reply);
-       if (be_buf_size > 0)
-	  WriteToClient(client, be_buf_size, (char *)be_buf);
-    }
-
-    if (be_buf_size > 0) free(be_buf);
-
-    return Success;
-}
-
-int __glXForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
-{
-   ClientPtr client = cl->client;
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   xGLXSingleReq *be_req;
-   xGLXSingleReply reply;
-   xGLXSingleReply be_reply;
-    __GLXcontext *glxc;
-   int buf_size;
-   char *be_buf = NULL;
-   int   be_buf_size = 0;
-   int from_screen = 0;
-   int to_screen = 0;
-   int s;
-
-   DMXScreenInfo *dmxScreen;
-   Display *dpy;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXSingleReq;
-    buf_size = (req->length << 2) - sz_xGLXSingleReq;
-
-    /* 
-     * send the request to the first back-end server(s)
-     */
-    for (s=to_screen; s>=from_screen; s--) {
-       dmxScreen = &dmxScreens[s];
-       dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReqSingle(GLXSingle,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = req->glxCode;
-       be_req->length = req->length;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       if (buf_size > 0) 
-	  _XSend(dpy, (const char *)pc, buf_size);
-
-       /*
-	* get the reply from the back-end server
-	*/
-       _XReply(dpy, (xReply*) &be_reply, 0, False);
-       be_buf_size = be_reply.length << 2;
-       if (be_buf_size > 0) {
-	  be_buf = (char *)malloc( be_buf_size );
-	  if (be_buf) {
-	     _XRead(dpy, be_buf, be_buf_size);
-	  }
-	  else {
-	     /* Throw data on the floor */
-	     _XEatData(dpy, be_buf_size);
-	     return BadAlloc;
-	  }
-       }
-
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       if (s > from_screen && be_buf_size > 0) {
-	  free(be_buf);
-       }
-    }
-
-    /*
-     * send the reply to the client
-     */
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = be_reply.length;
-    reply.retval = be_reply.retval;
-    reply.size = be_reply.size;
-    reply.pad3 = be_reply.pad3;
-    reply.pad4 = be_reply.pad4;
-
-    if (client->swapped) {
-       SendSwappedReply( client, &reply, be_buf, be_buf_size );
-    }
-    else {
-       WriteToClient(client, sizeof(xGLXSingleReply),(char *)&reply);
-       if (be_buf_size > 0)
-	  WriteToClient(client, be_buf_size, (char *)be_buf);
-    }
-
-    if (be_buf_size > 0) free(be_buf);
-
-    return Success;
-}
-
-int __glXForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXForwardSingleReq( cl, pc ) );
-}
-
-int __glXForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 2;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 4;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 8;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardAllWithReply( cl, pc ) );
-}
-
-int __glXForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 2;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardAllWithReply( cl, pc ) );
-}
-
-int __glXForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 4;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardAllWithReply( cl, pc ) );
-}
-
-int __glXForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXSingleReq *req = (xGLXSingleReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 8;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXSingleReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXSingleReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-
-   return( __glXForwardAllWithReply( cl, pc ) );
-}
-
-static GLint __glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h, 
-                          int *elementbits_return, int *rowbytes_return )
-{
-    GLint elements, esize;
-    GLint rowsize, padding;
-
-    if (w < 0 || h < 0) {
-	return -1;
-    }
-    switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_STENCIL_INDEX:
-      case GL_DEPTH_COMPONENT:
-	elements = 1;
-	break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-	elements = 1;
-	break;
-      case GL_LUMINANCE_ALPHA:
-	elements = 2;
-	break;
-      case GL_RGB:
-      case GL_BGR:
-	elements = 3;
-	break;
-      case GL_RGBA:
-      case GL_BGRA:
-      case GL_ABGR_EXT:
-	elements = 4;
-	break;
-      default:
-	return -1;
-    }
-    /*
-    ** According to the GLX protocol, each row must be padded to a multiple of
-    ** 4 bytes.  4 bytes also happens to be the default alignment in the pixel
-    ** store modes of the GL.
-    */
-    switch (type) {
-      case GL_BITMAP:
-	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
-	   rowsize = ((w * elements)+7)/8;
-	   padding = rowsize % 4;
-	   if (padding) {
-	      rowsize += 4 - padding;
-	   }
-	   if (elementbits_return) *elementbits_return = elements;
-	   if (rowbytes_return) *rowbytes_return = rowsize;
-	   return rowsize * h;
-	} else {
-	   return -1;
-	}
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	esize = 1;
-	break;
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	esize = 1;
-	elements = 1;
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	esize = 2;
-	break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-	esize = 2;
-	elements = 1;
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-      case GL_FLOAT:
-	esize = 4;
-	break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-	esize = 4;
-	elements = 1;
-	break;
-      default:
-	return -1;
-    }
-    rowsize = w * elements * esize;
-    padding = rowsize % 4;
-    if (padding) {
-	rowsize += 4 - padding;
-    }
-
-    if (elementbits_return) *elementbits_return = esize*elements*8;
-    if (rowbytes_return) *rowbytes_return = rowsize;
-
-    return rowsize * h;
-}
-
-static int intersectRect( int x1, int x2, int y1, int y2,
-                    int X1, int X2, int Y1, int Y2,
-		    int *ix1, int *ix2, int *iy1, int *iy2 )
-{
-   int right = (x2 < X2 ? x2 : X2);
-   int bottom = (y2 < Y2 ? y2 : Y2);
-   int left = (x1 > X1 ? x1 : X1);
-   int top = (y1 > Y1 ? y1 : Y1);
-   int width = right - left + 1;
-   int height = bottom - top + 1;
-
-   if ( (width <= 0) || (height <= 0) ) {
-      *ix1 = *ix2 = *iy1 = *iy2 = 0;
-      return 0;
-   }
-   else {
-      *ix1 = left;
-      *ix2 = right;
-      *iy1 = top;
-      *iy2 = bottom;
-      return width * height;
-   }
-
-}
-
-int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXSingleReq *req = (xGLXSingleReq *)pc;
-    xGLXSingleReq *be_req;
-    xGLXReadPixelsReply reply;
-    xGLXReadPixelsReply be_reply;
-    GLbyte *be_pc;
-    GLint x,y;
-    GLsizei width, height;
-    GLenum format, type;
-    GLboolean swapBytes, lsbFirst;
-    ClientPtr client = cl->client;
-    DrawablePtr pDraw;
-    __GLXcontext *glxc;
-    int from_screen = 0;
-    int to_screen = 0;
-    char *buf;
-    int buf_size;
-    int s;
-    int win_x1, win_x2;
-    int win_y1, win_y2;
-    int ebits, rowsize;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    if (client->swapped) {
-       __GLX_SWAP_INT(&req->contextTag);
-    }
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXSingleReq;
-    x = *(GLint *)(pc + 0);
-    y = *(GLint *)(pc + 4);
-    width = *(GLsizei *)(pc + 8);
-    height = *(GLsizei *)(pc + 12);
-    format = *(GLenum *)(pc + 16);
-    type = *(GLenum *)(pc + 20);
-    swapBytes = *(GLboolean *)(pc + 24);
-    lsbFirst = *(GLboolean *)(pc + 25);
-
-    if (client->swapped) {
-       __GLX_SWAP_INT(&x);
-       __GLX_SWAP_INT(&y);
-       __GLX_SWAP_INT(&width);
-       __GLX_SWAP_INT(&height);
-       __GLX_SWAP_INT(&format);
-       __GLX_SWAP_INT(&type);
-       swapBytes = !swapBytes;
-    }
-
-    buf_size = __glReadPixels_size(format,type,width,height, &ebits, &rowsize);
-    if (buf_size > 0) {
-       buf = (char *) malloc( buf_size );
-       if ( !buf ) {
-	  return BadAlloc;
-       }
-    }
-    else {
-       buf_size = 0;
-       buf = NULL;
-    }
-
-    if (buf_size > 0) {
-       /*
-	* Get the current drawable this context is bound to
-	*/
-       pDraw = __glXLookupDrawableByTag( cl, req->contextTag );
-       win_x1 = pDraw->x + x;
-       win_x2 = win_x1 + width - 1;
-       win_y1 = (dmxGlobalHeight - pDraw->y - pDraw->height) + y;
-       win_y2 = win_y1 + height - 1;
-       if (pDraw->type != DRAWABLE_WINDOW) {
-	  from_screen = to_screen = 0;
-       }
-
-       for (s=from_screen; s<=to_screen; s++) {
-	  DMXScreenInfo *dmxScreen = &dmxScreens[s];
-	  Display *dpy = GetBackEndDisplay(cl,s);
-	  int scr_x1 = dmxScreen->rootXOrigin;
-	  int scr_x2 = dmxScreen->rootXOrigin + dmxScreen->scrnWidth - 1;
-	  int scr_y1 = dmxScreen->rootYOrigin;
-	  int scr_y2 = dmxScreen->rootYOrigin + dmxScreen->scrnHeight - 1;
-	  int wx1, wx2, wy1, wy2;
-	  int sx, sy, sw, sh;
-	  int npixels;
-
-	  /*
-	   * find the window portion that is on the current screen
-	   */
-	  if (pDraw->type == DRAWABLE_WINDOW) {
-	     npixels = intersectRect( scr_x1, scr_x2, scr_y1, scr_y2,
-		   win_x1, win_x2, win_y1, win_y2,
-		   &wx1, &wx2, &wy1, &wy2 );
-	  }
-	  else {
-	     wx1 = win_x1;
-	     wx2 = win_x2;
-	     wy1 = win_y1;
-	     wy2 = win_y2;
-	     npixels = (wx2-wx1+1) * (wy2-wy1+1);
-	  }
-
-   	  if (npixels > 0) {
-
-   	     /* send the request to the back-end server */
-   	     LockDisplay(dpy);
-   	     GetReqExtra(GLXSingle,__GLX_PAD(26),be_req);
-   	     be_req->reqType = dmxScreen->glxMajorOpcode;
-   	     be_req->glxCode = X_GLsop_ReadPixels;
-   	     be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-   	     be_pc = ((GLbyte *)(be_req) + sz_xGLXSingleReq);
-
-   	     sx = wx1 - pDraw->x;
-   	     sy = wy1 - (dmxGlobalHeight - pDraw->y - pDraw->height); 
-   	     sw = (wx2-wx1+1); 
-   	     sh = (wy2-wy1+1); 
-	     
-	     *(GLint *)(be_pc + 0) = sx;    /* x */
-	     *(GLint *)(be_pc + 4) = sy;    /* y */
-	     *(GLsizei *)(be_pc + 8) = sw;    /* width */
-	     *(GLsizei *)(be_pc + 12) = sh;   /* height */
-	     *(GLenum *)(be_pc + 16) = format; 
-	     *(GLenum *)(be_pc + 20) = type;
-	     *(GLboolean *)(be_pc + 24) = swapBytes;
-	     *(GLboolean *)(be_pc + 25) = lsbFirst;
-
-	     _XReply(dpy, (xReply*) &be_reply, 0, False);
-         
-	     if (be_reply.length > 0) {
-		char *be_buf;
-		int be_buf_size = be_reply.length << 2;
-
-		be_buf = (char *) malloc( be_buf_size );
-		if (be_buf) {
-		   _XRead(dpy, be_buf, be_buf_size);
-
-		   /* copy pixels data to the right location of the */
-		   /* reply buffer */
-		   if ( type != GL_BITMAP ) {
-		      int pbytes = ebits / 8;
-		      char *dst = buf + (sy-y)*rowsize + (sx-x)*pbytes;
-		      char *src = be_buf;
-		      int pad = (pbytes * sw) % 4;
-		      int r;
-
-		      for (r=0; r<sh; r++) {
-			 memcpy( dst, src, pbytes*sw );
-			 dst += rowsize;
-			 src += (pbytes*sw + (pad ? 4-pad : 0) );
-		      }
-		   }
-		   else {
-		      /* this is a GL_BITMAP pixel type, should copy bits */
-		      int r;
-		      int src_rowsize = bits_to_bytes(sw * ebits);
-		      int src_pad = src_rowsize % 4;
-                      if ( src_pad ) {
-			 src_rowsize += (4 - src_pad);
-		      }
-
-		      for (r=0; r<sh; r++) {
-			 unsigned char dst_mask = 0x80 >> (sx % 8);
-			 unsigned char src_mask = 0x80;
-			 char *dst = buf + (sy-y+r)*rowsize + (sx-x)/8;
-			 char *src = be_buf + r*src_rowsize;
-			 int b;
-
-			 for (b=0; b<sw*ebits; b++) {
-			    if ( *src & src_mask ) {
-			       *dst |= dst_mask;
-			    }
-			    else {
-			       *dst &= ~dst_mask;
-			    }
-
-			    if (dst_mask > 1) dst_mask >>= 1;
-			    else { 
-			       dst_mask = 0x80;
-			       dst++;
-			    }
-
-			    if (src_mask > 1) src_mask >>= 1;
-			    else {
-			       src_mask = 0x80;
-			       src++;
-			    }
-			 }
-		      }
-
-		   }
-
-		   free( be_buf );
-		}
-		else {
-		   /* Throw data on the floor */
-		   _XEatData(dpy, be_buf_size);
-		   free( buf );
-		   return BadAlloc;
-		}
-	     }
-
-	     UnlockDisplay(dpy);
-	     SyncHandle();
-
-	  } /* of npixels > 0 */ 
-
-       }  /* of for loop */
-
-    } /* of if buf_size > 0 */
-
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-    reply.length = buf_size >> 2;
-
-    if (client->swapped) {
-       __GLX_SWAP_SHORT(&reply.sequenceNumber);
-       __GLX_SWAP_INT(&reply.length);
-    }
-
-    WriteToClient(client, sizeof(xGLXReadPixelsReply),(char *)&reply);
-    if (buf_size > 0) {
-       WriteToClient(client, buf_size, (char *)buf);
-       free( buf );
-    }
-
-    return Success;
-}
-
-int __glXDispSwap_GetTexImage(__GLXclientState *cl, GLbyte *pc)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    GLbyte *lpc = pc;
-
-    lpc += sz_xGLXSingleReq;
-    __GLX_SWAP_INT(lpc+0);
-    __GLX_SWAP_INT(lpc+4);
-    __GLX_SWAP_INT(lpc+8);
-    __GLX_SWAP_INT(lpc+12);
-
-    /* reverse swapBytes */
-    *(GLboolean *)(lpc + 16) = ! *(GLboolean *)(lpc + 16);
-
-    return( __glXForwardPipe0WithReplySwap( cl, pc ) );
-}
-
-int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
-{
-    __GLX_DECLARE_SWAP_VARIABLES;
-    GLbyte *lpc = pc;
-
-    lpc += sz_xGLXSingleReq;
-    __GLX_SWAP_INT(lpc+0);
-    __GLX_SWAP_INT(lpc+4);
-    __GLX_SWAP_INT(lpc+8);
-
-    /* reverse swapBytes */
-    *(GLboolean *)(lpc + 12) = ! *(GLboolean *)(lpc + 12);
-
-    return( __glXForwardPipe0WithReplySwap( cl, pc ) );
-}
-
-
+/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxwindow.h"
+#include "dmxpixmap.h"
+#include "dmxfont.h"
+#include "dmxcb.h"
+
+#include "glxserver.h"
+#include "glxext.h"
+#include "g_disptab.h"
+/* #include "g_disptab_EXT.h" */
+#include "unpack.h"
+#include "glxutil.h"
+
+#include "GL/glxproto.h"
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.h"
+#endif
+
+/*
+ * GetReqSingle - this is the equivalent of GetReq macro
+ *    from Xlibint.h but it does not set the reqType field (the opcode).
+ *    this is because the GL single opcodes has different naming convension
+ *    the other X opcodes (ie. X_GLsop_GetFloatv).
+ */
+#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
+#define GetReqSingle(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+	req->length = (SIZEOF(x##name##Req))>>2;\
+	dpy->bufptr += SIZEOF(x##name##Req);\
+	dpy->request++
+
+#else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
+#define GetReqSingle(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
+	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
+	dpy->request++
+#endif
+
+#define X_GLXSingle 0   /* needed by GetReqExtra */
+
+extern Display *GetBackEndDisplay( __GLXclientState *cl, int s );
+extern int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s);
+
+static int swap_vec_element_size = 0;
+
+static void SendSwappedReply( ClientPtr client,
+                              xGLXSingleReply *reply, 
+			      char *buf,
+			      int   buf_size )
+{
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_SWAP_SHORT(&reply->sequenceNumber);
+   __GLX_SWAP_INT(&reply->length);
+   __GLX_SWAP_INT(&reply->retval);
+   __GLX_SWAP_INT(&reply->size);
+
+   if ( (buf_size == 0) && (swap_vec_element_size > 0) ) {
+      /*
+       * the reply has single component - need to swap pad3
+       */
+      if (swap_vec_element_size == 2) {
+	 __GLX_SWAP_SHORT(&reply->pad3);
+      }
+      else if (swap_vec_element_size == 4) {
+	 __GLX_SWAP_INT(&reply->pad3);
+	 __GLX_SWAP_INT(&reply->pad4);    /* some requests use also pad4
+                                          * i.e GetConvolutionFilter
+					  */
+      }
+      else if (swap_vec_element_size == 8) {
+	 __GLX_SWAP_DOUBLE(&reply->pad3);
+      }
+   }
+   else if ( (buf_size > 0) && (swap_vec_element_size > 0) ) {
+      /*
+       * the reply has vector of elements which needs to be swapped
+       */
+      int vsize = buf_size / swap_vec_element_size;
+      char *p = buf;
+      int i;
+
+      for (i=0; i<vsize; i++) {
+	 if (swap_vec_element_size == 2) {
+	    __GLX_SWAP_SHORT(p);
+	 }
+	 else if (swap_vec_element_size == 4) {
+	    __GLX_SWAP_INT(p);
+	 }
+	 else if (swap_vec_element_size == 8) {
+	    __GLX_SWAP_DOUBLE(p);
+	 }
+
+	 p += swap_vec_element_size;
+      }
+
+      /*
+       * swap pad words as well - for case that some single reply uses
+       * them as well
+       */
+      __GLX_SWAP_INT(&reply->pad3);
+      __GLX_SWAP_INT(&reply->pad4);
+      __GLX_SWAP_INT(&reply->pad5);
+      __GLX_SWAP_INT(&reply->pad6);
+
+   }
+
+    WriteToClient(client, sizeof(xGLXSingleReply),(char *)reply);
+    if (buf_size > 0)
+       WriteToClient(client, buf_size, (char *)buf);
+
+}
+
+int __glXForwardSingleReq( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   xGLXSingleReq *be_req;
+    __GLXcontext *glxc;
+   int from_screen = 0;
+   int to_screen = 0;
+   int buf_size;
+   int s;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXSingleReq;
+    buf_size = (req->length << 2) - sz_xGLXSingleReq;
+
+    /*
+     * just forward the request to back-end server(s)
+     */
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReqSingle(GLXSingle,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = req->glxCode;
+       be_req->length = req->length;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       if (buf_size > 0) 
+	  _XSend(dpy, (const char *)pc, buf_size);
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       if (req->glxCode == X_GLsop_Flush) {
+	  XFlush(dpy);
+       }
+
+    }
+
+    return Success;
+}
+
+int __glXForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
+{
+   ClientPtr client = cl->client;
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   xGLXSingleReq *be_req;
+   xGLXSingleReply reply;
+   xGLXSingleReply be_reply;
+    __GLXcontext *glxc;
+   int buf_size;
+   char *be_buf = NULL;
+   int   be_buf_size;
+   DMXScreenInfo *dmxScreen;
+   Display *dpy;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return __glXBadContext;
+    }
+
+    pc += sz_xGLXSingleReq;
+    buf_size = (req->length << 2) - sz_xGLXSingleReq;
+
+    dmxScreen = &dmxScreens[glxc->pScreen->myNum];
+    dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
+
+    /* 
+     * send the request to the first back-end server
+     */
+    LockDisplay(dpy);
+    GetReqSingle(GLXSingle,be_req);
+    be_req->reqType = dmxScreen->glxMajorOpcode;
+    be_req->glxCode = req->glxCode;
+    be_req->length = req->length;
+    be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,glxc->pScreen->myNum);
+    if (buf_size > 0) 
+       _XSend(dpy, (const char *)pc, buf_size);
+
+    /*
+     * get the reply from the back-end server
+     */
+    _XReply(dpy, (xReply*) &be_reply, 0, False);
+    be_buf_size = be_reply.length << 2;
+    if (be_buf_size > 0) {
+       be_buf = (char *)malloc( be_buf_size );
+       if (be_buf) {
+	  _XRead(dpy, be_buf, be_buf_size);
+       }
+       else {
+	  /* Throw data on the floor */
+	  _XEatData(dpy, be_buf_size);
+	  return BadAlloc;
+       }
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    /*
+     * send the reply to the client
+     */
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = be_reply.length;
+    reply.retval = be_reply.retval;
+    reply.size = be_reply.size;
+    reply.pad3 = be_reply.pad3;
+    reply.pad4 = be_reply.pad4;
+
+    if (client->swapped) {
+       SendSwappedReply( client, &reply, be_buf, be_buf_size );
+    }
+    else {
+       WriteToClient(client, sizeof(xGLXSingleReply),(char *)&reply);
+       if (be_buf_size > 0)
+	  WriteToClient(client, be_buf_size, (char *)be_buf);
+    }
+
+    if (be_buf_size > 0) free(be_buf);
+
+    return Success;
+}
+
+int __glXForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
+{
+   ClientPtr client = cl->client;
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   xGLXSingleReq *be_req;
+   xGLXSingleReply reply;
+   xGLXSingleReply be_reply;
+    __GLXcontext *glxc;
+   int buf_size;
+   char *be_buf = NULL;
+   int   be_buf_size = 0;
+   int from_screen = 0;
+   int to_screen = 0;
+   int s;
+
+   DMXScreenInfo *dmxScreen;
+   Display *dpy;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXSingleReq;
+    buf_size = (req->length << 2) - sz_xGLXSingleReq;
+
+    /* 
+     * send the request to the first back-end server(s)
+     */
+    for (s=to_screen; s>=from_screen; s--) {
+       dmxScreen = &dmxScreens[s];
+       dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReqSingle(GLXSingle,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = req->glxCode;
+       be_req->length = req->length;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       if (buf_size > 0) 
+	  _XSend(dpy, (const char *)pc, buf_size);
+
+       /*
+	* get the reply from the back-end server
+	*/
+       _XReply(dpy, (xReply*) &be_reply, 0, False);
+       be_buf_size = be_reply.length << 2;
+       if (be_buf_size > 0) {
+	  be_buf = (char *)malloc( be_buf_size );
+	  if (be_buf) {
+	     _XRead(dpy, be_buf, be_buf_size);
+	  }
+	  else {
+	     /* Throw data on the floor */
+	     _XEatData(dpy, be_buf_size);
+	     return BadAlloc;
+	  }
+       }
+
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       if (s > from_screen && be_buf_size > 0) {
+	  free(be_buf);
+       }
+    }
+
+    /*
+     * send the reply to the client
+     */
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = be_reply.length;
+    reply.retval = be_reply.retval;
+    reply.size = be_reply.size;
+    reply.pad3 = be_reply.pad3;
+    reply.pad4 = be_reply.pad4;
+
+    if (client->swapped) {
+       SendSwappedReply( client, &reply, be_buf, be_buf_size );
+    }
+    else {
+       WriteToClient(client, sizeof(xGLXSingleReply),(char *)&reply);
+       if (be_buf_size > 0)
+	  WriteToClient(client, be_buf_size, (char *)be_buf);
+    }
+
+    if (be_buf_size > 0) free(be_buf);
+
+    return Success;
+}
+
+int __glXForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXForwardSingleReq( cl, pc ) );
+}
+
+int __glXForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 2;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 4;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 8;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardAllWithReply( cl, pc ) );
+}
+
+int __glXForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 2;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardAllWithReply( cl, pc ) );
+}
+
+int __glXForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 4;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardAllWithReply( cl, pc ) );
+}
+
+int __glXForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXSingleReq *req = (xGLXSingleReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 8;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXSingleReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXSingleReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+
+   return( __glXForwardAllWithReply( cl, pc ) );
+}
+
+static GLint __glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h, 
+                          int *elementbits_return, int *rowbytes_return )
+{
+    GLint elements, esize;
+    GLint rowsize, padding;
+
+    if (w < 0 || h < 0) {
+	return -1;
+    }
+    switch (format) {
+      case GL_COLOR_INDEX:
+      case GL_STENCIL_INDEX:
+      case GL_DEPTH_COMPONENT:
+	elements = 1;
+	break;
+      case GL_RED:
+      case GL_GREEN:
+      case GL_BLUE:
+      case GL_ALPHA:
+      case GL_LUMINANCE:
+	elements = 1;
+	break;
+      case GL_LUMINANCE_ALPHA:
+	elements = 2;
+	break;
+      case GL_RGB:
+      case GL_BGR:
+	elements = 3;
+	break;
+      case GL_RGBA:
+      case GL_BGRA:
+      case GL_ABGR_EXT:
+	elements = 4;
+	break;
+      default:
+	return -1;
+    }
+    /*
+    ** According to the GLX protocol, each row must be padded to a multiple of
+    ** 4 bytes.  4 bytes also happens to be the default alignment in the pixel
+    ** store modes of the GL.
+    */
+    switch (type) {
+      case GL_BITMAP:
+	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
+	   rowsize = ((w * elements)+7)/8;
+	   padding = rowsize % 4;
+	   if (padding) {
+	      rowsize += 4 - padding;
+	   }
+	   if (elementbits_return) *elementbits_return = elements;
+	   if (rowbytes_return) *rowbytes_return = rowsize;
+	   return rowsize * h;
+	} else {
+	   return -1;
+	}
+      case GL_BYTE:
+      case GL_UNSIGNED_BYTE:
+	esize = 1;
+	break;
+      case GL_UNSIGNED_BYTE_3_3_2:
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+	esize = 1;
+	elements = 1;
+	break;
+      case GL_SHORT:
+      case GL_UNSIGNED_SHORT:
+	esize = 2;
+	break;
+      case GL_UNSIGNED_SHORT_5_6_5:
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+	esize = 2;
+	elements = 1;
+	break;
+      case GL_INT:
+      case GL_UNSIGNED_INT:
+      case GL_FLOAT:
+	esize = 4;
+	break;
+      case GL_UNSIGNED_INT_8_8_8_8:
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+      case GL_UNSIGNED_INT_10_10_10_2:
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+	esize = 4;
+	elements = 1;
+	break;
+      default:
+	return -1;
+    }
+    rowsize = w * elements * esize;
+    padding = rowsize % 4;
+    if (padding) {
+	rowsize += 4 - padding;
+    }
+
+    if (elementbits_return) *elementbits_return = esize*elements*8;
+    if (rowbytes_return) *rowbytes_return = rowsize;
+
+    return rowsize * h;
+}
+
+static int intersectRect( int x1, int x2, int y1, int y2,
+                    int X1, int X2, int Y1, int Y2,
+		    int *ix1, int *ix2, int *iy1, int *iy2 )
+{
+   int right = (x2 < X2 ? x2 : X2);
+   int bottom = (y2 < Y2 ? y2 : Y2);
+   int left = (x1 > X1 ? x1 : X1);
+   int top = (y1 > Y1 ? y1 : Y1);
+   int width = right - left + 1;
+   int height = bottom - top + 1;
+
+   if ( (width <= 0) || (height <= 0) ) {
+      *ix1 = *ix2 = *iy1 = *iy2 = 0;
+      return 0;
+   }
+   else {
+      *ix1 = left;
+      *ix2 = right;
+      *iy1 = top;
+      *iy2 = bottom;
+      return width * height;
+   }
+
+}
+
+int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXSingleReq *req = (xGLXSingleReq *)pc;
+    xGLXSingleReq *be_req;
+    xGLXReadPixelsReply reply;
+    xGLXReadPixelsReply be_reply;
+    GLbyte *be_pc;
+    GLint x,y;
+    GLsizei width, height;
+    GLenum format, type;
+    GLboolean swapBytes, lsbFirst;
+    ClientPtr client = cl->client;
+    DrawablePtr pDraw;
+    __GLXcontext *glxc;
+    int from_screen = 0;
+    int to_screen = 0;
+    char *buf;
+    int buf_size;
+    int s;
+    int win_x1, win_x2;
+    int win_y1, win_y2;
+    int ebits, rowsize;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    if (client->swapped) {
+       __GLX_SWAP_INT(&req->contextTag);
+    }
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXSingleReq;
+    x = *(GLint *)(pc + 0);
+    y = *(GLint *)(pc + 4);
+    width = *(GLsizei *)(pc + 8);
+    height = *(GLsizei *)(pc + 12);
+    format = *(GLenum *)(pc + 16);
+    type = *(GLenum *)(pc + 20);
+    swapBytes = *(GLboolean *)(pc + 24);
+    lsbFirst = *(GLboolean *)(pc + 25);
+
+    if (client->swapped) {
+       __GLX_SWAP_INT(&x);
+       __GLX_SWAP_INT(&y);
+       __GLX_SWAP_INT(&width);
+       __GLX_SWAP_INT(&height);
+       __GLX_SWAP_INT(&format);
+       __GLX_SWAP_INT(&type);
+       swapBytes = !swapBytes;
+    }
+
+    buf_size = __glReadPixels_size(format,type,width,height, &ebits, &rowsize);
+    if (buf_size > 0) {
+       buf = (char *) malloc( buf_size );
+       if ( !buf ) {
+	  return BadAlloc;
+       }
+    }
+    else {
+       buf_size = 0;
+       buf = NULL;
+    }
+
+    if (buf_size > 0) {
+       /*
+	* Get the current drawable this context is bound to
+	*/
+       pDraw = __glXLookupDrawableByTag( cl, req->contextTag );
+       win_x1 = pDraw->x + x;
+       win_x2 = win_x1 + width - 1;
+       win_y1 = (dmxGlobalHeight - pDraw->y - pDraw->height) + y;
+       win_y2 = win_y1 + height - 1;
+       if (pDraw->type != DRAWABLE_WINDOW) {
+	  from_screen = to_screen = 0;
+       }
+
+       for (s=from_screen; s<=to_screen; s++) {
+	  DMXScreenInfo *dmxScreen = &dmxScreens[s];
+	  Display *dpy = GetBackEndDisplay(cl,s);
+	  int scr_x1 = dmxScreen->rootXOrigin;
+	  int scr_x2 = dmxScreen->rootXOrigin + dmxScreen->scrnWidth - 1;
+	  int scr_y1 = dmxScreen->rootYOrigin;
+	  int scr_y2 = dmxScreen->rootYOrigin + dmxScreen->scrnHeight - 1;
+	  int wx1, wx2, wy1, wy2;
+	  int sx, sy, sw, sh;
+	  int npixels;
+
+	  /*
+	   * find the window portion that is on the current screen
+	   */
+	  if (pDraw->type == DRAWABLE_WINDOW) {
+	     npixels = intersectRect( scr_x1, scr_x2, scr_y1, scr_y2,
+		   win_x1, win_x2, win_y1, win_y2,
+		   &wx1, &wx2, &wy1, &wy2 );
+	  }
+	  else {
+	     wx1 = win_x1;
+	     wx2 = win_x2;
+	     wy1 = win_y1;
+	     wy2 = win_y2;
+	     npixels = (wx2-wx1+1) * (wy2-wy1+1);
+	  }
+
+   	  if (npixels > 0) {
+
+   	     /* send the request to the back-end server */
+   	     LockDisplay(dpy);
+   	     GetReqExtra(GLXSingle,__GLX_PAD(26),be_req);
+   	     be_req->reqType = dmxScreen->glxMajorOpcode;
+   	     be_req->glxCode = X_GLsop_ReadPixels;
+   	     be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+   	     be_pc = ((GLbyte *)(be_req) + sz_xGLXSingleReq);
+
+   	     sx = wx1 - pDraw->x;
+   	     sy = wy1 - (dmxGlobalHeight - pDraw->y - pDraw->height); 
+   	     sw = (wx2-wx1+1); 
+   	     sh = (wy2-wy1+1); 
+	     
+	     *(GLint *)(be_pc + 0) = sx;    /* x */
+	     *(GLint *)(be_pc + 4) = sy;    /* y */
+	     *(GLsizei *)(be_pc + 8) = sw;    /* width */
+	     *(GLsizei *)(be_pc + 12) = sh;   /* height */
+	     *(GLenum *)(be_pc + 16) = format; 
+	     *(GLenum *)(be_pc + 20) = type;
+	     *(GLboolean *)(be_pc + 24) = swapBytes;
+	     *(GLboolean *)(be_pc + 25) = lsbFirst;
+
+	     _XReply(dpy, (xReply*) &be_reply, 0, False);
+         
+	     if (be_reply.length > 0) {
+		char *be_buf;
+		int be_buf_size = be_reply.length << 2;
+
+		be_buf = (char *) malloc( be_buf_size );
+		if (be_buf) {
+		   _XRead(dpy, be_buf, be_buf_size);
+
+		   /* copy pixels data to the right location of the */
+		   /* reply buffer */
+		   if ( type != GL_BITMAP ) {
+		      int pbytes = ebits / 8;
+		      char *dst = buf + (sy-y)*rowsize + (sx-x)*pbytes;
+		      char *src = be_buf;
+		      int pad = (pbytes * sw) % 4;
+		      int r;
+
+		      for (r=0; r<sh; r++) {
+			 memcpy( dst, src, pbytes*sw );
+			 dst += rowsize;
+			 src += (pbytes*sw + (pad ? 4-pad : 0) );
+		      }
+		   }
+		   else {
+		      /* this is a GL_BITMAP pixel type, should copy bits */
+		      int r;
+		      int src_rowsize = bits_to_bytes(sw * ebits);
+		      int src_pad = src_rowsize % 4;
+                      if ( src_pad ) {
+			 src_rowsize += (4 - src_pad);
+		      }
+
+		      for (r=0; r<sh; r++) {
+			 unsigned char dst_mask = 0x80 >> (sx % 8);
+			 unsigned char src_mask = 0x80;
+			 char *dst = buf + (sy-y+r)*rowsize + (sx-x)/8;
+			 char *src = be_buf + r*src_rowsize;
+			 int b;
+
+			 for (b=0; b<sw*ebits; b++) {
+			    if ( *src & src_mask ) {
+			       *dst |= dst_mask;
+			    }
+			    else {
+			       *dst &= ~dst_mask;
+			    }
+
+			    if (dst_mask > 1) dst_mask >>= 1;
+			    else { 
+			       dst_mask = 0x80;
+			       dst++;
+			    }
+
+			    if (src_mask > 1) src_mask >>= 1;
+			    else {
+			       src_mask = 0x80;
+			       src++;
+			    }
+			 }
+		      }
+
+		   }
+
+		   free( be_buf );
+		}
+		else {
+		   /* Throw data on the floor */
+		   _XEatData(dpy, be_buf_size);
+		   free( buf );
+		   return BadAlloc;
+		}
+	     }
+
+	     UnlockDisplay(dpy);
+	     SyncHandle();
+
+	  } /* of npixels > 0 */ 
+
+       }  /* of for loop */
+
+    } /* of if buf_size > 0 */
+
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+    reply.length = buf_size >> 2;
+
+    if (client->swapped) {
+       __GLX_SWAP_SHORT(&reply.sequenceNumber);
+       __GLX_SWAP_INT(&reply.length);
+    }
+
+    WriteToClient(client, sizeof(xGLXReadPixelsReply),(char *)&reply);
+    if (buf_size > 0) {
+       WriteToClient(client, buf_size, (char *)buf);
+       free( buf );
+    }
+
+    return Success;
+}
+
+int __glXDispSwap_GetTexImage(__GLXclientState *cl, GLbyte *pc)
+{
+    __GLX_DECLARE_SWAP_VARIABLES;
+    GLbyte *lpc = pc;
+
+    lpc += sz_xGLXSingleReq;
+    __GLX_SWAP_INT(lpc+0);
+    __GLX_SWAP_INT(lpc+4);
+    __GLX_SWAP_INT(lpc+8);
+    __GLX_SWAP_INT(lpc+12);
+
+    /* reverse swapBytes */
+    *(GLboolean *)(lpc + 16) = ! *(GLboolean *)(lpc + 16);
+
+    return( __glXForwardPipe0WithReplySwap( cl, pc ) );
+}
+
+int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
+{
+    __GLX_DECLARE_SWAP_VARIABLES;
+    GLbyte *lpc = pc;
+
+    lpc += sz_xGLXSingleReq;
+    __GLX_SWAP_INT(lpc+0);
+    __GLX_SWAP_INT(lpc+4);
+    __GLX_SWAP_INT(lpc+8);
+
+    /* reverse swapBytes */
+    *(GLboolean *)(lpc + 12) = ! *(GLboolean *)(lpc + 12);
+
+    return( __glXForwardPipe0WithReplySwap( cl, pc ) );
+}
+
+
diff --git a/xorg-server/hw/dmx/glxProxy/glxvendor.c b/xorg-server/hw/dmx/glxProxy/glxvendor.c
index 0b6ba4134..9dbc46daa 100644
--- a/xorg-server/hw/dmx/glxProxy/glxvendor.c
+++ b/xorg-server/hw/dmx/glxProxy/glxvendor.c
@@ -1,585 +1,585 @@
-/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include "dmx.h"
-#include "dmxwindow.h"
-#include "dmxpixmap.h"
-#include "dmxfont.h"
-
-#include "glxserver.h"
-#include "glxext.h"
-#include "g_disptab.h"
-/* #include "g_disptab_EXT.h" */
-#include "unpack.h"
-#include "glxutil.h"
-
-#include "GL/glxproto.h"
-
-#ifdef PANORAMIX
-#include "panoramiXsrv.h"
-#endif
-
-/*
- * GetReqVendorPrivate - this is the equivalent of GetReq macro
- *    from Xlibint.h but it does not set the reqType field (the opcode).
- *    this is because the GL single opcodes has different naming convension
- *    the other X opcodes (ie. X_GLsop_GetFloatv).
- */
-#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
-#define GetReqVendorPrivate(name, req) \
-        WORD64ALIGN\
-	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
-		_XFlush(dpy);\
-	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
-	req->length = (SIZEOF(x##name##Req))>>2;\
-	dpy->bufptr += SIZEOF(x##name##Req);\
-	dpy->request++
-
-#else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
-#define GetReqVendorPrivate(name, req) \
-        WORD64ALIGN\
-	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
-		_XFlush(dpy);\
-	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
-	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
-	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
-	dpy->request++
-#endif
-
-extern Display *GetBackEndDisplay( __GLXclientState *cl, int s );
-extern int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s);
-
-static int swap_vec_element_size = 0;
-
-static void SendSwappedReply( ClientPtr client,
-                              xGLXVendorPrivReply *reply, 
-			      char *buf,
-			      int   buf_size )
-{
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_SWAP_SHORT(&reply->sequenceNumber);
-   __GLX_SWAP_INT(&reply->length);
-   __GLX_SWAP_INT(&reply->retval);
-   __GLX_SWAP_INT(&reply->size);
-
-   if ( (buf_size == 0) && (swap_vec_element_size > 0) ) {
-      /*
-       * the reply has single component - need to swap pad3
-       */
-      if (swap_vec_element_size == 2) {
-	 __GLX_SWAP_SHORT(&reply->pad3);
-      }
-      else if (swap_vec_element_size == 4) {
-	 __GLX_SWAP_INT(&reply->pad3);
-	 __GLX_SWAP_INT(&reply->pad4);
-      }
-      else if (swap_vec_element_size == 8) {
-	 __GLX_SWAP_DOUBLE(&reply->pad3);
-      }
-   }
-   else if ( (buf_size > 0) && (swap_vec_element_size > 0) ) {
-      /*
-       * the reply has vector of elements which needs to be swapped
-       */
-      int vsize = buf_size / swap_vec_element_size;
-      char *p = buf;
-      int i;
-
-      for (i=0; i<vsize; i++) {
-	 if (swap_vec_element_size == 2) {
-	    __GLX_SWAP_SHORT(p);
-	 }
-	 else if (swap_vec_element_size == 4) {
-	    __GLX_SWAP_INT(p);
-	 }
-	 else if (swap_vec_element_size == 8) {
-	    __GLX_SWAP_DOUBLE(p);
-	 }
-
-	 p += swap_vec_element_size;
-      }
-
-      __GLX_SWAP_INT(&reply->pad3);
-      __GLX_SWAP_INT(&reply->pad4);
-      __GLX_SWAP_INT(&reply->pad5);
-      __GLX_SWAP_INT(&reply->pad6);
-
-   }
-
-    WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)reply);
-    if (buf_size > 0)
-       WriteToClient(client, buf_size, (char *)buf);
-
-}
-
-int __glXVForwardSingleReq( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   xGLXVendorPrivateReq *be_req;
-    __GLXcontext *glxc;
-   int from_screen = 0;
-   int to_screen = 0;
-   int buf_size;
-   int s;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXVendorPrivateReq;
-    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
-
-    /*
-     * just forward the request to back-end server(s)
-     */
-    for (s=from_screen; s<=to_screen; s++) {
-       DMXScreenInfo *dmxScreen = &dmxScreens[s];
-       Display *dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReqVendorPrivate(GLXVendorPrivate,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = req->glxCode;
-       be_req->length = req->length;
-       be_req->vendorCode = req->vendorCode;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       if (buf_size > 0) 
-	  _XSend(dpy, (const char *)pc, buf_size);
-       UnlockDisplay(dpy);
-       SyncHandle();
-    }
-
-    return Success;
-}
-
-int __glXVForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
-{
-   ClientPtr client = cl->client;
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   xGLXVendorPrivateReq *be_req;
-   xGLXVendorPrivReply reply;
-   xGLXVendorPrivReply be_reply;
-    __GLXcontext *glxc;
-   int buf_size;
-   char *be_buf = NULL;
-   int   be_buf_size;
-   DMXScreenInfo *dmxScreen;
-   Display *dpy;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return __glXBadContext;
-    }
-
-    pc += sz_xGLXVendorPrivateReq;
-    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
-
-    dmxScreen = &dmxScreens[glxc->pScreen->myNum];
-    dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
-
-    /* 
-     * send the request to the first back-end server
-     */
-    LockDisplay(dpy);
-    GetReqVendorPrivate(GLXVendorPrivate,be_req);
-    be_req->reqType = dmxScreen->glxMajorOpcode;
-    be_req->glxCode = req->glxCode;
-    be_req->length = req->length;
-    be_req->vendorCode = req->vendorCode;
-    be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag, glxc->pScreen->myNum);
-    if (buf_size > 0) 
-       _XSend(dpy, (const char *)pc, buf_size);
-
-    /*
-     * get the reply from the back-end server
-     */
-    _XReply(dpy, (xReply*) &be_reply, 0, False);
-    be_buf_size = be_reply.length << 2;
-    if (be_buf_size > 0) {
-       be_buf = (char *)malloc( be_buf_size );
-       if (be_buf) {
-	  _XRead(dpy, be_buf, be_buf_size);
-       }
-       else {
-	  /* Throw data on the floor */
-	  _XEatData(dpy, be_buf_size);
-	  return BadAlloc;
-       }
-    }
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-    /*
-     * send the reply to the client
-     */
-    memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    if (client->swapped) {
-       SendSwappedReply( client, &reply, be_buf, be_buf_size );
-    }
-    else {
-       WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
-       if (be_buf_size > 0)
-	  WriteToClient(client, be_buf_size, (char *)be_buf);
-    }
-
-    if (be_buf_size > 0) free(be_buf);
-
-    return Success;
-}
-
-int __glXVForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
-{
-   ClientPtr client = cl->client;
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   xGLXVendorPrivateReq *be_req;
-   xGLXVendorPrivReply reply;
-   xGLXVendorPrivReply be_reply;
-    __GLXcontext *glxc;
-   int buf_size;
-   char *be_buf = NULL;
-   int   be_buf_size = 0;
-   int from_screen = 0;
-   int to_screen = 0;
-   int s;
-
-   DMXScreenInfo *dmxScreen;
-   Display *dpy;
-
-    glxc = __glXLookupContextByTag(cl, req->contextTag);
-    if (!glxc) {
-	return 0;
-    }
-    from_screen = to_screen = glxc->pScreen->myNum;
-
-#ifdef PANORAMIX
-    if (!noPanoramiXExtension) {
-       from_screen = 0;
-       to_screen = screenInfo.numScreens - 1;
-    }
-#endif
-
-    pc += sz_xGLXVendorPrivateReq;
-    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
-
-    /* 
-     * send the request to the first back-end server(s)
-     */
-    for (s=to_screen; s>=from_screen; s--) {
-       dmxScreen = &dmxScreens[s];
-       dpy = GetBackEndDisplay(cl,s);
-
-       LockDisplay(dpy);
-       GetReqVendorPrivate(GLXVendorPrivate,be_req);
-       be_req->reqType = dmxScreen->glxMajorOpcode;
-       be_req->glxCode = req->glxCode;
-       be_req->length = req->length;
-       be_req->vendorCode = req->vendorCode;
-       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
-       if (buf_size > 0) 
-	  _XSend(dpy, (const char *)pc, buf_size);
-
-       /*
-	* get the reply from the back-end server
-	*/
-       _XReply(dpy, (xReply*) &be_reply, 0, False);
-       be_buf_size = be_reply.length << 2;
-       if (be_buf_size > 0) {
-	  be_buf = (char *)malloc( be_buf_size );
-	  if (be_buf) {
-	     _XRead(dpy, be_buf, be_buf_size);
-	  }
-	  else {
-	     /* Throw data on the floor */
-	     _XEatData(dpy, be_buf_size);
-	     return BadAlloc;
-	  }
-       }
-
-       UnlockDisplay(dpy);
-       SyncHandle();
-
-       if (s > from_screen && be_buf_size > 0) {
-	  free(be_buf);
-       }
-    }
-
-    /*
-     * send the reply to the client
-     */
-    memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
-
-    if (client->swapped) {
-       SendSwappedReply( client, &reply, be_buf, be_buf_size );
-    }
-    else {
-       WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
-       if (be_buf_size > 0)
-	  WriteToClient(client, be_buf_size, (char *)be_buf);
-    }
-
-    if (be_buf_size > 0) free(be_buf);
-
-    return Success;
-}
-
-int __glXVForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   return( __glXVForwardSingleReq( cl, pc ) );
-}
-
-int __glXVForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXVForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 2;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXVForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 4;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXVForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 8;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardPipe0WithReply( cl, pc ) );
-}
-
-int __glXVForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 0;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardAllWithReply( cl, pc ) );
-}
-
-int __glXVForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 2;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardAllWithReply( cl, pc ) );
-}
-
-int __glXVForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 4;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardAllWithReply( cl, pc ) );
-}
-
-int __glXVForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
-{
-   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
-   __GLX_DECLARE_SWAP_VARIABLES;
-   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-   __GLX_SWAP_SHORT(&req->length);
-   __GLX_SWAP_INT(&req->vendorCode);
-   __GLX_SWAP_INT(&req->contextTag);
-
-   swap_vec_element_size = 8;
-
-   /*
-    * swap extra data in request - assuming all data
-    * (if available) are arrays of 4 bytes components !
-    */
-   if (req->length > sz_xGLXVendorPrivateReq/4) {
-      int *data = (int *)(req+1);
-      int count = req->length - sz_xGLXVendorPrivateReq/4;
-      __GLX_SWAP_INT_ARRAY(data, count );
-   }
-
-   return( __glXVForwardAllWithReply( cl, pc ) );
-}
-
+/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxwindow.h"
+#include "dmxpixmap.h"
+#include "dmxfont.h"
+
+#include "glxserver.h"
+#include "glxext.h"
+#include "g_disptab.h"
+/* #include "g_disptab_EXT.h" */
+#include "unpack.h"
+#include "glxutil.h"
+
+#include "GL/glxproto.h"
+
+#ifdef PANORAMIX
+#include "panoramiXsrv.h"
+#endif
+
+/*
+ * GetReqVendorPrivate - this is the equivalent of GetReq macro
+ *    from Xlibint.h but it does not set the reqType field (the opcode).
+ *    this is because the GL single opcodes has different naming convension
+ *    the other X opcodes (ie. X_GLsop_GetFloatv).
+ */
+#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
+#define GetReqVendorPrivate(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+	req->length = (SIZEOF(x##name##Req))>>2;\
+	dpy->bufptr += SIZEOF(x##name##Req);\
+	dpy->request++
+
+#else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
+#define GetReqVendorPrivate(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
+	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
+	dpy->request++
+#endif
+
+extern Display *GetBackEndDisplay( __GLXclientState *cl, int s );
+extern int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s);
+
+static int swap_vec_element_size = 0;
+
+static void SendSwappedReply( ClientPtr client,
+                              xGLXVendorPrivReply *reply, 
+			      char *buf,
+			      int   buf_size )
+{
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_SWAP_SHORT(&reply->sequenceNumber);
+   __GLX_SWAP_INT(&reply->length);
+   __GLX_SWAP_INT(&reply->retval);
+   __GLX_SWAP_INT(&reply->size);
+
+   if ( (buf_size == 0) && (swap_vec_element_size > 0) ) {
+      /*
+       * the reply has single component - need to swap pad3
+       */
+      if (swap_vec_element_size == 2) {
+	 __GLX_SWAP_SHORT(&reply->pad3);
+      }
+      else if (swap_vec_element_size == 4) {
+	 __GLX_SWAP_INT(&reply->pad3);
+	 __GLX_SWAP_INT(&reply->pad4);
+      }
+      else if (swap_vec_element_size == 8) {
+	 __GLX_SWAP_DOUBLE(&reply->pad3);
+      }
+   }
+   else if ( (buf_size > 0) && (swap_vec_element_size > 0) ) {
+      /*
+       * the reply has vector of elements which needs to be swapped
+       */
+      int vsize = buf_size / swap_vec_element_size;
+      char *p = buf;
+      int i;
+
+      for (i=0; i<vsize; i++) {
+	 if (swap_vec_element_size == 2) {
+	    __GLX_SWAP_SHORT(p);
+	 }
+	 else if (swap_vec_element_size == 4) {
+	    __GLX_SWAP_INT(p);
+	 }
+	 else if (swap_vec_element_size == 8) {
+	    __GLX_SWAP_DOUBLE(p);
+	 }
+
+	 p += swap_vec_element_size;
+      }
+
+      __GLX_SWAP_INT(&reply->pad3);
+      __GLX_SWAP_INT(&reply->pad4);
+      __GLX_SWAP_INT(&reply->pad5);
+      __GLX_SWAP_INT(&reply->pad6);
+
+   }
+
+    WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)reply);
+    if (buf_size > 0)
+       WriteToClient(client, buf_size, (char *)buf);
+
+}
+
+int __glXVForwardSingleReq( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   xGLXVendorPrivateReq *be_req;
+    __GLXcontext *glxc;
+   int from_screen = 0;
+   int to_screen = 0;
+   int buf_size;
+   int s;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXVendorPrivateReq;
+    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
+
+    /*
+     * just forward the request to back-end server(s)
+     */
+    for (s=from_screen; s<=to_screen; s++) {
+       DMXScreenInfo *dmxScreen = &dmxScreens[s];
+       Display *dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReqVendorPrivate(GLXVendorPrivate,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = req->glxCode;
+       be_req->length = req->length;
+       be_req->vendorCode = req->vendorCode;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       if (buf_size > 0) 
+	  _XSend(dpy, (const char *)pc, buf_size);
+       UnlockDisplay(dpy);
+       SyncHandle();
+    }
+
+    return Success;
+}
+
+int __glXVForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
+{
+   ClientPtr client = cl->client;
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   xGLXVendorPrivateReq *be_req;
+   xGLXVendorPrivReply reply;
+   xGLXVendorPrivReply be_reply;
+    __GLXcontext *glxc;
+   int buf_size;
+   char *be_buf = NULL;
+   int   be_buf_size;
+   DMXScreenInfo *dmxScreen;
+   Display *dpy;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return __glXBadContext;
+    }
+
+    pc += sz_xGLXVendorPrivateReq;
+    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
+
+    dmxScreen = &dmxScreens[glxc->pScreen->myNum];
+    dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
+
+    /* 
+     * send the request to the first back-end server
+     */
+    LockDisplay(dpy);
+    GetReqVendorPrivate(GLXVendorPrivate,be_req);
+    be_req->reqType = dmxScreen->glxMajorOpcode;
+    be_req->glxCode = req->glxCode;
+    be_req->length = req->length;
+    be_req->vendorCode = req->vendorCode;
+    be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag, glxc->pScreen->myNum);
+    if (buf_size > 0) 
+       _XSend(dpy, (const char *)pc, buf_size);
+
+    /*
+     * get the reply from the back-end server
+     */
+    _XReply(dpy, (xReply*) &be_reply, 0, False);
+    be_buf_size = be_reply.length << 2;
+    if (be_buf_size > 0) {
+       be_buf = (char *)malloc( be_buf_size );
+       if (be_buf) {
+	  _XRead(dpy, be_buf, be_buf_size);
+       }
+       else {
+	  /* Throw data on the floor */
+	  _XEatData(dpy, be_buf_size);
+	  return BadAlloc;
+       }
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    /*
+     * send the reply to the client
+     */
+    memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if (client->swapped) {
+       SendSwappedReply( client, &reply, be_buf, be_buf_size );
+    }
+    else {
+       WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
+       if (be_buf_size > 0)
+	  WriteToClient(client, be_buf_size, (char *)be_buf);
+    }
+
+    if (be_buf_size > 0) free(be_buf);
+
+    return Success;
+}
+
+int __glXVForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
+{
+   ClientPtr client = cl->client;
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   xGLXVendorPrivateReq *be_req;
+   xGLXVendorPrivReply reply;
+   xGLXVendorPrivReply be_reply;
+    __GLXcontext *glxc;
+   int buf_size;
+   char *be_buf = NULL;
+   int   be_buf_size = 0;
+   int from_screen = 0;
+   int to_screen = 0;
+   int s;
+
+   DMXScreenInfo *dmxScreen;
+   Display *dpy;
+
+    glxc = __glXLookupContextByTag(cl, req->contextTag);
+    if (!glxc) {
+	return 0;
+    }
+    from_screen = to_screen = glxc->pScreen->myNum;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+       from_screen = 0;
+       to_screen = screenInfo.numScreens - 1;
+    }
+#endif
+
+    pc += sz_xGLXVendorPrivateReq;
+    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
+
+    /* 
+     * send the request to the first back-end server(s)
+     */
+    for (s=to_screen; s>=from_screen; s--) {
+       dmxScreen = &dmxScreens[s];
+       dpy = GetBackEndDisplay(cl,s);
+
+       LockDisplay(dpy);
+       GetReqVendorPrivate(GLXVendorPrivate,be_req);
+       be_req->reqType = dmxScreen->glxMajorOpcode;
+       be_req->glxCode = req->glxCode;
+       be_req->length = req->length;
+       be_req->vendorCode = req->vendorCode;
+       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
+       if (buf_size > 0) 
+	  _XSend(dpy, (const char *)pc, buf_size);
+
+       /*
+	* get the reply from the back-end server
+	*/
+       _XReply(dpy, (xReply*) &be_reply, 0, False);
+       be_buf_size = be_reply.length << 2;
+       if (be_buf_size > 0) {
+	  be_buf = (char *)malloc( be_buf_size );
+	  if (be_buf) {
+	     _XRead(dpy, be_buf, be_buf_size);
+	  }
+	  else {
+	     /* Throw data on the floor */
+	     _XEatData(dpy, be_buf_size);
+	     return BadAlloc;
+	  }
+       }
+
+       UnlockDisplay(dpy);
+       SyncHandle();
+
+       if (s > from_screen && be_buf_size > 0) {
+	  free(be_buf);
+       }
+    }
+
+    /*
+     * send the reply to the client
+     */
+    memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if (client->swapped) {
+       SendSwappedReply( client, &reply, be_buf, be_buf_size );
+    }
+    else {
+       WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
+       if (be_buf_size > 0)
+	  WriteToClient(client, be_buf_size, (char *)be_buf);
+    }
+
+    if (be_buf_size > 0) free(be_buf);
+
+    return Success;
+}
+
+int __glXVForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   return( __glXVForwardSingleReq( cl, pc ) );
+}
+
+int __glXVForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXVForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 2;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXVForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 4;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXVForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 8;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardPipe0WithReply( cl, pc ) );
+}
+
+int __glXVForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 0;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardAllWithReply( cl, pc ) );
+}
+
+int __glXVForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 2;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardAllWithReply( cl, pc ) );
+}
+
+int __glXVForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 4;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardAllWithReply( cl, pc ) );
+}
+
+int __glXVForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
+{
+   xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
+   __GLX_DECLARE_SWAP_VARIABLES;
+   __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+   __GLX_SWAP_SHORT(&req->length);
+   __GLX_SWAP_INT(&req->vendorCode);
+   __GLX_SWAP_INT(&req->contextTag);
+
+   swap_vec_element_size = 8;
+
+   /*
+    * swap extra data in request - assuming all data
+    * (if available) are arrays of 4 bytes components !
+    */
+   if (req->length > sz_xGLXVendorPrivateReq/4) {
+      int *data = (int *)(req+1);
+      int count = req->length - sz_xGLXVendorPrivateReq/4;
+      __GLX_SWAP_INT_ARRAY(data, count );
+   }
+
+   return( __glXVForwardAllWithReply( cl, pc ) );
+}
+
diff --git a/xorg-server/hw/dmx/glxProxy/render2swap.c b/xorg-server/hw/dmx/glxProxy/render2swap.c
index 81bb501ea..70ed5e802 100644
--- a/xorg-server/hw/dmx/glxProxy/render2swap.c
+++ b/xorg-server/hw/dmx/glxProxy/render2swap.c
@@ -1,286 +1,286 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxserver.h"
-#include "unpack.h"
-#include "g_disptab.h"
-
-GLint __glEvalComputeK(GLenum target)
-{
-    switch (target) {
-    case GL_MAP1_VERTEX_4:
-    case GL_MAP1_COLOR_4:
-    case GL_MAP1_TEXTURE_COORD_4:
-    case GL_MAP2_VERTEX_4:
-    case GL_MAP2_COLOR_4:
-    case GL_MAP2_TEXTURE_COORD_4:
-	return 4;
-    case GL_MAP1_VERTEX_3:
-    case GL_MAP1_TEXTURE_COORD_3:
-    case GL_MAP1_NORMAL:
-    case GL_MAP2_VERTEX_3:
-    case GL_MAP2_TEXTURE_COORD_3:
-    case GL_MAP2_NORMAL:
-	return 3;
-    case GL_MAP1_TEXTURE_COORD_2:
-    case GL_MAP2_TEXTURE_COORD_2:
-	return 2;
-    case GL_MAP1_TEXTURE_COORD_1:
-    case GL_MAP2_TEXTURE_COORD_1:
-    case GL_MAP1_INDEX:
-    case GL_MAP2_INDEX:
-	return 1;
-    default:
-	return 0;
-    }
-}
-
-void __glXDispSwap_Map1f(GLbyte *pc)
-{
-    GLint order, k;
-    GLfloat u1, u2, *points;
-    GLenum target;
-    GLint compsize;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-    __GLX_SWAP_INT(pc + 0);
-    __GLX_SWAP_INT(pc + 12);
-    __GLX_SWAP_FLOAT(pc + 4);
-    __GLX_SWAP_FLOAT(pc + 8);
-    
-    target = *(GLenum *)(pc + 0); 
-    order = *(GLint *)(pc + 12);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    points = (GLfloat *)(pc + 16);
-    k = __glEvalComputeK(target);
-
-    if (order <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = order * k;
-    }
-    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
-
-}
-
-void __glXDispSwap_Map2f(GLbyte *pc)
-{
-    GLint uorder, vorder, ustride, vstride, k;
-    GLfloat u1, u2, v1, v2, *points;
-    GLenum target;
-    GLint compsize;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-    __GLX_SWAP_INT(pc + 0);
-    __GLX_SWAP_INT(pc + 12);
-    __GLX_SWAP_INT(pc + 24);
-    __GLX_SWAP_FLOAT(pc + 4);
-    __GLX_SWAP_FLOAT(pc + 8);
-    __GLX_SWAP_FLOAT(pc + 16);
-    __GLX_SWAP_FLOAT(pc + 20);
-    
-    target = *(GLenum *)(pc + 0); 
-    uorder = *(GLint *)(pc + 12);
-    vorder = *(GLint *)(pc + 24);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    v1 = *(GLfloat *)(pc + 16);
-    v2 = *(GLfloat *)(pc + 20);
-    points = (GLfloat *)(pc + 28);
-
-    k = __glEvalComputeK(target);
-    ustride = vorder * k;
-    vstride = k;
-
-    if (vorder <= 0 || uorder <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = uorder * vorder * k;
-    }
-    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
-
-}
-
-void __glXDispSwap_Map1d(GLbyte *pc)
-{
-    GLint order, k, compsize;
-    GLenum target;
-    GLdouble u1, u2, *points;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-    __GLX_SWAP_DOUBLE(pc + 0);
-    __GLX_SWAP_DOUBLE(pc + 8);
-    __GLX_SWAP_INT(pc + 16);
-    __GLX_SWAP_INT(pc + 20);
-
-    target = *(GLenum*) (pc + 16);
-    order = *(GLint*) (pc + 20);
-    k = __glEvalComputeK(target);
-    if (order <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = order * k;
-    }
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
-    __GLX_SWAP_DOUBLE_ARRAY(pc+24, compsize);
-    pc += 24;
-
-#ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
-    }
-#else
-    points = (GLdouble*) pc;
-#endif
-}
-
-void __glXDispSwap_Map2d(GLbyte *pc)
-{
-    GLdouble u1, u2, v1, v2, *points;
-    GLint uorder, vorder, ustride, vstride, k, compsize;
-    GLenum target;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-    __GLX_SWAP_DOUBLE(pc + 0);
-    __GLX_SWAP_DOUBLE(pc + 8);
-    __GLX_SWAP_DOUBLE(pc + 16);
-    __GLX_SWAP_DOUBLE(pc + 24);
-    __GLX_SWAP_INT(pc + 32);
-    __GLX_SWAP_INT(pc + 36);
-    __GLX_SWAP_INT(pc + 40);
-
-    target = *(GLenum *)(pc + 32);
-    uorder = *(GLint *)(pc + 36);
-    vorder = *(GLint *)(pc + 40);
-    k = __glEvalComputeK(target);
-    if (vorder <= 0 || uorder <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = uorder * vorder * k;
-    }
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
-    __GLX_GET_DOUBLE(v1,pc+16);
-    __GLX_GET_DOUBLE(v2,pc+24);
-    __GLX_SWAP_DOUBLE_ARRAY(pc+44, compsize);
-    pc += 44;
-    ustride = vorder * k;
-    vstride = k;
-
-#ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
-    }
-#else
-    points = (GLdouble*) pc;
-#endif
-}
-
-void __glXDispSwap_CallLists(GLbyte *pc)
-{
-    GLenum type;
-    GLsizei n;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
-
-    __GLX_SWAP_INT(pc + 4);
-    __GLX_SWAP_INT(pc + 0);
-    type = *(GLenum *)(pc + 4);
-    n = *(GLsizei *)(pc + 0);
-
-    switch (type) {
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-      case GL_2_BYTES:
-      case GL_3_BYTES:
-      case GL_4_BYTES:
-	break;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	__GLX_SWAP_SHORT_ARRAY(pc+8, n);
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-	__GLX_SWAP_INT_ARRAY(pc+8, n);
-	break;
-      case GL_FLOAT:
-	__GLX_SWAP_FLOAT_ARRAY(pc+8, n);
-	break;
-    }
-
-}
-
-void __glXDispSwap_DrawArrays(GLbyte *pc)
-{
-    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *)pc;
-    __GLXdispatchDrawArraysComponentHeader *compHeader;
-    int i;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_INT(&hdr->numVertexes);
-    __GLX_SWAP_INT(&hdr->numComponents);
-    __GLX_SWAP_INT(&hdr->primType);
-
-    pc += sizeof(__GLXdispatchDrawArraysHeader);
-    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
-
-    /* compute stride (same for all component arrays) */
-    for (i=0; i<hdr->numComponents; i++) {
-	__GLX_SWAP_INT(&compHeader[i].datatype);
-	__GLX_SWAP_INT(&compHeader[i].numVals);
-	__GLX_SWAP_INT(&compHeader[i].component);
-
-    }
-
-}
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#include "glxserver.h"
+#include "unpack.h"
+#include "g_disptab.h"
+
+GLint __glEvalComputeK(GLenum target)
+{
+    switch (target) {
+    case GL_MAP1_VERTEX_4:
+    case GL_MAP1_COLOR_4:
+    case GL_MAP1_TEXTURE_COORD_4:
+    case GL_MAP2_VERTEX_4:
+    case GL_MAP2_COLOR_4:
+    case GL_MAP2_TEXTURE_COORD_4:
+	return 4;
+    case GL_MAP1_VERTEX_3:
+    case GL_MAP1_TEXTURE_COORD_3:
+    case GL_MAP1_NORMAL:
+    case GL_MAP2_VERTEX_3:
+    case GL_MAP2_TEXTURE_COORD_3:
+    case GL_MAP2_NORMAL:
+	return 3;
+    case GL_MAP1_TEXTURE_COORD_2:
+    case GL_MAP2_TEXTURE_COORD_2:
+	return 2;
+    case GL_MAP1_TEXTURE_COORD_1:
+    case GL_MAP2_TEXTURE_COORD_1:
+    case GL_MAP1_INDEX:
+    case GL_MAP2_INDEX:
+	return 1;
+    default:
+	return 0;
+    }
+}
+
+void __glXDispSwap_Map1f(GLbyte *pc)
+{
+    GLint order, k;
+    GLfloat u1, u2, *points;
+    GLenum target;
+    GLint compsize;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+    __GLX_SWAP_INT(pc + 0);
+    __GLX_SWAP_INT(pc + 12);
+    __GLX_SWAP_FLOAT(pc + 4);
+    __GLX_SWAP_FLOAT(pc + 8);
+    
+    target = *(GLenum *)(pc + 0); 
+    order = *(GLint *)(pc + 12);
+    u1 = *(GLfloat *)(pc + 4);
+    u2 = *(GLfloat *)(pc + 8);
+    points = (GLfloat *)(pc + 16);
+    k = __glEvalComputeK(target);
+
+    if (order <= 0 || k < 0) {
+	/* Erroneous command. */
+	compsize = 0;
+    } else {
+	compsize = order * k;
+    }
+    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
+
+}
+
+void __glXDispSwap_Map2f(GLbyte *pc)
+{
+    GLint uorder, vorder, ustride, vstride, k;
+    GLfloat u1, u2, v1, v2, *points;
+    GLenum target;
+    GLint compsize;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+    __GLX_SWAP_INT(pc + 0);
+    __GLX_SWAP_INT(pc + 12);
+    __GLX_SWAP_INT(pc + 24);
+    __GLX_SWAP_FLOAT(pc + 4);
+    __GLX_SWAP_FLOAT(pc + 8);
+    __GLX_SWAP_FLOAT(pc + 16);
+    __GLX_SWAP_FLOAT(pc + 20);
+    
+    target = *(GLenum *)(pc + 0); 
+    uorder = *(GLint *)(pc + 12);
+    vorder = *(GLint *)(pc + 24);
+    u1 = *(GLfloat *)(pc + 4);
+    u2 = *(GLfloat *)(pc + 8);
+    v1 = *(GLfloat *)(pc + 16);
+    v2 = *(GLfloat *)(pc + 20);
+    points = (GLfloat *)(pc + 28);
+
+    k = __glEvalComputeK(target);
+    ustride = vorder * k;
+    vstride = k;
+
+    if (vorder <= 0 || uorder <= 0 || k < 0) {
+	/* Erroneous command. */
+	compsize = 0;
+    } else {
+	compsize = uorder * vorder * k;
+    }
+    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
+
+}
+
+void __glXDispSwap_Map1d(GLbyte *pc)
+{
+    GLint order, k, compsize;
+    GLenum target;
+    GLdouble u1, u2, *points;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+    __GLX_SWAP_DOUBLE(pc + 0);
+    __GLX_SWAP_DOUBLE(pc + 8);
+    __GLX_SWAP_INT(pc + 16);
+    __GLX_SWAP_INT(pc + 20);
+
+    target = *(GLenum*) (pc + 16);
+    order = *(GLint*) (pc + 20);
+    k = __glEvalComputeK(target);
+    if (order <= 0 || k < 0) {
+	/* Erroneous command. */
+	compsize = 0;
+    } else {
+	compsize = order * k;
+    }
+    __GLX_GET_DOUBLE(u1,pc);
+    __GLX_GET_DOUBLE(u2,pc+8);
+    __GLX_SWAP_DOUBLE_ARRAY(pc+24, compsize);
+    pc += 24;
+
+#ifdef __GLX_ALIGN64
+    if (((unsigned long)pc) & 7) {
+	/*
+	** Copy the doubles up 4 bytes, trashing the command but aligning
+	** the data in the process
+	*/
+	__GLX_MEM_COPY(pc-4, pc, compsize*8);
+	points = (GLdouble*) (pc - 4);
+    } else {
+	points = (GLdouble*) pc;
+    }
+#else
+    points = (GLdouble*) pc;
+#endif
+}
+
+void __glXDispSwap_Map2d(GLbyte *pc)
+{
+    GLdouble u1, u2, v1, v2, *points;
+    GLint uorder, vorder, ustride, vstride, k, compsize;
+    GLenum target;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+    __GLX_SWAP_DOUBLE(pc + 0);
+    __GLX_SWAP_DOUBLE(pc + 8);
+    __GLX_SWAP_DOUBLE(pc + 16);
+    __GLX_SWAP_DOUBLE(pc + 24);
+    __GLX_SWAP_INT(pc + 32);
+    __GLX_SWAP_INT(pc + 36);
+    __GLX_SWAP_INT(pc + 40);
+
+    target = *(GLenum *)(pc + 32);
+    uorder = *(GLint *)(pc + 36);
+    vorder = *(GLint *)(pc + 40);
+    k = __glEvalComputeK(target);
+    if (vorder <= 0 || uorder <= 0 || k < 0) {
+	/* Erroneous command. */
+	compsize = 0;
+    } else {
+	compsize = uorder * vorder * k;
+    }
+    __GLX_GET_DOUBLE(u1,pc);
+    __GLX_GET_DOUBLE(u2,pc+8);
+    __GLX_GET_DOUBLE(v1,pc+16);
+    __GLX_GET_DOUBLE(v2,pc+24);
+    __GLX_SWAP_DOUBLE_ARRAY(pc+44, compsize);
+    pc += 44;
+    ustride = vorder * k;
+    vstride = k;
+
+#ifdef __GLX_ALIGN64
+    if (((unsigned long)pc) & 7) {
+	/*
+	** Copy the doubles up 4 bytes, trashing the command but aligning
+	** the data in the process
+	*/
+	__GLX_MEM_COPY(pc-4, pc, compsize*8);
+	points = (GLdouble*) (pc - 4);
+    } else {
+	points = (GLdouble*) pc;
+    }
+#else
+    points = (GLdouble*) pc;
+#endif
+}
+
+void __glXDispSwap_CallLists(GLbyte *pc)
+{
+    GLenum type;
+    GLsizei n;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+    __GLX_SWAP_INT(pc + 4);
+    __GLX_SWAP_INT(pc + 0);
+    type = *(GLenum *)(pc + 4);
+    n = *(GLsizei *)(pc + 0);
+
+    switch (type) {
+      case GL_BYTE:
+      case GL_UNSIGNED_BYTE:
+      case GL_2_BYTES:
+      case GL_3_BYTES:
+      case GL_4_BYTES:
+	break;
+      case GL_SHORT:
+      case GL_UNSIGNED_SHORT:
+	__GLX_SWAP_SHORT_ARRAY(pc+8, n);
+	break;
+      case GL_INT:
+      case GL_UNSIGNED_INT:
+	__GLX_SWAP_INT_ARRAY(pc+8, n);
+	break;
+      case GL_FLOAT:
+	__GLX_SWAP_FLOAT_ARRAY(pc+8, n);
+	break;
+    }
+
+}
+
+void __glXDispSwap_DrawArrays(GLbyte *pc)
+{
+    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *)pc;
+    __GLXdispatchDrawArraysComponentHeader *compHeader;
+    int i;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_INT(&hdr->numVertexes);
+    __GLX_SWAP_INT(&hdr->numComponents);
+    __GLX_SWAP_INT(&hdr->primType);
+
+    pc += sizeof(__GLXdispatchDrawArraysHeader);
+    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
+
+    /* compute stride (same for all component arrays) */
+    for (i=0; i<hdr->numComponents; i++) {
+	__GLX_SWAP_INT(&compHeader[i].datatype);
+	__GLX_SWAP_INT(&compHeader[i].numVals);
+	__GLX_SWAP_INT(&compHeader[i].component);
+
+    }
+
+}
diff --git a/xorg-server/hw/dmx/input/dmxevents.c b/xorg-server/hw/dmx/input/dmxevents.c
index 15d80f5bb..c8dd92e47 100644
--- a/xorg-server/hw/dmx/input/dmxevents.c
+++ b/xorg-server/hw/dmx/input/dmxevents.c
@@ -1,800 +1,800 @@
-/*
- * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.
- *
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- * Provide support and helper functions for enqueing events received by
- * the low-level input drivers. */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#define DMX_EVENTS_DEBUG 0
-
-#include "dmxinputinit.h"
-#include "dmxevents.h"
-#include "dmxcb.h"
-#include "dmxcommon.h"
-#include "dmxcursor.h"
-#include "dmxmotion.h"
-#include "dmxsigio.h"
-#include "dmxmap.h"
-
-#include <X11/keysym.h>
-#include "opaque.h"
-#include "inputstr.h"
-#include "inpututils.h"
-#include "mipointer.h"
-#include "mi.h"
-#include "exglobals.h"
-
-#include "xkbsrv.h"
-#include "XIstubs.h"
-
-static int  dmxGlobalX, dmxGlobalY; /* Global cursor position */
-static int  dmxGlobalInvalid;       /* Flag indicating dmxCoreMotion
-                                     * should move the mouse anyway. */
-
-#if DMX_EVENTS_DEBUG
-#define DMXDBG0(f)               dmxLog(dmxDebug,f)
-#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)
-#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)
-#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)
-#else
-#define DMXDBG0(f)
-#define DMXDBG1(f,a)
-#define DMXDBG2(f,a,b)
-#define DMXDBG3(f,a,b,c)
-#define DMXDBG4(f,a,b,c,d)
-#define DMXDBG5(f,a,b,c,d,e)
-#define DMXDBG6(f,a,b,c,d,e,g)
-#define DMXDBG7(f,a,b,c,d,e,g,h)
-#endif
-
-static int dmxApplyFunctions(DMXInputInfo *dmxInput, DMXFunctionType f)
-{
-    int i;
-    int rc = 0;
-
-    for (i = 0; i < dmxInput->numDevs; i+= dmxInput->devs[i]->binding)
-        if (dmxInput->devs[i]->functions)
-            rc += dmxInput->devs[i]->functions(dmxInput->devs[i]->private, f);
-    return rc;
-}
-
-static int dmxCheckFunctionKeys(DMXLocalInputInfoPtr dmxLocal,
-                                int type,
-                                KeySym keySym)
-{
-    DMXInputInfo   *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-
-#if 1 /* hack to detect ctrl-alt-q, etc */
-    static int ctrl = 0, alt = 0;
-    /* keep track of ctrl/alt key status */
-    if (type == KeyPress && keySym == 0xffe3) {
-        ctrl = 1;
-    }
-    else if (type == KeyRelease && keySym == 0xffe3) {
-        ctrl = 0;
-    }
-    else if (type == KeyPress && keySym == 0xffe9) {
-        alt = 1;
-    }
-    else if (type == KeyRelease && keySym == 0xffe9) {
-        alt = 0;
-    }
-    if (!ctrl || !alt)
-        return 0;
-#else
-    unsigned short state = 0;
-
-    if (dmxLocal->sendsCore)
-        state = dmxLocalCoreKeyboard->pDevice->key->state;
-    else if (dmxLocal->pDevice->key)
-        state = dmxLocal->pDevice->key->state;
-    
-    DMXDBG3("dmxCheckFunctionKeys: keySym=0x%04x %s state=0x%04x\n",
-            keySym, type == KeyPress ? "press" : "release", state);
-
-    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask))
-        return 0;
-#endif
-
-    switch (keySym) {
-    case XK_g:
-        if (type == KeyPress)
-            dmxApplyFunctions(dmxInput, DMX_FUNCTION_GRAB);
-        return 1;
-    case XK_f:
-        if (type == KeyPress)
-            dmxApplyFunctions(dmxInput, DMX_FUNCTION_FINE);
-        return 1;
-    case XK_q:
-        if (type == KeyPress && dmxLocal->sendsCore)
-            if (dmxApplyFunctions(dmxInput, DMX_FUNCTION_TERMINATE)) {
-                dmxLog(dmxInfo, "User request for termination\n");
-                dispatchException |= DE_TERMINATE;
-            }
-        return 1;
-    }
-    
-    return 0;
-}
-
-
-DMXScreenInfo *dmxFindFirstScreen(int x, int y)
-{
-    int i;
-
-    for (i = 0; i < dmxNumScreens; i++) {
-        DMXScreenInfo *dmxScreen = &dmxScreens[i];
-        if (dmxOnScreen(x, y, dmxScreen))
-            return dmxScreen;
-    }
-    return NULL;
-}
-
-
-/**
- * Enqueue a motion event.
- */
-static void enqueueMotion(DevicePtr pDev, int x, int y)
-{
-    GETDMXLOCALFROMPDEV;
-    DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
-    EventListPtr events;
-    int detail = 0;  /* XXX should this be mask of pressed buttons? */
-    ValuatorMask mask;
-    valuators[0] = x;
-    valuators[1] = y;
-
-    valuator_mask_set_range(&mask, 0, 2, valuators);
-    GetEventList(&events);
-    nevents = GetPointerEvents(events, p, MotionNotify, detail,
-                               POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-    for (i = 0; i < nevents; i++)
-       mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-    return;
-}
-
-
-void
-dmxCoreMotion(DevicePtr pDev, int x, int y, int delta, DMXBlockType block)
-{
-    DMXScreenInfo *dmxScreen;
-    DMXInputInfo  *dmxInput;
-    ScreenPtr     pScreen;
-    int           localX;
-    int           localY;
-    int           i;
-
-    if (!dmxGlobalInvalid && dmxGlobalX == x && dmxGlobalY == y)
-        return;
-    
-    DMXDBG5("dmxCoreMotion(%d,%d,%d) dmxGlobalX=%d dmxGlobalY=%d\n",
-            x, y, delta, dmxGlobalX, dmxGlobalY);
-
-    dmxGlobalInvalid = 0;
-    dmxGlobalX       = x;
-    dmxGlobalY       = y;
-
-    if (dmxGlobalX < 0)
-        dmxGlobalX = 0;
-    if (dmxGlobalY < 0)
-        dmxGlobalY = 0;
-    if (dmxGlobalX >= dmxGlobalWidth)
-        dmxGlobalX = dmxGlobalWidth  + delta -1;
-    if (dmxGlobalY >= dmxGlobalHeight)
-        dmxGlobalY = dmxGlobalHeight + delta -1;
-    
-    if ((dmxScreen = dmxFindFirstScreen(dmxGlobalX, dmxGlobalY))) {
-        localX = dmxGlobalX - dmxScreen->rootXOrigin;
-        localY = dmxGlobalY - dmxScreen->rootYOrigin;
-        if ((pScreen = miPointerGetScreen(inputInfo.pointer))
-            && pScreen->myNum == dmxScreen->index) {
-                                /* Screen is old screen */
-            if (block)
-                dmxSigioBlock();
-            if (pDev)
-               enqueueMotion(pDev, localX, localY);
-            if (block)
-                dmxSigioUnblock();
-        } else {
-                                /* Screen is new */
-            DMXDBG4("   New screen: old=%d new=%d localX=%d localY=%d\n",
-                    pScreen->myNum, dmxScreen->index, localX, localY);
-            if (block)
-                dmxSigioBlock();
-            mieqProcessInputEvents();
-            miPointerSetScreen(inputInfo.pointer, dmxScreen->index,
-                               localX, localY);
-            if (pDev)
-               enqueueMotion(pDev, localX, localY);
-            if (block)
-                dmxSigioUnblock();
-        }
-#if 00
-        miPointerGetPosition(inputInfo.pointer, &localX, &localY);
-
-        if ((pScreen = miPointerGetScreen(inputInfo.pointer))) {
-            dmxGlobalX = localX + dmxScreens[pScreen->myNum].rootXOrigin;
-            dmxGlobalY = localY + dmxScreens[pScreen->myNum].rootYOrigin;
-            ErrorF("Global is now %d, %d  %d, %d\n", dmxGlobalX, dmxGlobalY,
-                   localX, localY);
-            DMXDBG6("   Moved to dmxGlobalX=%d dmxGlobalY=%d"
-                    " on screen index=%d/%d localX=%d localY=%d\n",
-                    dmxGlobalX, dmxGlobalY,
-                    dmxScreen ? dmxScreen->index : -1, pScreen->myNum,
-                    localX, localY);
-        }
-#endif
-    }
-                                /* Send updates down to all core input
-                                 * drivers */
-    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {
-        int j;
-        for (j = 0; j < dmxInput->numDevs; j += dmxInput->devs[j]->binding)
-            if (!dmxInput->detached
-                && dmxInput->devs[j]->sendsCore
-                && dmxInput->devs[j]->update_position)
-                dmxInput->devs[j]->update_position(dmxInput->devs[j]->private,
-                                                   dmxGlobalX, dmxGlobalY);
-    }
-    if (!dmxScreen) ProcessInputEvents();
-}
-
-
-
-#define DMX_MAX_AXES 32         /* Max axes reported by this routine */
-static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
-                         int *v, int firstAxis, int axesCount,
-                         DMXMotionType type, DMXBlockType block)
-{
-    DeviceIntPtr           pDevice = dmxLocal->pDevice;
-    xEvent                 xE[2 * DMX_MAX_AXES/6];
-    deviceKeyButtonPointer *xev    = (deviceKeyButtonPointer *)xE;
-    deviceValuator         *xv     = (deviceValuator *)xev+1;
-    int                    thisX   = 0;
-    int                    thisY   = 0;
-    int                    i;
-    int                    count;
-    EventListPtr           events;
-    int                    nevents;
-    ValuatorMask           mask;
-
-    memset(xE, 0, sizeof(xE));
-
-    if (axesCount > DMX_MAX_AXES) axesCount = DMX_MAX_AXES;
-
-    if ((valuator_get_mode(pDevice,0) == Relative) && axesCount == 2) {
-                                /* The dmx console is a relative mode
-                                 * device that sometimes reports
-                                 * absolute motion.  It only has two
-                                 * axes. */
-        if (type == DMX_RELATIVE) {
-            thisX = -v[0];
-            thisY = -v[1];
-            dmxLocal->lastX += thisX;
-            dmxLocal->lastY += thisY;
-            if (dmxLocal->update_position)
-                dmxLocal->update_position(dmxLocal->private,
-                                          dmxLocal->lastX, dmxLocal->lastY);
-        } else {                    /* Convert to relative */
-            if (dmxLocal->lastX || dmxLocal->lastY) {
-                thisX = v[0] - dmxLocal->lastX;
-                thisY = v[1] - dmxLocal->lastY;
-            }
-            dmxLocal->lastX = v[0];
-            dmxLocal->lastY = v[1];
-        }
-        v[0] = thisX;
-        v[1] = thisY;
-    }
-
-    if (axesCount <= 6) {
-                                /* Optimize for the common case when
-                                 * only 1 or 2 axes change. */
-            xev->time          = GetTimeInMillis();
-            xev->type          = DeviceMotionNotify;
-            xev->detail        = 0;
-            xev->deviceid      = pDevice->id | MORE_EVENTS;
-            
-            xv->type           = DeviceValuator;
-            xv->deviceid       = pDevice->id;
-            xv->num_valuators  = axesCount;
-            xv->first_valuator = firstAxis;
-            switch (xv->num_valuators) {
-            case 6: xv->valuator5 = v[5];
-            case 5: xv->valuator4 = v[4];
-            case 4: xv->valuator3 = v[3];
-            case 3: xv->valuator2 = v[2];
-            case 2: xv->valuator1 = v[1];
-            case 1: xv->valuator0 = v[0];
-            }
-            count              = 2;
-    } else {
-        for (i = 0, count = 0; i < axesCount; i += 6) {
-            xev->time          = GetTimeInMillis();
-            xev->type          = DeviceMotionNotify;
-            xev->detail        = 0;
-            xev->deviceid      = pDevice->id | MORE_EVENTS;
-            xev               += 2;
-            
-            xv->type           = DeviceValuator;
-            xv->deviceid       = pDevice->id;
-            xv->num_valuators  = (i+6 >= axesCount ? axesCount - i : 6);
-            xv->first_valuator = firstAxis + i;
-            switch (xv->num_valuators) {
-            case 6: xv->valuator5 = v[i+5];
-            case 5: xv->valuator4 = v[i+4];
-            case 4: xv->valuator3 = v[i+3];
-            case 3: xv->valuator2 = v[i+2];
-            case 2: xv->valuator1 = v[i+1];
-            case 1: xv->valuator0 = v[i+0];
-            }
-            xv                += 2;
-            count             += 2;
-        }
-    }
-
-    if (block)
-        dmxSigioBlock();
-    valuator_mask_set_range(&mask, firstAxis, axesCount, v);
-    GetEventList(&events);
-    nevents = GetPointerEvents(events, pDevice, MotionNotify, 0,
-                               POINTER_ABSOLUTE, &mask);
-    for (i = 0; i < nevents; i++)
-        mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-    if (block)
-        dmxSigioUnblock();
-}
-
-static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
-                                          XEvent *e, DMXBlockType block)
-{
-    int                    type;
-    int                    event   = -1;
-    XDeviceKeyEvent        *ke     = (XDeviceKeyEvent *)e;
-    XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;
-    DeviceIntPtr           pDevice = dmxLocal->pDevice;
-    int                    valuators[MAX_VALUATORS];
-    EventListPtr           events;
-    int                    nevents, i;
-    ValuatorMask           mask;
-
-    if (!e)
-        return -1;          /* No extended event passed, cannot handle */
-
-    if ((XID)dmxLocal->deviceId != ke->deviceid) {
-                                /* Search for the correct dmxLocal,
-                                 * since backend and console events are
-                                 * picked up for the first device on
-                                 * that X server. */
-        int i;
-        DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];
-        for (i = 0; i < dmxInput->numDevs; i++) {
-            dmxLocal = dmxInput->devs[i];
-            if ((XID)dmxLocal->deviceId == ke->deviceid)
-                break;
-        }
-    }
-
-    if ((XID)dmxLocal->deviceId != ke->deviceid
-        || (type = dmxMapLookup(dmxLocal, e->type)) < 0)
-        return -1;    /* No mapping, so this event is unhandled */
-
-    switch (type) {
-    case XI_DeviceValuator:          event = DeviceValuator;          break;
-    case XI_DeviceKeyPress:          event = KeyPress;                break;
-    case XI_DeviceKeyRelease:        event = KeyRelease;              break;
-    case XI_DeviceButtonPress:       event = ButtonPress;             break;
-    case XI_DeviceButtonRelease:     event = ButtonRelease;           break;
-    case XI_DeviceMotionNotify:      event = MotionNotify;            break;
-    case XI_DeviceFocusIn:           event = DeviceFocusIn;           break;
-    case XI_DeviceFocusOut:          event = DeviceFocusOut;          break;
-    case XI_ProximityIn:             event = ProximityIn;             break;
-    case XI_ProximityOut:            event = ProximityOut;            break;
-    case XI_DeviceStateNotify:       event = DeviceStateNotify;       break;
-    case XI_DeviceMappingNotify:     event = DeviceMappingNotify;     break;
-    case XI_ChangeDeviceNotify:      event = ChangeDeviceNotify;      break;
-    case XI_DeviceKeystateNotify:    event = DeviceStateNotify;       break;
-    case XI_DeviceButtonstateNotify: event = DeviceStateNotify;       break;
-    }
-
-#define EXTRACT_VALUATORS(ke, valuators) \
-        valuators[0] = ke->axis_data[0]; \
-        valuators[1] = ke->axis_data[1]; \
-        valuators[2] = ke->axis_data[2]; \
-        valuators[3] = ke->axis_data[3]; \
-        valuators[4] = ke->axis_data[4]; \
-        valuators[5] = ke->axis_data[5]; \
-
-    switch (type) {
-    case XI_DeviceKeyPress:
-    case XI_DeviceKeyRelease:
-        EXTRACT_VALUATORS(ke, valuators);
-        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetKeyboardEvents(events, pDevice, event,
-                                    ke->keycode, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-    case XI_DeviceButtonPress:
-    case XI_DeviceButtonRelease:
-        EXTRACT_VALUATORS(ke, valuators);
-        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
-                                   POINTER_ABSOLUTE, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-    case XI_ProximityIn:
-    case XI_ProximityOut:
-        EXTRACT_VALUATORS(ke, valuators);
-        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
-        if (block)
-            dmxSigioBlock();
-        GetEventList(&events);
-        nevents = GetProximityEvents(events, pDevice, event, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
-
-        if (block)
-            dmxSigioUnblock();
-        break;
-
-        break;
-
-    case XI_DeviceMotionNotify:
-        dmxExtMotion(dmxLocal, me->axis_data, me->first_axis, me->axes_count,
-                     DMX_ABSOLUTE, block);
-        break;
-    case XI_DeviceFocusIn:
-    case XI_DeviceFocusOut:
-    case XI_DeviceStateNotify:
-    case XI_DeviceMappingNotify:
-    case XI_ChangeDeviceNotify:
-    case XI_DeviceKeystateNotify:
-    case XI_DeviceButtonstateNotify:
-                                /* These are ignored, since DMX will
-                                 * generate its own events of these
-                                 * types, as necessary.
-
-                                 * Perhaps ChangeDeviceNotify should
-                                 * generate an error, because it is
-                                 * unexpected? */
-        break;
-    case XI_DeviceValuator:
-    default:
-        dmxLog(dmxWarning,
-               "XInput extension event (remote=%d -> zero-based=%d)"
-               " not supported yet\n", e->type, type);
-        return -1;
-    }
-    return 0;
-}
-
-static int dmxGetButtonMapping(DMXLocalInputInfoPtr dmxLocal, int button)
-{
-    ButtonClassPtr b = dmxLocal->pDevice->button;
-
-    if (button > b->numButtons) { /* This shouldn't happen. */
-        dmxLog(dmxWarning, "Button %d pressed, but only %d buttons?!?\n",
-               button, b->numButtons);
-        return button;
-    }
-    return b->map[button];
-}
-
-/** Return DMX's notion of the pointer position in the global coordinate
- * space. */
-void dmxGetGlobalPosition(int *x, int *y)
-{
-    *x = dmxGlobalX;
-    *y = dmxGlobalY;
-}
-
-/** Invalidate the global position for #dmxCoreMotion. */
-void dmxInvalidateGlobalPosition(void)
-{
-    dmxGlobalInvalid = 1;
-}
-
-/** Enqueue a motion event for \a pDev.  The \a v vector has length \a
- * axesCount, and contains values for each of the axes, starting at \a
- * firstAxes.
- *
- * The \a type of the motion may be \a DMX_RELATIVE, \a DMX_ABSOLUTE, or
- * \a DMX_ABSOLUTE_CONFINED (in the latter case, the pointer will not be
- * allowed to move outside the global boundaires).
- *
- * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
- * blocked around calls to \a enqueueMotion(). */
-void dmxMotion(DevicePtr pDev, int *v, int firstAxes, int axesCount,
-               DMXMotionType type, DMXBlockType block)
-{
-    GETDMXLOCALFROMPDEV;
-
-    if (!dmxLocal->sendsCore) {
-        dmxExtMotion(dmxLocal, v, firstAxes, axesCount, type, block);
-        return;
-    }
-    if (axesCount == 2) {
-        switch (type) {
-        case DMX_RELATIVE:
-            dmxCoreMotion(pDev, dmxGlobalX - v[0], dmxGlobalY - v[1], 0, block);
-            break;
-        case DMX_ABSOLUTE:
-            dmxCoreMotion(pDev, v[0], v[1], 0, block);
-            break;
-        case DMX_ABSOLUTE_CONFINED:
-            dmxCoreMotion(pDev, v[0], v[1], -1, block);
-            break;
-        }
-    }
-}
-
-static KeySym dmxKeyCodeToKeySym(DMXLocalInputInfoPtr dmxLocal,
-                                 KeyCode keyCode)
-{
-    KeySym keysym = NoSymbol;
-    int effectiveGroup;
-    XkbSrvInfoPtr xkbi;
-
-    if (!dmxLocal || !dmxLocal->pDevice || !dmxLocal->pDevice->key)
-        goto out;
-
-    xkbi = dmxLocal->pDevice->key->xkbInfo;
-    effectiveGroup = XkbGetEffectiveGroup(xkbi, &xkbi->state, keyCode);
-
-    if (effectiveGroup == -1)
-        goto out;
-
-    keysym = XkbKeySym(xkbi->desc, keyCode, effectiveGroup);
-    DMXDBG2("dmxKeyCodeToKeySym: Translated keyCode=%d to keySym=0x%04x\n",
-            keyCode, keysym);
-
-out:
-    return keysym;
-}
-
-static KeyCode dmxKeySymToKeyCode(DMXLocalInputInfoPtr dmxLocal, KeySym keySym,
-                                  int tryFirst)
-{
-    /* FIXME: this is quite ineffective, converting to a core map first and
-     * then extracting the info from there. It'd be better to run the actual
-     * xkb map */
-    XkbSrvInfoPtr xkbi = dmxLocal->pDevice->key->xkbInfo;
-    KeySymsPtr pKeySyms = XkbGetCoreMap(dmxLocal->pDevice);
-    int        i;
-
-                                /* Optimize for similar maps */
-    if (XkbKeycodeInRange(xkbi->desc, tryFirst)
-        && pKeySyms->map[(tryFirst - xkbi->desc->min_key_code)
-                         * pKeySyms->mapWidth] == keySym)
-        return tryFirst;
-
-    for (i = pKeySyms->minKeyCode; i <= pKeySyms->maxKeyCode; i++) {
-        if (pKeySyms->map[(i - pKeySyms->minKeyCode)
-                          * pKeySyms->mapWidth] == keySym) {
-            DMXDBG3("dmxKeySymToKeyCode: Translated keySym=0x%04x to"
-                    " keyCode=%d (reverses to core keySym=0x%04x)\n",
-                    keySym, i, dmxKeyCodeToKeySym(dmxLocalCoreKeyboard,i));
-            return i;
-        }
-    }
-    return 0;
-}
-
-static int dmxFixup(DevicePtr pDev, int detail, KeySym keySym)
-{
-    GETDMXLOCALFROMPDEV;
-    int keyCode;
-    
-    if (!dmxLocal->pDevice->key) {
-        dmxLog(dmxWarning, "dmxFixup: not a keyboard device (%s)\n",
-               dmxLocal->pDevice->name);
-        return NoSymbol;
-    }
-    if (!keySym)
-        keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
-    if (keySym == NoSymbol)
-        return detail;
-    keyCode = dmxKeySymToKeyCode(dmxLocalCoreKeyboard, keySym, detail);
-
-    return keyCode ? keyCode : detail;
-}
-
-/** Enqueue an event from the \a pDev device with the
- * specified \a type and \a detail.  If the event is a KeyPress or
- * KeyRelease event, then the \a keySym is also specified.
- *
- * FIXME: make the code do what the comment says, or remove this comment.
- * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
- * blocked around calls to dmxeqEnqueue(). */
-    
-void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
-                XEvent *e, DMXBlockType block)
-{
-    GETDMXINPUTFROMPDEV;
-    xEvent xE;
-    DeviceIntPtr p = dmxLocal->pDevice;
-    int i, nevents, valuators[3];
-    EventListPtr events;
-    ValuatorMask mask;
-
-    DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);
-
-    switch (type) {
-    case KeyPress:
-    case KeyRelease:
-        if (!keySym)
-            keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
-        if (dmxCheckFunctionKeys(dmxLocal, type, keySym))
-            return;
-        if (dmxLocal->sendsCore && dmxLocal != dmxLocalCoreKeyboard)
-            xE.u.u.detail = dmxFixup(pDev, detail, keySym);
-
-        GetEventList(&events);
-        /*ErrorF("KEY %d  sym %d\n", detail, (int) keySym);*/
-        nevents = GetKeyboardEvents(events, p, type, detail, NULL);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case ButtonPress:
-    case ButtonRelease:
-        detail = dmxGetButtonMapping(dmxLocal, detail);
-        valuator_mask_zero(&mask);
-        GetEventList(&events);
-        nevents = GetPointerEvents(events, p, type, detail,
-                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case MotionNotify:
-        GetEventList(&events);
-        valuators[0] = e->xmotion.x;
-        valuators[1] = e->xmotion.y;
-        valuators[2] = e->xmotion.state; /* FIXME: WTF?? */
-        valuator_mask_set_range(&mask, 0, 3, valuators);
-        nevents = GetPointerEvents(events, p, type, detail, 
-                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
-        for (i = 0; i < nevents; i++)
-            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
-        return;
-
-    case EnterNotify:
-    case LeaveNotify:
-    case KeymapNotify:
-    case MappingNotify:         /* This is sent because we change the
-                                 * modifier map on the backend/console
-                                 * input device so that we have complete
-                                 * control of the input device LEDs. */
-        return;
-    default:
-        if (type == ProximityIn || type == ProximityOut) {
-            if (dmxLocal->sendsCore)
-                return; /* Not a core event */
-            break;
-        }
-        if (type >= LASTEvent) {
-            if (dmxTranslateAndEnqueueExtEvent(dmxLocal, e, block))
-                dmxLogInput(dmxInput, "Unhandled extension event: %d\n", type);
-        } else {
-            dmxLogInput(dmxInput, "Unhandled event: %d (%s)\n",
-                        type, dmxEventName(type));
-        }
-        return;
-    }
-
-}
-
-/** A pointer to this routine is passed to low-level input drivers so
- * that all special keychecking is unified to this file.  This function
- * returns 0 if no special keys have been pressed.  If the user has
- * requested termination of the DMX server, -1 is returned.  If the user
- * has requested a switch to a VT, then the (1-based) number of that VT
- * is returned. */
-int dmxCheckSpecialKeys(DevicePtr pDev, KeySym keySym)
-{
-    GETDMXINPUTFROMPDEV;
-    int            vt    = 0;
-    unsigned short state = 0;
-
-    if (dmxLocal->sendsCore)
-        state = XkbStateFieldFromRec(&dmxLocalCoreKeyboard->pDevice->key->xkbInfo->state);
-    else if (dmxLocal->pDevice->key)
-        state = XkbStateFieldFromRec(&dmxLocal->pDevice->key->xkbInfo->state);
-
-    if (!dmxLocal->sendsCore) return 0; /* Only for core devices */
-
-    DMXDBG2("dmxCheckSpecialKeys: keySym=0x%04x state=0x%04x\n", keySym,state);
-    
-    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask)) return 0;
-    
-    switch (keySym) {
-    case XK_F1:
-    case XK_F2:
-    case XK_F3:
-    case XK_F4:
-    case XK_F5:
-    case XK_F6:
-    case XK_F7:
-    case XK_F8:
-    case XK_F9:
-    case XK_F10:
-        vt = keySym - XK_F1 + 1;
-        break;
-
-    case XK_F11:
-    case XK_F12:
-        vt = keySym - XK_F11 + 11;
-        break;
-
-    case XK_q:                  /* To avoid confusion  */
-    case XK_BackSpace:
-    case XK_Delete:
-    case XK_KP_Delete:
-        dmxLog(dmxInfo, "User request for termination\n");
-        dispatchException |= DE_TERMINATE;
-        return -1;              /* Terminate */
-    }
-
-    if (vt) {
-        dmxLog(dmxInfo, "Request to switch to VT %d\n", vt);
-        dmxInput->vt_switch_pending = vt;
-        return vt;
-    }
-
-    return 0;                   /* Do nothing */
-}
+/*
+ * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ * Provide support and helper functions for enqueing events received by
+ * the low-level input drivers. */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#define DMX_EVENTS_DEBUG 0
+
+#include "dmxinputinit.h"
+#include "dmxevents.h"
+#include "dmxcb.h"
+#include "dmxcommon.h"
+#include "dmxcursor.h"
+#include "dmxmotion.h"
+#include "dmxsigio.h"
+#include "dmxmap.h"
+
+#include <X11/keysym.h>
+#include "opaque.h"
+#include "inputstr.h"
+#include "inpututils.h"
+#include "mipointer.h"
+#include "mi.h"
+#include "exglobals.h"
+
+#include "xkbsrv.h"
+#include "XIstubs.h"
+
+static int  dmxGlobalX, dmxGlobalY; /* Global cursor position */
+static int  dmxGlobalInvalid;       /* Flag indicating dmxCoreMotion
+                                     * should move the mouse anyway. */
+
+#if DMX_EVENTS_DEBUG
+#define DMXDBG0(f)               dmxLog(dmxDebug,f)
+#define DMXDBG1(f,a)             dmxLog(dmxDebug,f,a)
+#define DMXDBG2(f,a,b)           dmxLog(dmxDebug,f,a,b)
+#define DMXDBG3(f,a,b,c)         dmxLog(dmxDebug,f,a,b,c)
+#define DMXDBG4(f,a,b,c,d)       dmxLog(dmxDebug,f,a,b,c,d)
+#define DMXDBG5(f,a,b,c,d,e)     dmxLog(dmxDebug,f,a,b,c,d,e)
+#define DMXDBG6(f,a,b,c,d,e,g)   dmxLog(dmxDebug,f,a,b,c,d,e,g)
+#define DMXDBG7(f,a,b,c,d,e,g,h) dmxLog(dmxDebug,f,a,b,c,d,e,g,h)
+#else
+#define DMXDBG0(f)
+#define DMXDBG1(f,a)
+#define DMXDBG2(f,a,b)
+#define DMXDBG3(f,a,b,c)
+#define DMXDBG4(f,a,b,c,d)
+#define DMXDBG5(f,a,b,c,d,e)
+#define DMXDBG6(f,a,b,c,d,e,g)
+#define DMXDBG7(f,a,b,c,d,e,g,h)
+#endif
+
+static int dmxApplyFunctions(DMXInputInfo *dmxInput, DMXFunctionType f)
+{
+    int i;
+    int rc = 0;
+
+    for (i = 0; i < dmxInput->numDevs; i+= dmxInput->devs[i]->binding)
+        if (dmxInput->devs[i]->functions)
+            rc += dmxInput->devs[i]->functions(dmxInput->devs[i]->private, f);
+    return rc;
+}
+
+static int dmxCheckFunctionKeys(DMXLocalInputInfoPtr dmxLocal,
+                                int type,
+                                KeySym keySym)
+{
+    DMXInputInfo   *dmxInput = &dmxInputs[dmxLocal->inputIdx];
+
+#if 1 /* hack to detect ctrl-alt-q, etc */
+    static int ctrl = 0, alt = 0;
+    /* keep track of ctrl/alt key status */
+    if (type == KeyPress && keySym == 0xffe3) {
+        ctrl = 1;
+    }
+    else if (type == KeyRelease && keySym == 0xffe3) {
+        ctrl = 0;
+    }
+    else if (type == KeyPress && keySym == 0xffe9) {
+        alt = 1;
+    }
+    else if (type == KeyRelease && keySym == 0xffe9) {
+        alt = 0;
+    }
+    if (!ctrl || !alt)
+        return 0;
+#else
+    unsigned short state = 0;
+
+    if (dmxLocal->sendsCore)
+        state = dmxLocalCoreKeyboard->pDevice->key->state;
+    else if (dmxLocal->pDevice->key)
+        state = dmxLocal->pDevice->key->state;
+    
+    DMXDBG3("dmxCheckFunctionKeys: keySym=0x%04x %s state=0x%04x\n",
+            keySym, type == KeyPress ? "press" : "release", state);
+
+    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask))
+        return 0;
+#endif
+
+    switch (keySym) {
+    case XK_g:
+        if (type == KeyPress)
+            dmxApplyFunctions(dmxInput, DMX_FUNCTION_GRAB);
+        return 1;
+    case XK_f:
+        if (type == KeyPress)
+            dmxApplyFunctions(dmxInput, DMX_FUNCTION_FINE);
+        return 1;
+    case XK_q:
+        if (type == KeyPress && dmxLocal->sendsCore)
+            if (dmxApplyFunctions(dmxInput, DMX_FUNCTION_TERMINATE)) {
+                dmxLog(dmxInfo, "User request for termination\n");
+                dispatchException |= DE_TERMINATE;
+            }
+        return 1;
+    }
+    
+    return 0;
+}
+
+
+DMXScreenInfo *dmxFindFirstScreen(int x, int y)
+{
+    int i;
+
+    for (i = 0; i < dmxNumScreens; i++) {
+        DMXScreenInfo *dmxScreen = &dmxScreens[i];
+        if (dmxOnScreen(x, y, dmxScreen))
+            return dmxScreen;
+    }
+    return NULL;
+}
+
+
+/**
+ * Enqueue a motion event.
+ */
+static void enqueueMotion(DevicePtr pDev, int x, int y)
+{
+    GETDMXLOCALFROMPDEV;
+    DeviceIntPtr p = dmxLocal->pDevice;
+    int i, nevents, valuators[3];
+    EventListPtr events;
+    int detail = 0;  /* XXX should this be mask of pressed buttons? */
+    ValuatorMask mask;
+    valuators[0] = x;
+    valuators[1] = y;
+
+    valuator_mask_set_range(&mask, 0, 2, valuators);
+    GetEventList(&events);
+    nevents = GetPointerEvents(events, p, MotionNotify, detail,
+                               POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
+    for (i = 0; i < nevents; i++)
+       mieqEnqueue(p, (InternalEvent*)(events + i)->event);
+    return;
+}
+
+
+void
+dmxCoreMotion(DevicePtr pDev, int x, int y, int delta, DMXBlockType block)
+{
+    DMXScreenInfo *dmxScreen;
+    DMXInputInfo  *dmxInput;
+    ScreenPtr     pScreen;
+    int           localX;
+    int           localY;
+    int           i;
+
+    if (!dmxGlobalInvalid && dmxGlobalX == x && dmxGlobalY == y)
+        return;
+    
+    DMXDBG5("dmxCoreMotion(%d,%d,%d) dmxGlobalX=%d dmxGlobalY=%d\n",
+            x, y, delta, dmxGlobalX, dmxGlobalY);
+
+    dmxGlobalInvalid = 0;
+    dmxGlobalX       = x;
+    dmxGlobalY       = y;
+
+    if (dmxGlobalX < 0)
+        dmxGlobalX = 0;
+    if (dmxGlobalY < 0)
+        dmxGlobalY = 0;
+    if (dmxGlobalX >= dmxGlobalWidth)
+        dmxGlobalX = dmxGlobalWidth  + delta -1;
+    if (dmxGlobalY >= dmxGlobalHeight)
+        dmxGlobalY = dmxGlobalHeight + delta -1;
+    
+    if ((dmxScreen = dmxFindFirstScreen(dmxGlobalX, dmxGlobalY))) {
+        localX = dmxGlobalX - dmxScreen->rootXOrigin;
+        localY = dmxGlobalY - dmxScreen->rootYOrigin;
+        if ((pScreen = miPointerGetScreen(inputInfo.pointer))
+            && pScreen->myNum == dmxScreen->index) {
+                                /* Screen is old screen */
+            if (block)
+                dmxSigioBlock();
+            if (pDev)
+               enqueueMotion(pDev, localX, localY);
+            if (block)
+                dmxSigioUnblock();
+        } else {
+                                /* Screen is new */
+            DMXDBG4("   New screen: old=%d new=%d localX=%d localY=%d\n",
+                    pScreen->myNum, dmxScreen->index, localX, localY);
+            if (block)
+                dmxSigioBlock();
+            mieqProcessInputEvents();
+            miPointerSetScreen(inputInfo.pointer, dmxScreen->index,
+                               localX, localY);
+            if (pDev)
+               enqueueMotion(pDev, localX, localY);
+            if (block)
+                dmxSigioUnblock();
+        }
+#if 00
+        miPointerGetPosition(inputInfo.pointer, &localX, &localY);
+
+        if ((pScreen = miPointerGetScreen(inputInfo.pointer))) {
+            dmxGlobalX = localX + dmxScreens[pScreen->myNum].rootXOrigin;
+            dmxGlobalY = localY + dmxScreens[pScreen->myNum].rootYOrigin;
+            ErrorF("Global is now %d, %d  %d, %d\n", dmxGlobalX, dmxGlobalY,
+                   localX, localY);
+            DMXDBG6("   Moved to dmxGlobalX=%d dmxGlobalY=%d"
+                    " on screen index=%d/%d localX=%d localY=%d\n",
+                    dmxGlobalX, dmxGlobalY,
+                    dmxScreen ? dmxScreen->index : -1, pScreen->myNum,
+                    localX, localY);
+        }
+#endif
+    }
+                                /* Send updates down to all core input
+                                 * drivers */
+    for (i = 0, dmxInput = &dmxInputs[0]; i < dmxNumInputs; i++, dmxInput++) {
+        int j;
+        for (j = 0; j < dmxInput->numDevs; j += dmxInput->devs[j]->binding)
+            if (!dmxInput->detached
+                && dmxInput->devs[j]->sendsCore
+                && dmxInput->devs[j]->update_position)
+                dmxInput->devs[j]->update_position(dmxInput->devs[j]->private,
+                                                   dmxGlobalX, dmxGlobalY);
+    }
+    if (!dmxScreen) ProcessInputEvents();
+}
+
+
+
+#define DMX_MAX_AXES 32         /* Max axes reported by this routine */
+static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
+                         int *v, int firstAxis, int axesCount,
+                         DMXMotionType type, DMXBlockType block)
+{
+    DeviceIntPtr           pDevice = dmxLocal->pDevice;
+    xEvent                 xE[2 * DMX_MAX_AXES/6];
+    deviceKeyButtonPointer *xev    = (deviceKeyButtonPointer *)xE;
+    deviceValuator         *xv     = (deviceValuator *)xev+1;
+    int                    thisX   = 0;
+    int                    thisY   = 0;
+    int                    i;
+    int                    count;
+    EventListPtr           events;
+    int                    nevents;
+    ValuatorMask           mask;
+
+    memset(xE, 0, sizeof(xE));
+
+    if (axesCount > DMX_MAX_AXES) axesCount = DMX_MAX_AXES;
+
+    if ((valuator_get_mode(pDevice,0) == Relative) && axesCount == 2) {
+                                /* The dmx console is a relative mode
+                                 * device that sometimes reports
+                                 * absolute motion.  It only has two
+                                 * axes. */
+        if (type == DMX_RELATIVE) {
+            thisX = -v[0];
+            thisY = -v[1];
+            dmxLocal->lastX += thisX;
+            dmxLocal->lastY += thisY;
+            if (dmxLocal->update_position)
+                dmxLocal->update_position(dmxLocal->private,
+                                          dmxLocal->lastX, dmxLocal->lastY);
+        } else {                    /* Convert to relative */
+            if (dmxLocal->lastX || dmxLocal->lastY) {
+                thisX = v[0] - dmxLocal->lastX;
+                thisY = v[1] - dmxLocal->lastY;
+            }
+            dmxLocal->lastX = v[0];
+            dmxLocal->lastY = v[1];
+        }
+        v[0] = thisX;
+        v[1] = thisY;
+    }
+
+    if (axesCount <= 6) {
+                                /* Optimize for the common case when
+                                 * only 1 or 2 axes change. */
+            xev->time          = GetTimeInMillis();
+            xev->type          = DeviceMotionNotify;
+            xev->detail        = 0;
+            xev->deviceid      = pDevice->id | MORE_EVENTS;
+            
+            xv->type           = DeviceValuator;
+            xv->deviceid       = pDevice->id;
+            xv->num_valuators  = axesCount;
+            xv->first_valuator = firstAxis;
+            switch (xv->num_valuators) {
+            case 6: xv->valuator5 = v[5];
+            case 5: xv->valuator4 = v[4];
+            case 4: xv->valuator3 = v[3];
+            case 3: xv->valuator2 = v[2];
+            case 2: xv->valuator1 = v[1];
+            case 1: xv->valuator0 = v[0];
+            }
+            count              = 2;
+    } else {
+        for (i = 0, count = 0; i < axesCount; i += 6) {
+            xev->time          = GetTimeInMillis();
+            xev->type          = DeviceMotionNotify;
+            xev->detail        = 0;
+            xev->deviceid      = pDevice->id | MORE_EVENTS;
+            xev               += 2;
+            
+            xv->type           = DeviceValuator;
+            xv->deviceid       = pDevice->id;
+            xv->num_valuators  = (i+6 >= axesCount ? axesCount - i : 6);
+            xv->first_valuator = firstAxis + i;
+            switch (xv->num_valuators) {
+            case 6: xv->valuator5 = v[i+5];
+            case 5: xv->valuator4 = v[i+4];
+            case 4: xv->valuator3 = v[i+3];
+            case 3: xv->valuator2 = v[i+2];
+            case 2: xv->valuator1 = v[i+1];
+            case 1: xv->valuator0 = v[i+0];
+            }
+            xv                += 2;
+            count             += 2;
+        }
+    }
+
+    if (block)
+        dmxSigioBlock();
+    valuator_mask_set_range(&mask, firstAxis, axesCount, v);
+    GetEventList(&events);
+    nevents = GetPointerEvents(events, pDevice, MotionNotify, 0,
+                               POINTER_ABSOLUTE, &mask);
+    for (i = 0; i < nevents; i++)
+        mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
+
+    if (block)
+        dmxSigioUnblock();
+}
+
+static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
+                                          XEvent *e, DMXBlockType block)
+{
+    int                    type;
+    int                    event   = -1;
+    XDeviceKeyEvent        *ke     = (XDeviceKeyEvent *)e;
+    XDeviceMotionEvent     *me     = (XDeviceMotionEvent *)e;
+    DeviceIntPtr           pDevice = dmxLocal->pDevice;
+    int                    valuators[MAX_VALUATORS];
+    EventListPtr           events;
+    int                    nevents, i;
+    ValuatorMask           mask;
+
+    if (!e)
+        return -1;          /* No extended event passed, cannot handle */
+
+    if ((XID)dmxLocal->deviceId != ke->deviceid) {
+                                /* Search for the correct dmxLocal,
+                                 * since backend and console events are
+                                 * picked up for the first device on
+                                 * that X server. */
+        int i;
+        DMXInputInfo *dmxInput = &dmxInputs[dmxLocal->inputIdx];
+        for (i = 0; i < dmxInput->numDevs; i++) {
+            dmxLocal = dmxInput->devs[i];
+            if ((XID)dmxLocal->deviceId == ke->deviceid)
+                break;
+        }
+    }
+
+    if ((XID)dmxLocal->deviceId != ke->deviceid
+        || (type = dmxMapLookup(dmxLocal, e->type)) < 0)
+        return -1;    /* No mapping, so this event is unhandled */
+
+    switch (type) {
+    case XI_DeviceValuator:          event = DeviceValuator;          break;
+    case XI_DeviceKeyPress:          event = KeyPress;                break;
+    case XI_DeviceKeyRelease:        event = KeyRelease;              break;
+    case XI_DeviceButtonPress:       event = ButtonPress;             break;
+    case XI_DeviceButtonRelease:     event = ButtonRelease;           break;
+    case XI_DeviceMotionNotify:      event = MotionNotify;            break;
+    case XI_DeviceFocusIn:           event = DeviceFocusIn;           break;
+    case XI_DeviceFocusOut:          event = DeviceFocusOut;          break;
+    case XI_ProximityIn:             event = ProximityIn;             break;
+    case XI_ProximityOut:            event = ProximityOut;            break;
+    case XI_DeviceStateNotify:       event = DeviceStateNotify;       break;
+    case XI_DeviceMappingNotify:     event = DeviceMappingNotify;     break;
+    case XI_ChangeDeviceNotify:      event = ChangeDeviceNotify;      break;
+    case XI_DeviceKeystateNotify:    event = DeviceStateNotify;       break;
+    case XI_DeviceButtonstateNotify: event = DeviceStateNotify;       break;
+    }
+
+#define EXTRACT_VALUATORS(ke, valuators) \
+        valuators[0] = ke->axis_data[0]; \
+        valuators[1] = ke->axis_data[1]; \
+        valuators[2] = ke->axis_data[2]; \
+        valuators[3] = ke->axis_data[3]; \
+        valuators[4] = ke->axis_data[4]; \
+        valuators[5] = ke->axis_data[5]; \
+
+    switch (type) {
+    case XI_DeviceKeyPress:
+    case XI_DeviceKeyRelease:
+        EXTRACT_VALUATORS(ke, valuators);
+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
+        if (block)
+            dmxSigioBlock();
+        GetEventList(&events);
+        nevents = GetKeyboardEvents(events, pDevice, event,
+                                    ke->keycode, &mask);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
+
+        if (block)
+            dmxSigioUnblock();
+        break;
+    case XI_DeviceButtonPress:
+    case XI_DeviceButtonRelease:
+        EXTRACT_VALUATORS(ke, valuators);
+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
+        if (block)
+            dmxSigioBlock();
+        GetEventList(&events);
+        nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
+                                   POINTER_ABSOLUTE, &mask);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
+
+        if (block)
+            dmxSigioUnblock();
+        break;
+    case XI_ProximityIn:
+    case XI_ProximityOut:
+        EXTRACT_VALUATORS(ke, valuators);
+        valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
+        if (block)
+            dmxSigioBlock();
+        GetEventList(&events);
+        nevents = GetProximityEvents(events, pDevice, event, &mask);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
+
+        if (block)
+            dmxSigioUnblock();
+        break;
+
+        break;
+
+    case XI_DeviceMotionNotify:
+        dmxExtMotion(dmxLocal, me->axis_data, me->first_axis, me->axes_count,
+                     DMX_ABSOLUTE, block);
+        break;
+    case XI_DeviceFocusIn:
+    case XI_DeviceFocusOut:
+    case XI_DeviceStateNotify:
+    case XI_DeviceMappingNotify:
+    case XI_ChangeDeviceNotify:
+    case XI_DeviceKeystateNotify:
+    case XI_DeviceButtonstateNotify:
+                                /* These are ignored, since DMX will
+                                 * generate its own events of these
+                                 * types, as necessary.
+
+                                 * Perhaps ChangeDeviceNotify should
+                                 * generate an error, because it is
+                                 * unexpected? */
+        break;
+    case XI_DeviceValuator:
+    default:
+        dmxLog(dmxWarning,
+               "XInput extension event (remote=%d -> zero-based=%d)"
+               " not supported yet\n", e->type, type);
+        return -1;
+    }
+    return 0;
+}
+
+static int dmxGetButtonMapping(DMXLocalInputInfoPtr dmxLocal, int button)
+{
+    ButtonClassPtr b = dmxLocal->pDevice->button;
+
+    if (button > b->numButtons) { /* This shouldn't happen. */
+        dmxLog(dmxWarning, "Button %d pressed, but only %d buttons?!?\n",
+               button, b->numButtons);
+        return button;
+    }
+    return b->map[button];
+}
+
+/** Return DMX's notion of the pointer position in the global coordinate
+ * space. */
+void dmxGetGlobalPosition(int *x, int *y)
+{
+    *x = dmxGlobalX;
+    *y = dmxGlobalY;
+}
+
+/** Invalidate the global position for #dmxCoreMotion. */
+void dmxInvalidateGlobalPosition(void)
+{
+    dmxGlobalInvalid = 1;
+}
+
+/** Enqueue a motion event for \a pDev.  The \a v vector has length \a
+ * axesCount, and contains values for each of the axes, starting at \a
+ * firstAxes.
+ *
+ * The \a type of the motion may be \a DMX_RELATIVE, \a DMX_ABSOLUTE, or
+ * \a DMX_ABSOLUTE_CONFINED (in the latter case, the pointer will not be
+ * allowed to move outside the global boundaires).
+ *
+ * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
+ * blocked around calls to \a enqueueMotion(). */
+void dmxMotion(DevicePtr pDev, int *v, int firstAxes, int axesCount,
+               DMXMotionType type, DMXBlockType block)
+{
+    GETDMXLOCALFROMPDEV;
+
+    if (!dmxLocal->sendsCore) {
+        dmxExtMotion(dmxLocal, v, firstAxes, axesCount, type, block);
+        return;
+    }
+    if (axesCount == 2) {
+        switch (type) {
+        case DMX_RELATIVE:
+            dmxCoreMotion(pDev, dmxGlobalX - v[0], dmxGlobalY - v[1], 0, block);
+            break;
+        case DMX_ABSOLUTE:
+            dmxCoreMotion(pDev, v[0], v[1], 0, block);
+            break;
+        case DMX_ABSOLUTE_CONFINED:
+            dmxCoreMotion(pDev, v[0], v[1], -1, block);
+            break;
+        }
+    }
+}
+
+static KeySym dmxKeyCodeToKeySym(DMXLocalInputInfoPtr dmxLocal,
+                                 KeyCode keyCode)
+{
+    KeySym keysym = NoSymbol;
+    int effectiveGroup;
+    XkbSrvInfoPtr xkbi;
+
+    if (!dmxLocal || !dmxLocal->pDevice || !dmxLocal->pDevice->key)
+        goto out;
+
+    xkbi = dmxLocal->pDevice->key->xkbInfo;
+    effectiveGroup = XkbGetEffectiveGroup(xkbi, &xkbi->state, keyCode);
+
+    if (effectiveGroup == -1)
+        goto out;
+
+    keysym = XkbKeySym(xkbi->desc, keyCode, effectiveGroup);
+    DMXDBG2("dmxKeyCodeToKeySym: Translated keyCode=%d to keySym=0x%04x\n",
+            keyCode, keysym);
+
+out:
+    return keysym;
+}
+
+static KeyCode dmxKeySymToKeyCode(DMXLocalInputInfoPtr dmxLocal, KeySym keySym,
+                                  int tryFirst)
+{
+    /* FIXME: this is quite ineffective, converting to a core map first and
+     * then extracting the info from there. It'd be better to run the actual
+     * xkb map */
+    XkbSrvInfoPtr xkbi = dmxLocal->pDevice->key->xkbInfo;
+    KeySymsPtr pKeySyms = XkbGetCoreMap(dmxLocal->pDevice);
+    int        i;
+
+                                /* Optimize for similar maps */
+    if (XkbKeycodeInRange(xkbi->desc, tryFirst)
+        && pKeySyms->map[(tryFirst - xkbi->desc->min_key_code)
+                         * pKeySyms->mapWidth] == keySym)
+        return tryFirst;
+
+    for (i = pKeySyms->minKeyCode; i <= pKeySyms->maxKeyCode; i++) {
+        if (pKeySyms->map[(i - pKeySyms->minKeyCode)
+                          * pKeySyms->mapWidth] == keySym) {
+            DMXDBG3("dmxKeySymToKeyCode: Translated keySym=0x%04x to"
+                    " keyCode=%d (reverses to core keySym=0x%04x)\n",
+                    keySym, i, dmxKeyCodeToKeySym(dmxLocalCoreKeyboard,i));
+            return i;
+        }
+    }
+    return 0;
+}
+
+static int dmxFixup(DevicePtr pDev, int detail, KeySym keySym)
+{
+    GETDMXLOCALFROMPDEV;
+    int keyCode;
+    
+    if (!dmxLocal->pDevice->key) {
+        dmxLog(dmxWarning, "dmxFixup: not a keyboard device (%s)\n",
+               dmxLocal->pDevice->name);
+        return NoSymbol;
+    }
+    if (!keySym)
+        keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
+    if (keySym == NoSymbol)
+        return detail;
+    keyCode = dmxKeySymToKeyCode(dmxLocalCoreKeyboard, keySym, detail);
+
+    return keyCode ? keyCode : detail;
+}
+
+/** Enqueue an event from the \a pDev device with the
+ * specified \a type and \a detail.  If the event is a KeyPress or
+ * KeyRelease event, then the \a keySym is also specified.
+ *
+ * FIXME: make the code do what the comment says, or remove this comment.
+ * If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
+ * blocked around calls to dmxeqEnqueue(). */
+    
+void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
+                XEvent *e, DMXBlockType block)
+{
+    GETDMXINPUTFROMPDEV;
+    xEvent xE;
+    DeviceIntPtr p = dmxLocal->pDevice;
+    int i, nevents, valuators[3];
+    EventListPtr events;
+    ValuatorMask mask;
+
+    DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);
+
+    switch (type) {
+    case KeyPress:
+    case KeyRelease:
+        if (!keySym)
+            keySym = dmxKeyCodeToKeySym(dmxLocal, detail);
+        if (dmxCheckFunctionKeys(dmxLocal, type, keySym))
+            return;
+        if (dmxLocal->sendsCore && dmxLocal != dmxLocalCoreKeyboard)
+            xE.u.u.detail = dmxFixup(pDev, detail, keySym);
+
+        GetEventList(&events);
+        /*ErrorF("KEY %d  sym %d\n", detail, (int) keySym);*/
+        nevents = GetKeyboardEvents(events, p, type, detail, NULL);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
+        return;
+
+    case ButtonPress:
+    case ButtonRelease:
+        detail = dmxGetButtonMapping(dmxLocal, detail);
+        valuator_mask_zero(&mask);
+        GetEventList(&events);
+        nevents = GetPointerEvents(events, p, type, detail,
+                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
+        return;
+
+    case MotionNotify:
+        GetEventList(&events);
+        valuators[0] = e->xmotion.x;
+        valuators[1] = e->xmotion.y;
+        valuators[2] = e->xmotion.state; /* FIXME: WTF?? */
+        valuator_mask_set_range(&mask, 0, 3, valuators);
+        nevents = GetPointerEvents(events, p, type, detail, 
+                                   POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
+        for (i = 0; i < nevents; i++)
+            mieqEnqueue(p, (InternalEvent*)(events + i)->event);
+        return;
+
+    case EnterNotify:
+    case LeaveNotify:
+    case KeymapNotify:
+    case MappingNotify:         /* This is sent because we change the
+                                 * modifier map on the backend/console
+                                 * input device so that we have complete
+                                 * control of the input device LEDs. */
+        return;
+    default:
+        if (type == ProximityIn || type == ProximityOut) {
+            if (dmxLocal->sendsCore)
+                return; /* Not a core event */
+            break;
+        }
+        if (type >= LASTEvent) {
+            if (dmxTranslateAndEnqueueExtEvent(dmxLocal, e, block))
+                dmxLogInput(dmxInput, "Unhandled extension event: %d\n", type);
+        } else {
+            dmxLogInput(dmxInput, "Unhandled event: %d (%s)\n",
+                        type, dmxEventName(type));
+        }
+        return;
+    }
+
+}
+
+/** A pointer to this routine is passed to low-level input drivers so
+ * that all special keychecking is unified to this file.  This function
+ * returns 0 if no special keys have been pressed.  If the user has
+ * requested termination of the DMX server, -1 is returned.  If the user
+ * has requested a switch to a VT, then the (1-based) number of that VT
+ * is returned. */
+int dmxCheckSpecialKeys(DevicePtr pDev, KeySym keySym)
+{
+    GETDMXINPUTFROMPDEV;
+    int            vt    = 0;
+    unsigned short state = 0;
+
+    if (dmxLocal->sendsCore)
+        state = XkbStateFieldFromRec(&dmxLocalCoreKeyboard->pDevice->key->xkbInfo->state);
+    else if (dmxLocal->pDevice->key)
+        state = XkbStateFieldFromRec(&dmxLocal->pDevice->key->xkbInfo->state);
+
+    if (!dmxLocal->sendsCore) return 0; /* Only for core devices */
+
+    DMXDBG2("dmxCheckSpecialKeys: keySym=0x%04x state=0x%04x\n", keySym,state);
+    
+    if ((state & (ControlMask|Mod1Mask)) != (ControlMask|Mod1Mask)) return 0;
+    
+    switch (keySym) {
+    case XK_F1:
+    case XK_F2:
+    case XK_F3:
+    case XK_F4:
+    case XK_F5:
+    case XK_F6:
+    case XK_F7:
+    case XK_F8:
+    case XK_F9:
+    case XK_F10:
+        vt = keySym - XK_F1 + 1;
+        break;
+
+    case XK_F11:
+    case XK_F12:
+        vt = keySym - XK_F11 + 11;
+        break;
+
+    case XK_q:                  /* To avoid confusion  */
+    case XK_BackSpace:
+    case XK_Delete:
+    case XK_KP_Delete:
+        dmxLog(dmxInfo, "User request for termination\n");
+        dispatchException |= DE_TERMINATE;
+        return -1;              /* Terminate */
+    }
+
+    if (vt) {
+        dmxLog(dmxInfo, "Request to switch to VT %d\n", vt);
+        dmxInput->vt_switch_pending = vt;
+        return vt;
+    }
+
+    return 0;                   /* Do nothing */
+}