XFree86 4.3.0.1xf86-4_3_0_1PRE_xf86-4_3_0_1

1 files changed, 1668 insertions, 2328 deletions

diff --git a/Xext/panoramiXprocs.c b/Xext/panoramiXprocs.c
index cd54bdcb3..37b54f4bc 100644
--- a/Xext/panoramiXprocs.c
+++ b/Xext/panoramiXprocs.c
@@ -24,6 +24,10 @@ dealings in this Software without prior written authorization from Digital
 Equipment Corporation.
 ******************************************************************/
 
+/* Massively rewritten by Mark Vojkovich <markv@valinux.com> */
+
+/* $XFree86: xc/programs/Xserver/Xext/panoramiXprocs.c,v 3.33 2002/04/10 21:38:53 mvojkovi Exp $ */
+
 #include <stdio.h>
 #include "X.h"
 #define NEED_REPLIES
@@ -40,757 +44,485 @@ Equipment Corporation.
 #include "misc.h"
 #include "dixstruct.h"
 #include "panoramiX.h"
+#include "panoramiXsrv.h"
+#include "resource.h"
+
+#define XINERAMA_IMAGE_BUFSIZE (256*1024)
+#define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
+                              CWDontPropagate | CWOverrideRedirect | CWCursor )
 
-extern Bool noPanoramiXExtension;
-extern Bool PanoramiXVisibilityNotifySent;
-extern Bool PanoramiXMapped;
-extern int PanoramiXNumScreens;
-extern int PanoramiXPixWidth;
-extern int PanoramiXPixHeight;
-extern PanoramiXWindow *PanoramiXWinRoot;
-extern PanoramiXGC   *PanoramiXGCRoot;
-extern PanoramiXCmap *PanoramiXCmapRoot;
-extern PanoramiXPmap *PanoramiXPmapRoot;
-extern PanoramiXData *panoramiXdataPtr;
-extern PanoramiXCDT   PanoramiXColorDepthTable[MAXSCREENS];
 extern ScreenInfo *GlobalScrInfo;
-extern int (* SavedProcVector[256])();
-extern void (* ReplySwapVector[256])();
-extern WindowPtr *WindowTable;
 extern char *ConnectionInfo;
 extern int connBlockScreenStart;
 
-extern XID clientErrorValue;
-
-extern void Swap32Write();
-
-extern long defaultScreenSaverTime;
-extern long defaultScreenSaverInterval;
-extern int  defaultScreenSaverBlanking;
-extern int  defaultScreenSaverAllowExposures;
-static ClientPtr onlyClient;
-static Bool grabbingClient = FALSE;
-#ifdef __alpha /* THIS NEEDS TO BE LONG !!!! Change driver! */
-int	*checkForInput[2];
-#else
-long	*checkForInput[2];
-#endif
-extern int connBlockScreenStart;
-
-extern int (* InitialVector[3]) ();
-extern int (* ProcVector[256]) ();
-extern int (* SwappedProcVector[256]) ();
+extern int (* SavedProcVector[256]) ();
 extern void (* EventSwapVector[128]) ();
-extern void (* ReplySwapVector[256]) ();
 extern void Swap32Write(), SLHostsExtend(), SQColorsExtend(), 
 WriteSConnectionInfo();
 extern void WriteSConnSetupPrefix();
-extern char *ClientAuthorized();
-extern Bool InsertFakeRequest();
-static void KillAllClients();
-static void DeleteClientFromAnySelections();
-extern void ProcessWorkQueue();
-
-
-static int nextFreeClientID; /* always MIN free client ID */
-
-static int	nClients;	/* number active clients */
-
-char isItTimeToYield;
 
 /* Various of the DIX function interfaces were not designed to allow
  * the client->errorValue to be set on BadValue and other errors.
  * Rather than changing interfaces and breaking untold code we introduce
  * a new global that dispatch can use.
  */
-XID clientErrorValue;   /* XXX this is a kludge */
-
-
-#define SAME_SCREENS(a, b) (\
-    (a.pScreen == b.pScreen))
+extern XID clientErrorValue;   /* XXX this is a kludge */
 
-
-
-extern int Ones();
-
-int PanoramiXCreateWindow(register ClientPtr client)
+int PanoramiXCreateWindow(ClientPtr client)
 {
-    register WindowPtr 	pParent, pWin;
+    PanoramiXRes *parent, *newWin;
+    PanoramiXRes *backPix = NULL;
+    PanoramiXRes *bordPix = NULL;
+    PanoramiXRes *cmap    = NULL;
     REQUEST(xCreateWindowReq);
-    int 		result, j = 0;
-    unsigned 		len;
-    Bool		FoundIt = FALSE;
-    Window 		winID;
-    Window 		parID;
-    PanoramiXWindow 	*localWin;
-    PanoramiXWindow 	*parentWin = PanoramiXWinRoot;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXCmap 	*pPanoramiXCmap = NULL;
-    PanoramiXPmap         *pBackgndPmap = NULL;
-    PanoramiXPmap         *pBorderPmap = NULL;
-    VisualID            orig_visual;
-    XID			orig_wid;
-    int			orig_x, orig_y;
-    register Mask	orig_mask;
-    int 		cmap_offset = 0;
-    int                 pback_offset = 0;
-    int                 pbord_offset = 0;
-    int                 class_index, this_class_index;
-    int                 vid_index, this_vid_index;
+    int pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+    int result = 0, len, j;
+    int orig_x, orig_y;
+    XID orig_visual, tmp;
+    Bool parentIsRoot;
 
     REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
     
     len = client->req_len - (sizeof(xCreateWindowReq) >> 2);
-    IF_RETURN((Ones((Mask)stuff->mask) != len), BadLength);
-    orig_mask = stuff->mask;
-    PANORAMIXFIND_ID(parentWin, stuff->parent);
-    if (parentWin) {
-	localWin = (PanoramiXWindow *)Xcalloc(sizeof(PanoramiXWindow));
-	IF_RETURN(!localWin, BadAlloc);
-    } else {
-	return BadWindow;
-    }
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWBackPixmap)) {
-	XID pmapID;
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+
+    if (!(parent = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+        return BadWindow;
+
+    if(stuff->class == CopyFromParent)
+	stuff->class = parent->u.win.class;
+
+    if((stuff->class == InputOnly) && (stuff->mask & (~INPUTONLY_LEGAL_MASK)))
+        return BadMatch;
 
+    if ((Mask)stuff->mask & CWBackPixmap) {
 	pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));
-	pmapID = *((CARD32 *) &stuff[1] + pback_offset);
-	if (pmapID) {
-	    pBackgndPmap = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pBackgndPmap, pmapID);
+	tmp = *((CARD32 *) &stuff[1] + pback_offset);
+	if ((tmp != None) && (tmp != ParentRelative)) {
+	   if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWBorderPixmap)) {
-	XID pmapID;
-
+    if ((Mask)stuff->mask & CWBorderPixmap) {
 	pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));
-	pmapID = *((CARD32 *) &stuff[1] + pbord_offset);
-	if (pmapID) {
-	    pBorderPmap = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pBorderPmap, pmapID);
+	tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+	if (tmp != CopyFromParent) {
+	   if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWColormap)) {
-	Colormap cmapID;
-
+    if ((Mask)stuff->mask & CWColormap) {
 	cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));
-	cmapID = *((CARD32 *) &stuff[1] + cmap_offset);
-	if (cmapID) {
-	    pPanoramiXCmap = PanoramiXCmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXCmap, cmapID);
+	tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+	if ((tmp != CopyFromParent) && (tmp != None)) {
+	   if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+	      return BadColor;
 	}
     }
+
+    if(!(newWin = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
+
+    newWin->type = XRT_WINDOW;
+    newWin->u.win.visibility = VisibilityNotViewable;
+    newWin->u.win.class = stuff->class;
+    newWin->info[0].id = stuff->wid;
+    for(j = 1; j < PanoramiXNumScreens; j++)
+        newWin->info[j].id = FakeClientID(client->index);
+
+    if (stuff->class == InputOnly)
+	stuff->visual = CopyFromParent;
+    orig_visual = stuff->visual;
     orig_x = stuff->x;
     orig_y = stuff->y;
-    orig_wid = stuff->wid;
-    orig_visual = stuff->visual;
-    for (j = 0; j <= PanoramiXNumScreens - 1; j++) {
-	winID = j ? FakeClientID(client->index) : orig_wid;
-	localWin->info[j].id = winID;
-    }
-    localWin->FreeMe = FALSE;
-    localWin->visibility = VisibilityNotViewable;
-    localWin->VisibilitySent = FALSE;
-    PANORAMIXFIND_LAST(pPanoramiXWin, PanoramiXWinRoot);
-    pPanoramiXWin->next = localWin;
-    if ( (stuff->visual != CopyFromParent) && (stuff->depth != 0))
-      {
-       /* Find the correct visual for this screen */
-	for (class_index = 0; class_index < PanoramiXColorDepthTable[0].numVisuals; 
-class_index++)
-	  {
-	    for (vid_index = 0; vid_index < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[stuff->depth].numVids; vid_index++)
-	      {
-		if ( stuff->visual == PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[stuff->depth].vid[vid_index] )
-		{
-		  this_class_index = class_index;
-		  this_vid_index   = vid_index;
-	          FoundIt = TRUE;
-		  break;
-		}
-	       }
-	   }
-      }
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	if (parentWin == PanoramiXWinRoot) {
+    parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id);
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->wid = newWin->info[j].id;
+        stuff->parent = parent->info[j].id;
+	if (parentIsRoot) {
 	    stuff->x = orig_x - panoramiXdataPtr[j].x;
 	    stuff->y = orig_y - panoramiXdataPtr[j].y;
 	}
-	stuff->wid = localWin->info[j].id;
-	parID = (XID)(parentWin->info[j].id);
-	pParent = (WindowPtr)SecurityLookupWindow(parID, client,SecurityReadAccess);
-	IF_RETURN((!pParent),BadWindow);
-	stuff->parent = parID;
-	if ( (orig_visual != CopyFromParent) && (stuff->depth != 0) && FoundIt ) 
-	  {
-	    stuff->visual = PanoramiXColorDepthTable[j].panoramiXScreenMap[this_class_index].vmap[stuff->depth].vid[this_vid_index];
-	  }
-	if (pBackgndPmap)
-	    *((CARD32 *) &stuff[1] + pback_offset) = pBackgndPmap->info[j].id;
-	if (pBorderPmap)
-	    *((CARD32 *) &stuff[1] + pbord_offset) = pBorderPmap->info[j].id;
-	if (pPanoramiXCmap)
-	    *((CARD32 *) &stuff[1] + cmap_offset) = pPanoramiXCmap->info[j].id;
-	stuff->mask = orig_mask;
-	result = (*SavedProcVector[X_CreateWindow])(client);
-	BREAK_IF(result != Success); 
-    }
-    if (result != Success) {
-       pPanoramiXWin->next = NULL;
-       if (localWin)
-           Xfree(localWin);
-    }
+	if (backPix)
+	    *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[j].id;
+	if (bordPix)
+	    *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[j].id;
+	if (cmap)
+	    *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[j].id;
+	if ( orig_visual != CopyFromParent ) 
+	    stuff->visual = PanoramiXVisualTable[(orig_visual*MAXSCREENS) + j];
+        result = (*SavedProcVector[X_CreateWindow])(client);
+        if(result != Success) break;
+    }
+
+    if (result == Success)
+        AddResource(newWin->info[0].id, XRT_WINDOW, newWin);
+    else 
+        xfree(newWin);
+
     return (result);
 }
 
 
-
-int PanoramiXChangeWindowAttributes(register ClientPtr client)
+int PanoramiXChangeWindowAttributes(ClientPtr client)
 {
-    register WindowPtr 	pWin;
+    PanoramiXRes *win;
+    PanoramiXRes *backPix = NULL;
+    PanoramiXRes *bordPix = NULL;
+    PanoramiXRes *cmap    = NULL;
     REQUEST(xChangeWindowAttributesReq);
-    register int  	result;
-    int 	  	len;
-    int 	  	j;
-    Window 	  	winID;
-    Mask		orig_valueMask;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXWindow   	*pPanoramiXWinback = NULL;
-    PanoramiXCmap 	*pPanoramiXCmap = NULL;
-    PanoramiXPmap	*pBackgndPmap = NULL;
-    PanoramiXPmap	*pBorderPmap = NULL;
-    int			cmap_offset = 0;
-    int 		pback_offset = 0;
-    int			pbord_offset = 0;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
+    int pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+    int result = 0, len, j;
+    XID tmp;
 
     REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
+    
     len = client->req_len - (sizeof(xChangeWindowAttributesReq) >> 2);
-    IF_RETURN((len != Ones((Mask) stuff->valueMask)), BadLength);
-    orig_valueMask = stuff->valueMask;
-    winID = stuff->window;
-    for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->window);
-						pPanoramiXWin = pPanoramiXWin->next)
-	pPanoramiXWinback = pPanoramiXWin;
-    pPanoramiXWin = PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, winID);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWBackPixmap)) {
-	XID pmapID;
+    if (Ones(stuff->valueMask) != len)
+        return BadLength;
 
+    if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+        return BadWindow;
+
+    if((win->u.win.class == InputOnly) && 
+       (stuff->valueMask & (~INPUTONLY_LEGAL_MASK)))
+        return BadMatch;
+
+    if ((Mask)stuff->valueMask & CWBackPixmap) {
 	pback_offset = Ones((Mask)stuff->valueMask & (CWBackPixmap - 1));
-	pmapID = *((CARD32 *) &stuff[1] + pback_offset);
-	if (pmapID) {
-	    pBackgndPmap = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pBackgndPmap, pmapID);
+	tmp = *((CARD32 *) &stuff[1] + pback_offset);
+	if ((tmp != None) && (tmp != ParentRelative)) {
+	   if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWBorderPixmap)) {
-	XID pmapID;
-
+    if ((Mask)stuff->valueMask & CWBorderPixmap) {
 	pbord_offset = Ones((Mask)stuff->valueMask & (CWBorderPixmap - 1));
-	pmapID = *((CARD32 *) &stuff[1] + pbord_offset);
-	if (pmapID) {
-	    pBorderPmap = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pBorderPmap, pmapID);
+	tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+	if (tmp != CopyFromParent) {
+	   if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWColormap )) {
-	Colormap cmapID;
-
+    if ((Mask)stuff->valueMask & CWColormap) {
 	cmap_offset = Ones((Mask)stuff->valueMask & (CWColormap - 1));
-	cmapID = *((CARD32 *) &stuff[1] + cmap_offset);
-	if (cmapID) {
-	    pPanoramiXCmap = PanoramiXCmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXCmap, cmapID);
+	tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+	if ((tmp != CopyFromParent) && (tmp != None)) {
+	   if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+	      return BadColor;
 	}
     }
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->window = pPanoramiXWin->info[j].id;
-	stuff->valueMask = orig_valueMask;  
-	if (pBackgndPmap)
-	    *((CARD32 *) &stuff[1] + pback_offset) = pBackgndPmap->info[j].id;
-	if (pBorderPmap)
-	    *((CARD32 *) &stuff[1] + pbord_offset) = pBorderPmap->info[j].id;
-	if (pPanoramiXCmap)
-	    *((CARD32 *) &stuff[1] + cmap_offset) = pPanoramiXCmap->info[j].id;
-	result = (*SavedProcVector[X_ChangeWindowAttributes])(client);
-        BREAK_IF(result != Success);
-    }
-    if ((result == Success) && pPanoramiXWinback && 
-	        pPanoramiXWin && pPanoramiXWin->FreeMe) {
-	pPanoramiXWinback->next = pPanoramiXWin->next;
-	Xfree(pPanoramiXWin);
-    } 
+
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->window = win->info[j].id;
+	if (backPix)
+	    *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[j].id;
+	if (bordPix)
+	    *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[j].id;
+	if (cmap)
+	    *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[j].id;
+        result = (*SavedProcVector[X_ChangeWindowAttributes])(client);
+    }
+
     return (result);
 }
 
 
 int PanoramiXDestroyWindow(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int         	j, result;
-    PanoramiXWindow   	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXWindow   	*pPanoramiXWinback = NULL;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->id);
-						pPanoramiXWin = pPanoramiXWin->next)
-	pPanoramiXWinback = pPanoramiXWin;
-    IF_RETURN(!pPanoramiXWin,BadWindow);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->id = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_DestroyWindow])(client);
-        BREAK_IF(result != Success);
-    }
-    if ((result == Success) && pPanoramiXWinback && 
-	        pPanoramiXWin && pPanoramiXWin->FreeMe) {
-	pPanoramiXWinback->next = pPanoramiXWin->next;
-	Xfree(pPanoramiXWin);
-    } 
-    PANORAMIX_FREE(client);
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->id = win->info[j].id;
+	result = (*SavedProcVector[X_DestroyWindow])(client);
+        if(result != Success) break;
+    }
+
+    /* Since ProcDestroyWindow is using FreeResource, it will free
+	our resource for us on the last pass through the loop above */
+ 
     return (result);
 }
 
 
 int PanoramiXDestroySubwindows(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int         	j,result;
-    PanoramiXWindow   	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXWindow   	*pPanoramiXWinback = NULL;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->id);
-						pPanoramiXWin = pPanoramiXWin->next)
-	pPanoramiXWinback = pPanoramiXWin;
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->id = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_DestroySubwindows])(client);
-    }
-    if ((result == Success) && pPanoramiXWinback && 
-	        pPanoramiXWin && pPanoramiXWin->FreeMe) {
-	pPanoramiXWinback->next = pPanoramiXWin->next;
-	Xfree(pPanoramiXWin);
-    }
-    PANORAMIX_FREE(client);
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->id = win->info[j].id;
+	result = (*SavedProcVector[X_DestroySubwindows])(client);
+        if(result != Success) break;
+    }
+
+    /* DestroySubwindows is using FreeResource which will free
+	our resources for us on the last pass through the loop above */
+
     return (result);
 }
 
 
 int PanoramiXChangeSaveSet(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xChangeSaveSetReq);
-    int         	j, result;
-    PanoramiXWindow   	*pPanoramiXWin = PanoramiXWinRoot;
 
     REQUEST_SIZE_MATCH(xChangeSaveSetReq);
-    if (!stuff->window) 
-	result = (* SavedProcVector[X_ChangeSaveSet])(client);
-    else {
-      PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-      IF_RETURN(!pPanoramiXWin, BadWindow);
-      FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->window = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_ChangeSaveSet])(client);
-      }
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->window = win->info[j].id;
+	result = (*SavedProcVector[X_ChangeSaveSet])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
-int PanoramiXReparentWindow(register ClientPtr client)
+int PanoramiXReparentWindow(ClientPtr client)
 {
-    register WindowPtr 	pWin, pParent;
+    PanoramiXRes *win, *parent;
+    int         result = 0, j;
+    int		x, y;
+    Bool	parentIsRoot;
     REQUEST(xReparentWindowReq);
-    register int 	result;
-    int 		j;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXWindow 	*pPanoramiXPar = PanoramiXWinRoot;
 
     REQUEST_SIZE_MATCH(xReparentWindowReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    PANORAMIXFIND_ID(pPanoramiXPar, stuff->parent);
-    IF_RETURN(!pPanoramiXPar, BadWindow);
-    FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXPar), j) {
-	stuff->window = pPanoramiXWin->info[j].id;
-	stuff->parent = pPanoramiXPar->info[j].id;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+	return BadWindow;
+
+    if(!(parent = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+	return BadWindow;
+
+    x = stuff->x;
+    y = stuff->y;
+    parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id);
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->window = win->info[j].id;
+	stuff->parent = parent->info[j].id;
+	if(parentIsRoot) {
+	    stuff->x = x - panoramiXdataPtr[j].x;
+	    stuff->y = y - panoramiXdataPtr[j].y;
+	}
 	result = (*SavedProcVector[X_ReparentWindow])(client);
-	BREAK_IF(result != Success);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
-int PanoramiXMapWindow(register ClientPtr client)
+int PanoramiXMapWindow(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int 		j,result;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    register WindowPtr  pWin, pChild;
-    Window		winID;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    /* initialize visibility */
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client, 
-SecurityReadAccess);
-    IF_RETURN(!pWin, BadWindow);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
-      if (pPanoramiXWin)
-	  pPanoramiXWin->VisibilitySent = FALSE;
-    }
-    pPanoramiXWin = PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    PanoramiXMapped = TRUE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
-    {
-	 winID = pPanoramiXWin->info[j].id;
-         pWin = (WindowPtr) SecurityLookupWindow(winID, 
-client,SecurityReadAccess);
-	 IF_RETURN((!pWin), BadWindow);
-	 stuff->id = winID;
-	 result = (*SavedProcVector[X_MapWindow])(client);
-    }
-    /* clean up */
-    PanoramiXMapped = FALSE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->id = win->info[j].id;
+	result = (*SavedProcVector[X_MapWindow])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
-int PanoramiXMapSubwindows(register ClientPtr client)
+int PanoramiXMapSubwindows(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int 		j,result;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    register WindowPtr  pWin, pChild;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    /* initialize visibility values */
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    IF_RETURN(!pWin, BadWindow);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-
-    pPanoramiXWin = PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    PanoramiXMapped = TRUE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
-    {
-	stuff->id = pPanoramiXWin->info[j].id;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->id = win->info[j].id;
 	result = (*SavedProcVector[X_MapSubwindows])(client);
+        if(result != Success) break;
     }
-    /* clean up */
-    PanoramiXMapped = FALSE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-    PANORAMIX_FREE(client);
+
     return (result);
 }
 
 
-int PanoramiXUnmapWindow(register ClientPtr client)
+int PanoramiXUnmapWindow(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int 		j, result;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    register WindowPtr  pWin, pChild;
-   
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    /* initialize visibility values */
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    IF_RETURN(!pWin, BadWindow);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    PanoramiXMapped = TRUE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
-    {
-	 stuff->id = pPanoramiXWin->info[j].id;
-	 result = (*SavedProcVector[X_UnmapWindow])(client);
-    }
-
-    /* clean up */
-    PanoramiXMapped = FALSE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-    PANORAMIX_FREE(client);
-    return (client->noClientException);
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->id = win->info[j].id;
+	result = (*SavedProcVector[X_UnmapWindow])(client);
+        if(result != Success) break;
+    }
+
+    return (result);
 }
 
 
-int PanoramiXUnmapSubwindows(register ClientPtr client)
+int PanoramiXUnmapSubwindows(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int 		j, result;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    register WindowPtr  pWin, pChild;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    /* initialize visibility values */
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    IF_RETURN(!pWin, BadWindow);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    PanoramiXMapped = TRUE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
-    {
-	stuff->id = pPanoramiXWin->info[j].id;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->id = win->info[j].id;
 	result = (*SavedProcVector[X_UnmapSubwindows])(client);
+        if(result != Success) break;
     }
 
-    /* clean up */
-    PanoramiXMapped = FALSE;
-    PanoramiXVisibilityNotifySent = FALSE;
-    pPanoramiXWin->VisibilitySent = FALSE;
-    pWin = (WindowPtr) SecurityLookupWindow(stuff->id, 
-client,SecurityReadAccess);
-    for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
-      pPanoramiXWin = PanoramiXWinRoot;
-      PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
-      if (pPanoramiXWin)
-	pPanoramiXWin->VisibilitySent = FALSE;
-    }
-    PANORAMIX_FREE(client);
-    return (client->noClientException);
+    return (result);
 }
 
 
-int PanoramiXConfigureWindow(register ClientPtr client)
+int PanoramiXConfigureWindow(ClientPtr client)
 {
-    register WindowPtr	pWin;
+    PanoramiXRes *win;
+    PanoramiXRes *sib = NULL;
+    WindowPtr   pWin;
+    int         result = 0, j, len, sib_offset = 0, x = 0, y = 0;
+    int		x_offset = -1;
+    int		y_offset = -1;
     REQUEST(xConfigureWindowReq);
-    register int 	result;
-    unsigned 		len, i, things;
-    XID 		changes[32];
-    register Mask	orig_mask;
-    int 		j, sib_position;
-    Window 		winID;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXWindow	*pPanoramiXSib = NULL;
-    int 		x_off = 0, y_off = 0;
-    XID 		*pStuff;
-    XID 		*origStuff, *modStuff;
-    Mask 		local_mask;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
+
     len = client->req_len - (sizeof(xConfigureWindowReq) >> 2);
-    things = Ones((Mask)stuff->mask);
-    IF_RETURN((things != len), BadLength);
-    orig_mask = stuff->mask;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    if (!pPanoramiXWin) {
-	client->errorValue = stuff->window;
-	return (BadWindow);
-    }
-    if (things > 0) {
-        pStuff = (XID *) ALLOCATE_LOCAL(things * sizeof(XID));
-        memcpy((char *) pStuff, (char *) &stuff[1], things * sizeof(XID));
-        local_mask = (CWSibling | CWX | CWY) & ((Mask) stuff->mask);
-        if (local_mask & CWSibling) {
-       	   sib_position = Ones((Mask) stuff->mask & (CWSibling - 1));
-    	   pPanoramiXSib = PanoramiXWinRoot;
-	   PANORAMIXFIND_ID(pPanoramiXSib, *(pStuff + sib_position));
-        }
-        FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	    winID = pPanoramiXWin->info[j].id;
-	    pWin = (WindowPtr)SecurityLookupWindow(winID, client,SecurityReadAccess);
-	    if (!pWin) {
-		client->errorValue = pPanoramiXWin->info[0].id;
-		return (BadWindow);
-	    }
-	    stuff->window = winID;
-	    if (pWin->parent 
-		&& (pWin->parent->drawable.id == PanoramiXWinRoot->info[j].id)) {
-	        x_off = panoramiXdataPtr[j].x;
-	        y_off = panoramiXdataPtr[j].y;
-	    }
-	    modStuff = (XID *) &stuff[1];
-	    origStuff = pStuff;
-	    i = things;
-	    if (local_mask & CWX) {
-	        *modStuff++ = *origStuff++ - x_off;
-	        i--;
-	    }
-	    if (local_mask & CWY) {
-	       *modStuff++ = *origStuff++ - y_off;
-	       i--;
-	    }
-	    for ( ; i; i--) 
-	       *modStuff++ = *origStuff++;
-	    if (pPanoramiXSib)
-	       *((XID *) &stuff[1] + sib_position) = pPanoramiXSib->info[j].id;
-	    stuff->mask = orig_mask;
-	    result = (*SavedProcVector[X_ConfigureWindow])(client);
-        }
-    DEALLOCATE_LOCAL(pStuff);
-    PANORAMIX_FREE(client);
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+
+    /* because we need the parent */
+    if (!(pWin = (WindowPtr)SecurityLookupIDByType(
+		client, stuff->window, RT_WINDOW, SecurityWriteAccess)))
+        return BadWindow;
+
+    if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+        return BadWindow;
+
+    if ((Mask)stuff->mask & CWSibling) {
+	XID tmp;
+	sib_offset = Ones((Mask)stuff->mask & (CWSibling - 1));
+	if ((tmp = *((CARD32 *) &stuff[1] + sib_offset))) {
+	   if(!(sib = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_WINDOW, SecurityReadAccess)))
+	      return BadWindow;
+	}
+    }
+
+    if(pWin->parent && (pWin->parent == WindowTable[0])) {
+	if ((Mask)stuff->mask & CWX) {
+	    x_offset = 0;
+	    x = *((CARD32 *)&stuff[1]);
+	}
+	if ((Mask)stuff->mask & CWY) {
+	    y_offset = (x_offset == -1) ? 0 : 1;
+	    y = *((CARD32 *) &stuff[1] + y_offset);
+	}
+    }
+
+    /* have to go forward or you get expose events before 
+	ConfigureNotify events */
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->window = win->info[j].id;
+	if(sib)
+	    *((CARD32 *) &stuff[1] + sib_offset) = sib->info[j].id;
+	if(x_offset >= 0)
+	    *((CARD32 *) &stuff[1] + x_offset) = x - panoramiXdataPtr[j].x;
+	if(y_offset >= 0)
+	    *((CARD32 *) &stuff[1] + y_offset) = y - panoramiXdataPtr[j].y;
+	result = (*SavedProcVector[X_ConfigureWindow])(client);
+        if(result != Success) break;
+    }
+
     return (result);
-    } else
-	return (client->noClientException);
 }
 
 
-int PanoramiXCirculateWindow(register ClientPtr client)
+int PanoramiXCirculateWindow(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j;
     REQUEST(xCirculateWindowReq);
-    int 	  j,result;
-    PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xCirculateWindowReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->window = pPanoramiXWin->info[j].id;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+	return BadWindow;
+
+    FOR_NSCREENS_FORWARD(j) {
+	stuff->window = win->info[j].id;
 	result = (*SavedProcVector[X_CirculateWindow])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
-int PanoramiXGetGeometry(register ClientPtr client)
+int PanoramiXGetGeometry(ClientPtr client)
 {
     xGetGeometryReply 	 rep;
-    register DrawablePtr pDraw;
+    DrawablePtr pDraw;
     REQUEST(xResourceReq);
 
     REQUEST_SIZE_MATCH(xResourceReq);
@@ -798,1883 +530,1489 @@ int PanoramiXGetGeometry(register ClientPtr client)
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
-    rep.root = WindowTable[pDraw->pScreen->myNum]->drawable.id;
+    rep.root = WindowTable[0]->drawable.id;
     rep.depth = pDraw->depth;
+    rep.width = pDraw->width;
+    rep.height = pDraw->height;
+    rep.x = rep.y = rep.borderWidth = 0;
 
-    if (stuff->id == PanoramiXWinRoot->info[0].id) {
-	xConnSetup *setup = (xConnSetup *) ConnectionInfo;
+    if (stuff->id == rep.root) {
 	xWindowRoot *root  = (xWindowRoot *)
 				    (ConnectionInfo + connBlockScreenStart);
 
 	rep.width = root->pixWidth;
 	rep.height = root->pixHeight;
-    } else {
-	rep.width = pDraw->width;
-	rep.height = pDraw->height;
-    }
-
-    /* XXX - Because the pixmap-implementation of the multibuffer extension 
-     *       may have the buffer-id's drawable resource value be a pointer
-     *       to the buffer's window instead of the buffer itself
-     *       (this happens if the buffer is the displayed buffer),
-     *       we also have to check that the id matches before we can
-     *       truly say that it is a DRAWABLE_WINDOW.
-     */
-
-    if ((pDraw->type == UNDRAWABLE_WINDOW) ||
-        ((pDraw->type == DRAWABLE_WINDOW) && (stuff->id == pDraw->id))) {
-        register WindowPtr pWin = (WindowPtr)pDraw;
+    } else 
+    if ((pDraw->type == UNDRAWABLE_WINDOW) || (pDraw->type == DRAWABLE_WINDOW))
+    {
+        WindowPtr pWin = (WindowPtr)pDraw;
 	rep.x = pWin->origin.x - wBorderWidth (pWin);
 	rep.y = pWin->origin.y - wBorderWidth (pWin);
+	if(pWin->parent == WindowTable[0]) {
+	   rep.x += panoramiXdataPtr[0].x;
+	   rep.y += panoramiXdataPtr[0].y;
+	}
 	rep.borderWidth = pWin->borderWidth;
-    } else { 			/* DRAWABLE_PIXMAP or DRAWABLE_BUFFER */
-	rep.x = rep.y = rep.borderWidth = 0;
     }
+
     WriteReplyToClient(client, sizeof(xGetGeometryReply), &rep);
     return (client->noClientException);
 }
 
+int PanoramiXTranslateCoords(ClientPtr client)
+{
+    INT16 x, y;
+    REQUEST(xTranslateCoordsReq);
 
-int PanoramiXChangeProperty(ClientPtr client)
-{	      
-    int  	  result, j;
-    PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-    REQUEST(xChangePropertyReq);
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
-
-    REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->window = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_ChangeProperty])(client);
-	if (result != Success) {
-	    stuff->window = pPanoramiXWin->info[0].id;
-	    break;
-        }
-    }
-    return (result);
-}
-
-
-int PanoramiXDeleteProperty(ClientPtr client)
-{	      
-    int  	  result, j;
-    PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-    REQUEST(xDeletePropertyReq);
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
-
-    REQUEST_SIZE_MATCH(xDeletePropertyReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->window = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_DeleteProperty])(client);
-	BREAK_IF(result != Success);
-    }
-    PANORAMIX_FREE(client);
-    return (result);
-}
+    register WindowPtr pWin, pDst;
+    xTranslateCoordsReply rep;
 
+    REQUEST_SIZE_MATCH(xTranslateCoordsReq);
+    pWin = (WindowPtr)SecurityLookupWindow(stuff->srcWid, client,
+					   SecurityReadAccess);
+    if (!pWin)
+        return(BadWindow);
+    pDst = (WindowPtr)SecurityLookupWindow(stuff->dstWid, client,
+					   SecurityReadAccess);
+    if (!pDst)
+        return(BadWindow);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.sameScreen = xTrue;
+    rep.child = None;
 
-int PanoramiXSendEvent(ClientPtr client)
-{	      
-    int  	  result, j; 
-    BYTE	  orig_type;
-    Mask	  orig_eventMask;
-    PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-    REQUEST(xSendEventReq);
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
-
-    REQUEST_SIZE_MATCH(xSendEventReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->destination);
-    orig_type = stuff->event.u.u.type;
-    orig_eventMask = stuff->eventMask;
-    if (!pPanoramiXWin) {
-	noPanoramiXExtension = TRUE;
-	result = (* SavedProcVector[X_SendEvent])(client);
-	noPanoramiXExtension = FALSE;
+    if(pWin == WindowTable[0]) {
+	x = stuff->srcX - panoramiXdataPtr[0].x;
+	y = stuff->srcY - panoramiXdataPtr[0].y;
+    } else {
+	x = pWin->drawable.x + stuff->srcX;
+	y = pWin->drawable.y + stuff->srcY;
     }
-    else {
-       noPanoramiXExtension = FALSE;
-       FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	 stuff->destination = pPanoramiXWin->info[j].id;
-	 stuff->eventMask = orig_eventMask;
-	 stuff->event.u.u.type = orig_type;
-	 if (!j) 
-	     noPanoramiXExtension = TRUE;
-	 result = (* SavedProcVector[X_SendEvent])(client);
-	 noPanoramiXExtension = FALSE;
-       }
+    pWin = pDst->firstChild;
+    while (pWin) {
+#ifdef SHAPE
+	    BoxRec  box;
+#endif
+	    if ((pWin->mapped) &&
+		(x >= pWin->drawable.x - wBorderWidth (pWin)) &&
+		(x < pWin->drawable.x + (int)pWin->drawable.width +
+		 wBorderWidth (pWin)) &&
+		(y >= pWin->drawable.y - wBorderWidth (pWin)) &&
+		(y < pWin->drawable.y + (int)pWin->drawable.height +
+		 wBorderWidth (pWin))
+#ifdef SHAPE
+		/* When a window is shaped, a further check
+		 * is made to see if the point is inside
+		 * borderSize
+		 */
+		&& (!wBoundingShape(pWin) ||
+		    POINT_IN_REGION(pWin->drawable.pScreen, 
+					wBoundingShape(pWin), 
+					x - pWin->drawable.x, 
+					y - pWin->drawable.y, &box))
+#endif
+		)
+            {
+		rep.child = pWin->drawable.id;
+		pWin = (WindowPtr) NULL;
+	    }
+	    else
+		pWin = pWin->nextSib;
+    }
+    rep.dstX = x - pDst->drawable.x;
+    rep.dstY = y - pDst->drawable.y;
+    if(pDst == WindowTable[0]) {
+	rep.dstX += panoramiXdataPtr[0].x;
+	rep.dstY += panoramiXdataPtr[0].y;
     }
-    return (result);
-}
 
+    WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep);
+    return(client->noClientException);
+}
 
-int PanoramiXCreatePixmap(register ClientPtr client)
+int PanoramiXCreatePixmap(ClientPtr client)
 {
-    PixmapPtr 		 pMap;
-    register DrawablePtr pDraw;
+    PanoramiXRes *refDraw, *newPix;
+    int result = 0, j;
     REQUEST(xCreatePixmapReq);
-     DepthPtr 		 pDepth;
-    int 		 result, j;
-    Pixmap 		 pmapID;
-    PanoramiXWindow 	 *pPanoramiXWin;
-    PanoramiXPmap 	 *pPanoramiXPmap;
-    PanoramiXPmap	 *localPmap;
-    XID			 orig_pid;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xCreatePixmapReq);
     client->errorValue = stuff->pid;
 
-    localPmap =(PanoramiXPmap *) Xcalloc(sizeof(PanoramiXPmap));
-    IF_RETURN(!localPmap, BadAlloc);
-
-    pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE, 
-						  SecurityReadAccess);
-    IF_RETURN(!pDraw, BadDrawable);
-
-    pPanoramiXWin = (pDraw->type == DRAWABLE_PIXMAP)
-					    ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-
-    orig_pid = stuff->pid;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXPmap, j) {
-	pmapID = j ? FakeClientID(client->index) : orig_pid;
-	localPmap->info[j].id = pmapID;
-    }
-    localPmap->FreeMe = FALSE;
-    PANORAMIXFIND_LAST(pPanoramiXPmap, PanoramiXPmapRoot);
-    pPanoramiXPmap->next = localPmap;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->pid = localPmap->info[j].id;
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	result = (* SavedProcVector[X_CreatePixmap])(client);
-	BREAK_IF(result != Success);
-    }
-    if (result != Success) {
-	pPanoramiXPmap->next = NULL;
-	if (localPmap)
-	    Xfree(localPmap);
+    if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+	return BadDrawable;
+
+    if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+	return BadAlloc;
+
+    newPix->type = XRT_PIXMAP;
+    newPix->u.pix.shared = FALSE;
+    newPix->info[0].id = stuff->pid;
+    for(j = 1; j < PanoramiXNumScreens; j++)
+	newPix->info[j].id = FakeClientID(client->index);
+   
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->pid = newPix->info[j].id;
+	stuff->drawable = refDraw->info[j].id;
+	result = (*SavedProcVector[X_CreatePixmap])(client);
+	if(result != Success) break;
     }
+
+    if (result == Success)
+	AddResource(newPix->info[0].id, XRT_PIXMAP, newPix);
+    else 
+	xfree(newPix);
+
     return (result);
 }
 
 
 int PanoramiXFreePixmap(ClientPtr client)
 {
-    PixmapPtr 	pMap;
-    int         result, j;
-    PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
-    PanoramiXPmap *pPanoramiXPmapback = NULL;
+    PanoramiXRes *pix;
+    int         result = 0, j;
     REQUEST(xResourceReq);
 
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
-
     REQUEST_SIZE_MATCH(xResourceReq);
-    for (; pPanoramiXPmap && (pPanoramiXPmap->info[0].id != stuff->id);
-					    pPanoramiXPmap = pPanoramiXPmap->next)
-	pPanoramiXPmapback = pPanoramiXPmap;
-    if (!pPanoramiXPmap)
-	result = (* SavedProcVector[X_FreePixmap])(client);
-    else {
-        FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	    stuff->id = pPanoramiXPmap->info[j].id;
-	    result = (* SavedProcVector[X_FreePixmap])(client);
-        }
-        if ((result == Success) && pPanoramiXPmapback &&
-		 pPanoramiXPmap && pPanoramiXPmap->FreeMe ) {
-    	    pPanoramiXPmapback->next = pPanoramiXPmap->next;
-	    Xfree(pPanoramiXPmap);
-        }
+
+    client->errorValue = stuff->id;
+
+    if(!(pix = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_PIXMAP, SecurityDestroyAccess)))
+	return BadPixmap;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->id = pix->info[j].id;
+	result = (*SavedProcVector[X_FreePixmap])(client);
+	if(result != Success) break;
     }
+
+    /* Since ProcFreePixmap is using FreeResource, it will free
+	our resource for us on the last pass through the loop above */
+ 
     return (result);
 }
 
 
-int PanoramiXCreateGC(register ClientPtr client)
+int PanoramiXCreateGC(ClientPtr client)
 {
-    int 	       result, j;
-    GC 		      *pGC;
-    DrawablePtr        pDraw;
-    unsigned 	       len, i;
+    PanoramiXRes *refDraw;
+    PanoramiXRes *newGC;
+    PanoramiXRes *stip = NULL;
+    PanoramiXRes *tile = NULL;
+    PanoramiXRes *clip = NULL;
     REQUEST(xCreateGCReq);
-    GContext 	       GCID;
-    PanoramiXWindow   *pPanoramiXWin;
-    PanoramiXGC	      *localGC;
-    PanoramiXGC       *pPanoramiXGC;
-    PanoramiXPmap     *pPanoramiXTile = NULL, *pPanoramiXStip = NULL;
-    PanoramiXPmap     *pPanoramiXClip = NULL;
-    int		       tile_offset, stip_offset, clip_offset;
-    XID		       orig_GC;
+    int tile_offset = 0, stip_offset = 0, clip_offset = 0;
+    int result = 0, len, j;
+    XID tmp;
 
     REQUEST_AT_LEAST_SIZE(xCreateGCReq);
+    
     client->errorValue = stuff->gc;
-    pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						  SecurityReadAccess);
-    IF_RETURN(!pDraw, BadDrawable);
-    pPanoramiXWin = (pDraw->type == DRAWABLE_PIXMAP)
-					    ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-
-    len = client->req_len -  (sizeof(xCreateGCReq) >> 2);
-    IF_RETURN((len != Ones((Mask)stuff->mask)), BadLength);
-    localGC = (PanoramiXGC *) Xcalloc(sizeof(PanoramiXGC));
-    IF_RETURN(!localGC, BadAlloc);
-    orig_GC = stuff->gc;
-    if ((Mask)stuff->mask & GCTile) {
-	XID tileID;
+    len = client->req_len - (sizeof(xCreateGCReq) >> 2);
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+
+    if (!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+        return BadDrawable;
 
+    if ((Mask)stuff->mask & GCTile) {
 	tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
-	tileID = *((CARD32 *) &stuff[1] + tile_offset);
-	if (tileID) {
-	    pPanoramiXTile = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXTile, tileID);
+	if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
+	   if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
     if ((Mask)stuff->mask & GCStipple) {
-	XID stipID;
-
 	stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
-	stipID = *((CARD32 *) &stuff[1] + stip_offset);
-	if (stipID) {
-	    pPanoramiXStip = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXStip, stipID);
+	if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
+	   if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
     if ((Mask)stuff->mask & GCClipMask) {
-	XID clipID;
-
 	clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
-	clipID = *((CARD32 *) &stuff[1] + clip_offset);
-	if (clipID) {
-	    pPanoramiXClip = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXClip, clipID);
+	if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
+	   if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
-	GCID = j ? FakeClientID(client->index) : orig_GC;
-	localGC->info[j].id = GCID;
-    }
-    localGC->FreeMe = FALSE;
-    PANORAMIXFIND_LAST(pPanoramiXGC, PanoramiXGCRoot);
-    pPanoramiXGC->next = localGC;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->gc = localGC->info[j].id;
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	if (pPanoramiXTile)
-	    *((CARD32 *) &stuff[1] + tile_offset) = pPanoramiXTile->info[j].id;
-	if (pPanoramiXStip)
-	    *((CARD32 *) &stuff[1] + stip_offset) = pPanoramiXStip->info[j].id;
-	if (pPanoramiXClip)
-	    *((CARD32 *) &stuff[1] + clip_offset) = pPanoramiXClip->info[j].id;
-	result = (* SavedProcVector[X_CreateGC])(client);
-	BREAK_IF(result != Success);
-    }
-    if (result != Success) {
-       pPanoramiXGC->next = NULL;
-       Xfree(localGC);
+
+    if(!(newGC = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
+
+    newGC->type = XRT_GC;
+    newGC->info[0].id = stuff->gc;
+    for(j = 1; j < PanoramiXNumScreens; j++)
+        newGC->info[j].id = FakeClientID(client->index);
+
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->gc = newGC->info[j].id;
+        stuff->drawable = refDraw->info[j].id;
+	if (tile)
+	    *((CARD32 *) &stuff[1] + tile_offset) = tile->info[j].id;
+	if (stip)
+	    *((CARD32 *) &stuff[1] + stip_offset) = stip->info[j].id;
+	if (clip)
+	    *((CARD32 *) &stuff[1] + clip_offset) = clip->info[j].id;
+        result = (*SavedProcVector[X_CreateGC])(client);
+        if(result != Success) break;
     }
+
+    if (result == Success)
+        AddResource(newGC->info[0].id, XRT_GC, newGC);
+    else 
+        xfree(newGC);
+
     return (result);
 }
 
-
 int PanoramiXChangeGC(ClientPtr client)
 {
-    GC 		*pGC;
+    PanoramiXRes *gc;
+    PanoramiXRes *stip = NULL;
+    PanoramiXRes *tile = NULL;
+    PanoramiXRes *clip = NULL;
     REQUEST(xChangeGCReq);
-    int 	result, j;
-    unsigned 	len;
-    PanoramiXGC   *pPanoramiXGC = PanoramiXGCRoot;
-    PanoramiXPmap	*pPanoramiXTile = NULL, *pPanoramiXStip = NULL;
-    PanoramiXPmap	*pPanoramiXClip = NULL;
-    int		tile_offset, stip_offset, clip_offset;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
+    int tile_offset = 0, stip_offset = 0, clip_offset = 0;
+    int result = 0, len, j;
+    XID tmp;
 
     REQUEST_AT_LEAST_SIZE(xChangeGCReq);
-    VERIFY_GC(pGC, stuff->gc, client);
-    len = client->req_len -  (sizeof(xChangeGCReq) >> 2);
-    IF_RETURN((len != Ones((Mask)stuff->mask)), BadLength);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    if ((Mask)stuff->mask & GCTile) {
-	XID tileID;
+    
+    len = client->req_len - (sizeof(xChangeGCReq) >> 2);
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+
+    if (!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+        return BadGC;
 
-	tile_offset = Ones((Mask)stuff->mask & (GCTile -1) );
-	tileID = *((CARD32 *) &stuff[1] + tile_offset);
-	if (tileID) {
-	    pPanoramiXTile = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXTile, tileID);
+    if ((Mask)stuff->mask & GCTile) {
+	tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
+	if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
+	   if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
     if ((Mask)stuff->mask & GCStipple) {
-	XID stipID;
-
-	stip_offset = Ones((Mask)stuff->mask & (GCStipple -1 ));
-	stipID = *((CARD32 *) &stuff[1] + stip_offset);
-	if (stipID) {
-	    pPanoramiXStip = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXStip, stipID);
+	stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
+	if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
+	   if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
     if ((Mask)stuff->mask & GCClipMask) {
-	XID clipID;
-
-	clip_offset = Ones((Mask)stuff->mask & (GCClipMask -1));
-	clipID = *((CARD32 *) &stuff[1] + clip_offset);
-	if (clipID) {
-	    pPanoramiXClip = PanoramiXPmapRoot;
-	    PANORAMIXFIND_ID(pPanoramiXClip, clipID);
+	clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
+	if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
+	   if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
+		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+	      return BadPixmap;
 	}
     }
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
-	stuff->gc = pPanoramiXGC->info[j].id;
-	if (pPanoramiXTile)
-	    *((CARD32 *) &stuff[1] + tile_offset) = pPanoramiXTile->info[j].id;
-	if (pPanoramiXStip)
-	    *((CARD32 *) &stuff[1] + stip_offset) = pPanoramiXStip->info[j].id;
-	if (pPanoramiXClip)
-	    *((CARD32 *) &stuff[1] + clip_offset) = pPanoramiXClip->info[j].id;
-	result = (* SavedProcVector[X_ChangeGC])(client);
-	BREAK_IF(result != Success);
-    }
-    PANORAMIX_FREE(client);
+
+
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->gc = gc->info[j].id;
+	if (tile)
+	    *((CARD32 *) &stuff[1] + tile_offset) = tile->info[j].id;
+	if (stip)
+	    *((CARD32 *) &stuff[1] + stip_offset) = stip->info[j].id;
+	if (clip)
+	    *((CARD32 *) &stuff[1] + clip_offset) = clip->info[j].id;
+        result = (*SavedProcVector[X_ChangeGC])(client);
+        if(result != Success) break;
+    }
+
     return (result);
 }
 
 
 int PanoramiXCopyGC(ClientPtr client)
 {
-    int 	j, result;
-    PanoramiXGC	*pPanoramiXGCSrc = PanoramiXGCRoot;
-    PanoramiXGC	*pPanoramiXGCDst = PanoramiXGCRoot;
+    PanoramiXRes *srcGC, *dstGC;
+    int         result = 0, j;
     REQUEST(xCopyGCReq);
 
     REQUEST_SIZE_MATCH(xCopyGCReq);
-    PANORAMIXFIND_ID(pPanoramiXGCSrc, stuff->srcGC);
-    IF_RETURN(!pPanoramiXGCSrc, BadGC);
-    PANORAMIXFIND_ID(pPanoramiXGCDst, stuff->dstGC);
-    IF_RETURN(!pPanoramiXGCDst, BadGC);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGCDst, j) {
-	stuff->srcGC = pPanoramiXGCSrc->info[j].id;
-	stuff->dstGC = pPanoramiXGCDst->info[j].id;
-	result = (* SavedProcVector[X_CopyGC])(client);
-	BREAK_IF(result != Success);
+
+    if(!(srcGC = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->srcGC, XRT_GC, SecurityReadAccess)))
+	return BadGC;
+
+    if(!(dstGC = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->dstGC, XRT_GC, SecurityWriteAccess)))
+	return BadGC;
+
+    FOR_NSCREENS(j) {
+	stuff->srcGC = srcGC->info[j].id;
+	stuff->dstGC = dstGC->info[j].id;
+	result = (*SavedProcVector[X_CopyGC])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
 int PanoramiXSetDashes(ClientPtr client)
 {
-    GC 		*pGC;
+    PanoramiXRes *gc;
+    int         result = 0, j;
     REQUEST(xSetDashesReq);
-    int 	result, j;
-    PanoramiXGC   *pPanoramiXGC = PanoramiXGCRoot;
 
     REQUEST_FIXED_SIZE(xSetDashesReq, stuff->nDashes);
-    VERIFY_GC(pGC, stuff->gc, client);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
-	stuff->gc = pPanoramiXGC->info[j].id;
-	result = (* SavedProcVector[X_SetDashes])(client);
-	BREAK_IF(result != Success);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+	return BadGC;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->gc = gc->info[j].id;
+	result = (*SavedProcVector[X_SetDashes])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
-int PanoramiXSetClipRectangles(register ClientPtr client)
+int PanoramiXSetClipRectangles(ClientPtr client)
 {
-    int 	result;
-    register GC *pGC;
+    PanoramiXRes *gc;
+    int         result = 0, j;
     REQUEST(xSetClipRectanglesReq);
-    int		j;
-    PanoramiXGC	*pPanoramiXGC = PanoramiXGCRoot;
 
     REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
-	stuff->gc = pPanoramiXGC->info[j].id;
-	result = (* SavedProcVector[X_SetClipRectangles])(client);
-	BREAK_IF(result != Success);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+	return BadGC;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->gc = gc->info[j].id;
+	result = (*SavedProcVector[X_SetClipRectangles])(client);
+        if(result != Success) break;
     }
+
     return (result);
 }
 
 
 int PanoramiXFreeGC(ClientPtr client)
 {
-    register GC *pGC;
+    PanoramiXRes *gc;
+    int         result = 0, j;
     REQUEST(xResourceReq);
-    int		result, j;
-    PanoramiXGC	*pPanoramiXGC = PanoramiXGCRoot;
-    PanoramiXGC	*pPanoramiXGCback = NULL;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    for (; pPanoramiXGC && (pPanoramiXGC->info[0].id != stuff->id); 
-						pPanoramiXGC = pPanoramiXGC->next)
-	pPanoramiXGCback = pPanoramiXGC;
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
-	stuff->id = pPanoramiXGC->info[j].id;
-        result = (* SavedProcVector[X_FreeGC])(client);
-	BREAK_IF(result != Success);
-    }
-    if ((result == Success) && pPanoramiXGCback &&
-	         pPanoramiXGC && pPanoramiXGC->FreeMe) {
-	pPanoramiXGCback->next = pPanoramiXGC->next;
-	if (pPanoramiXGC)
-	   Xfree(pPanoramiXGC);
-    }
-    PANORAMIX_FREE(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->id, XRT_GC, SecurityDestroyAccess)))
+	return BadGC;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->id = gc->info[j].id;
+	result = (*SavedProcVector[X_FreeGC])(client);
+	if(result != Success) break;
+    }
+
+    /* Since ProcFreeGC is using FreeResource, it will free
+	our resource for us on the last pass through the loop above */
+ 
     return (result);
 }
 
 
-int PanoramiXClearToBackground(register ClientPtr client)
+int PanoramiXClearToBackground(ClientPtr client)
 {
+    PanoramiXRes *win;
+    int         result = 0, j, x, y;
+    Bool	isRoot;
     REQUEST(xClearAreaReq);
-    register WindowPtr  pWin;
-    int 		result, j;
-    Window 		winID;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    int 		orig_x, orig_y;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xClearAreaReq);
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    IF_RETURN(!pPanoramiXWin, BadWindow);
-    orig_x = stuff->x;
-    orig_y = stuff->y;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	winID = pPanoramiXWin->info[j].id;
-	pWin = (WindowPtr) SecurityLookupWindow(winID, client, SecurityReadAccess);
-	if (!pWin) {
-	    client->errorValue = pPanoramiXWin->info[0].id;
-	    return (BadWindow);
-	}
-	stuff->window = winID;
-	if (pWin->drawable.id == PanoramiXWinRoot->info[j].id) {
-	    stuff->x = orig_x - panoramiXdataPtr[j].x;
-	    stuff->y = orig_y - panoramiXdataPtr[j].y;
+
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+	return BadWindow;
+
+    x = stuff->x;
+    y = stuff->y;
+    isRoot = (stuff->window == WindowTable[0]->drawable.id);
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->window = win->info[j].id;
+	if(isRoot) {
+	    stuff->x = x - panoramiXdataPtr[j].x;
+	    stuff->y = y - panoramiXdataPtr[j].y;
 	}
 	result = (*SavedProcVector[X_ClearArea])(client);
+	if(result != Success) break;
     }
-    PANORAMIX_FREE(client);
+ 
     return (result);
 }
 
 
+/* 
+    For Window to Pixmap copies you're screwed since each screen's
+    pixmap will look like what it sees on its screen.  Unless the
+    screens overlap and the window lies on each, the two copies
+    will be out of sync.  To remedy this we do a GetImage and PutImage
+    in place of the copy.  Doing this as a single Image isn't quite
+    correct since it will include the obscured areas but we will
+    have to fix this later. (MArk).
+*/
+
 int PanoramiXCopyArea(ClientPtr client)
 {
-    int			j, result;
-    Window		srcID, dstID;
-    DrawablePtr		pSrc, pDst;
-    GContext		GCID;
-    GC			*pGC;
-    PanoramiXWindow 	*pPanoramiXSrcRoot;
-    PanoramiXWindow 	*pPanoramiXDstRoot;
-    PanoramiXWindow	*pPanoramiXSrc;
-    PanoramiXWindow	*pPanoramiXDst;
-    PanoramiXGC		*pPanoramiXGC = PanoramiXGCRoot;
+    int			j, result = 0, srcx, srcy, dstx, dsty;
+    PanoramiXRes	*gc, *src, *dst;
+    Bool		srcIsRoot = FALSE;
+    Bool		dstIsRoot = FALSE;
+    Bool		srcShared, dstShared;
     REQUEST(xCopyAreaReq);
-    int           srcx = stuff->srcX, srcy = stuff->srcY;
-    int           dstx = stuff->dstX, dsty = stuff->dstY;
 
     REQUEST_SIZE_MATCH(xCopyAreaReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client);
-    if (stuff->dstDrawable != stuff->srcDrawable) {
-        VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client);
-        if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth)) {
-            client->errorValue = stuff->dstDrawable;
-            return (BadMatch);
-        }
+    if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+	return BadDrawable;
+
+    srcShared = IS_SHARED_PIXMAP(src);
+
+    if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;
+
+    dstShared = IS_SHARED_PIXMAP(dst);
+
+    if(dstShared && srcShared)
+	return (* SavedProcVector[X_CopyArea])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;
+
+    if((dst->type == XRT_WINDOW) &&
+       (stuff->dstDrawable == WindowTable[0]->drawable.id))
+	dstIsRoot = TRUE;
+    if((src->type == XRT_WINDOW) &&
+       (stuff->srcDrawable == WindowTable[0]->drawable.id))
+	srcIsRoot = TRUE;
+
+    srcx = stuff->srcX; srcy = stuff->srcY;
+    dstx = stuff->dstX; dsty = stuff->dstY;
+    if((dst->type == XRT_PIXMAP) && (src->type == XRT_WINDOW)) {
+	DrawablePtr drawables[MAXSCREENS];
+	DrawablePtr pDst;
+	GCPtr pGC;
+        char *data;
+	int pitch;
+
+	FOR_NSCREENS(j)
+	    VERIFY_DRAWABLE(drawables[j], src->info[j].id, client);
+
+	pitch = PixmapBytePad(stuff->width, drawables[0]->depth); 
+	if(!(data = xcalloc(1, stuff->height * pitch)))
+	    return BadAlloc;
+
+	XineramaGetImageData(drawables, srcx, srcy, 
+		stuff->width, stuff->height, ZPixmap, ~0, data, pitch, 
+		srcIsRoot);
+
+	FOR_NSCREENS_BACKWARD(j) {
+	    stuff->gc = gc->info[j].id;
+	    VALIDATE_DRAWABLE_AND_GC(dst->info[j].id, pDst, pGC, client);
+
+	    if(drawables[0]->depth != pDst->depth) {
+		client->errorValue = stuff->dstDrawable;
+		xfree(data);
+		return (BadMatch);
+	    }
+
+	    (*pGC->ops->PutImage) (pDst, pGC, pDst->depth, dstx, dsty, 
+				   stuff->width, stuff->height, 
+				   0, ZPixmap, data);
+
+	    if(dstShared) break;
+	}
+
+	xfree(data);
+
+	result = Success;
     } else {
-        pSrc = pDst;
-    } 
-    pPanoramiXSrcRoot = (pSrc->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXDstRoot = (pDst->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXSrc = pPanoramiXSrcRoot;
-    pPanoramiXDst = pPanoramiXDstRoot;
-    PANORAMIXFIND_ID(pPanoramiXSrc, stuff->srcDrawable);
-    IF_RETURN(!pPanoramiXSrc, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXDst, stuff->dstDrawable);
-    IF_RETURN(!pPanoramiXDst, BadDrawable);
-    GCID = stuff->gc;
-    PANORAMIXFIND_ID(pPanoramiXGC, GCID);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-
-    FOR_NSCREENS_OR_ONCE(pPanoramiXSrc, j) {
-	stuff->dstDrawable = pPanoramiXDst->info[j].id;
-	stuff->srcDrawable = pPanoramiXSrc->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
- 	if (pPanoramiXSrc == pPanoramiXSrcRoot) {	
-	    stuff->srcX = srcx - panoramiXdataPtr[j].x;
-	    stuff->srcY = srcy - panoramiXdataPtr[j].y;
+	DrawablePtr pDst = NULL, pSrc = NULL;
+	GCPtr pGC = NULL;
+	RegionPtr pRgn[MAXSCREENS];
+
+	FOR_NSCREENS_BACKWARD(j) {
+	    stuff->dstDrawable = dst->info[j].id;
+	    stuff->srcDrawable = src->info[j].id;
+	    stuff->gc          = gc->info[j].id;
+ 	    if (srcIsRoot) {	
+		stuff->srcX = srcx - panoramiXdataPtr[j].x;
+		stuff->srcY = srcy - panoramiXdataPtr[j].y;
+	    }
+ 	    if (dstIsRoot) {	
+		stuff->dstX = dstx - panoramiXdataPtr[j].x;
+		stuff->dstY = dsty - panoramiXdataPtr[j].y;
+	    }
+
+	    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client); 
+	    if (stuff->dstDrawable != stuff->srcDrawable) {
+		SECURITY_VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client,
+                                 SecurityReadAccess);
+		if ((pDst->pScreen != pSrc->pScreen) || 
+		    (pDst->depth != pSrc->depth)) {
+			client->errorValue = stuff->dstDrawable;
+			return (BadMatch);
+   		}
+ 	    } else
+		pSrc = pDst;
+
+	    pRgn[j] = (*pGC->ops->CopyArea)(pSrc, pDst, pGC, 
+				stuff->srcX, stuff->srcY,
+				stuff->width, stuff->height, 
+				stuff->dstX, stuff->dstY);
+
+	    if(dstShared) {
+		while(j--) pRgn[j] = NULL;
+		break;
+	    }
 	}
- 	if (pPanoramiXDst == pPanoramiXDstRoot) {	
-	    stuff->dstX = dstx - panoramiXdataPtr[j].x;
-	    stuff->dstY = dsty - panoramiXdataPtr[j].y;
+
+	if(pGC->graphicsExposures) {
+	    ScreenPtr pScreen = pDst->pScreen;
+	    RegionRec totalReg;
+	    Bool overlap;
+
+	    REGION_INIT(pScreen, &totalReg, NullBox, 1);
+	    FOR_NSCREENS_BACKWARD(j) {
+		if(pRgn[j]) {
+		   if(srcIsRoot) {
+		       REGION_TRANSLATE(pScreen, pRgn[j], 
+				panoramiXdataPtr[j].x, panoramiXdataPtr[j].y);
+		   }
+		   REGION_APPEND(pScreen, &totalReg, pRgn[j]);
+		   REGION_DESTROY(pScreen, pRgn[j]);
+		}
+	    }
+	    REGION_VALIDATE(pScreen, &totalReg, &overlap);
+	    (*pScreen->SendGraphicsExpose)(
+		client, &totalReg, stuff->dstDrawable, X_CopyArea, 0);
+	    REGION_UNINIT(pScreen, &totalReg);
 	}
-	result = (* SavedProcVector[X_CopyArea])(client);
-	BREAK_IF(result != Success);
+	
+	result = client->noClientException;
     }
+
     return (result);
 }
 
+
 int PanoramiXCopyPlane(ClientPtr client)
 {
-    int 	  SrcScr = -1, DstScr = -1;
-    PixmapPtr 	  pMap = NULL;
-    Pixmap	  pmapID;
-    PanoramiXRect   SrcRect, DstRect;
-    int 	  i, j, k;
-    Window 	  srcID, dstID;
-    DrawablePtr   pSrc, pDst;
-    GContext 	  GCID;
-    GContext      GCIDbase;
-    GC		  *pGC;
-    PanoramiXWindow *pPanoramiXSrc;
-    PanoramiXWindow *pPanoramiXDst;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    RegionPtr 	  *PanoramiXRgnPtrs;
-    RegionPtr 	  *FetchRgnPtrs = NULL;
-    RegionPtr 	  pRgn;
+    int			j, srcx, srcy, dstx, dsty;
+    PanoramiXRes	*gc, *src, *dst;
+    Bool		srcIsRoot = FALSE;
+    Bool		dstIsRoot = FALSE;
+    Bool		srcShared, dstShared;
+    DrawablePtr 	psrcDraw, pdstDraw = NULL;
+    GCPtr 		pGC = NULL;
+    RegionPtr 		pRgn[MAXSCREENS];
     REQUEST(xCopyPlaneReq);
-    int           srcx = stuff->srcX, srcy = stuff->srcY;
-    int           dstx = stuff->dstX, dsty = stuff->dstY;
-    int           width = stuff->width, height = stuff->height;
 
     REQUEST_SIZE_MATCH(xCopyPlaneReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client);
-    if (stuff->dstDrawable != stuff->srcDrawable) {
-        VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client);
-        if (pDst->pScreen != pSrc->pScreen) {
-            client->errorValue = stuff->dstDrawable;
-            return (BadMatch);
-        }
-    } else {
-        pSrc = pDst;
-    }
+    if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+	return BadDrawable;    
 
-    /*
-     *	Check to see if stuff->bitPlane has exactly ONE good bit set
-     */
+    srcShared = IS_SHARED_PIXMAP(src);
 
+    if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;
 
-    if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
-       (stuff->bitPlane > (1L << (pSrc->depth - 1))))
-    {
-       client->errorValue = stuff->bitPlane;
-       return(BadValue);
-    }
-
-    pPanoramiXSrc = (pSrc->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXDst = (pDst->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXSrc, stuff->srcDrawable);
-    IF_RETURN(!pPanoramiXSrc, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXDst, stuff->dstDrawable);
-    IF_RETURN(!pPanoramiXDst, BadDrawable);
-    GCIDbase = stuff->gc;
-    PANORAMIXFIND_ID(pPanoramiXGC, GCIDbase);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    
-    /*
-     *	Unless both are pixmaps, need to do special things to accomodate
-     *	being on multiple screens, different screens, etc.
-     */
-    
-    if (pSrc->type != DRAWABLE_PIXMAP) {
-	SrcRect.x = pSrc->x + srcx;
-	SrcRect.y = pSrc->y + srcy;
-	SrcRect.width = width;
-	SrcRect.height = height;
-	for (SrcScr = PanoramiXNumScreens - 1; SrcScr>=0; SrcScr-- )
-	    if (RECTA_SUBSUMES_RECTB(panoramiXdataPtr[SrcScr], SrcRect))
-		break;
-    }
-    if (pDst->type != DRAWABLE_PIXMAP) {
-	DstRect.x = pDst->x + dstx;
-	DstRect.y = pDst->y + dsty;
-	DstRect.width = width;
-	DstRect.height = height;
-	for (DstScr = PanoramiXNumScreens - 1; DstScr>=0; DstScr--)
-	    if (RECTA_SUBSUMES_RECTB(panoramiXdataPtr[DstScr], DstRect))
-		break;
-    } 
-	
-    /*
-     *	If source is on multiple screens, different screen from destination,
-     *	destination is on multiple screens, or destination is a pixmap,
-     *	need to get info into local pixmap for subsequent transfer.
-     */
-
-             
-    if ((pSrc->type != DRAWABLE_PIXMAP) && 
-	  (SrcScr < 0 || DstScr < 0 || SrcScr != DstScr 
-		|| pDst->type == DRAWABLE_PIXMAP)) {
-	unsigned char save_alu;
-	RegionRec     tempReg;
-	RegionPtr     pCompositeClip;
-	PanoramiXPmap   *pPanoramiXPmap = PanoramiXPmapRoot;
-
-	pMap = (PixmapPtr) (*pSrc->pScreen->CreatePixmap)(pSrc->pScreen,
-				    width, height, pGC->depth);
-	PANORAMIXFIND_LAST(pPanoramiXPmap, PanoramiXPmapRoot);
-	pPanoramiXPmap->next = 
-		    (PanoramiXPmap *)Xcalloc(sizeof(PanoramiXPmap));
-	pPanoramiXPmap = pPanoramiXPmap->next;
-	pmapID = FakeClientID(0);
-	AddResource(pmapID, RT_PIXMAP, (pointer)pMap);
-	for (j = PanoramiXNumScreens - 1; j>=0; j--)
-	    pPanoramiXPmap->info[j].id = pmapID;
-	tempReg.extents.x1 = 0;
-	tempReg.extents.y1 = 0;
-	tempReg.extents.x2 = width;
-	tempReg.extents.y2 = height;
-	tempReg.data = NULL;
-	FetchRgnPtrs = 
-	    (RegionPtr *) ALLOCATE_LOCAL(PanoramiXNumScreens * sizeof(RegionPtr));
-	i = 0;
-	FOR_NSCREENS_OR_ONCE(pPanoramiXSrc, j) {
-	    if ((SrcScr >= 0) && pPanoramiXSrc)
-		j = SrcScr;
-	    srcID = pPanoramiXSrc->info[j].id;
-	    pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE, 
-				 			 SecurityReadAccess);
-	    GCID = pPanoramiXGC->info[j].id;
-	    pGC = (GC *) LookupIDByType(GCID, RT_GC);
-	    pMap->drawable.pScreen = pSrc->pScreen;
-	    pGC->pScreen = pSrc->pScreen;
-	    save_alu = pGC->alu;
-	    pGC->alu = GXcopy;
-	    pCompositeClip = ((miPrivGC*)
-		    (pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip;
-	    ((miPrivGC*)(pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip = 
-&tempReg;
-	    FetchRgnPtrs[i++] = (*pGC->ops->CopyPlane)(pSrc, (DrawablePtr) pMap,
-			 pGC, srcx, srcy, width, height, 0, 0, stuff->bitPlane);
-	    pGC->alu = save_alu;
-	    ((miPrivGC*) (pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip = 
-pCompositeClip;
-	    if (SrcScr >= 0)
-		j = 0;
-	}
-    }
+    dstShared = IS_SHARED_PIXMAP(dst);
 
-    if (pMap) {
-	pSrc = (DrawablePtr) pMap;
-	srcx = 0;
-	srcy = 0;
-    }
-    PanoramiXRgnPtrs = 
-	    (RegionPtr *) ALLOCATE_LOCAL(PanoramiXNumScreens * sizeof(RegionPtr));
-    k = 0;
-	/* if src and dst are entirely on one screen, 
-	   then we only need one simple transfer */
-    if ((DstScr >= 0) && (pMap || (SrcScr >=0))) {
-	dstID = pPanoramiXDst->info[DstScr].id;
-	pDst = (DrawablePtr) SecurityLookupIDByClass(client, dstID, RC_DRAWABLE,
-						     SecurityReadAccess);
-	GCID = pPanoramiXGC->info[DstScr].id;
-	pGC = (GC *) LookupIDByType(GCID, RT_GC);
-	ValidateGC(pDst, pGC);
-	if (pMap) {
-	    pMap->drawable.pScreen = pDst->pScreen;
-	} else {
-	    srcID = pPanoramiXSrc->info[SrcScr].id;
-	    if (srcID != dstID) {
-		pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE,
-							     SecurityReadAccess);
-	    } else 
-		pSrc = pDst;
+    if(dstShared && srcShared)
+	return (* SavedProcVector[X_CopyPlane])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;
+
+    if((dst->type == XRT_WINDOW) &&
+       (stuff->dstDrawable == WindowTable[0]->drawable.id))
+	dstIsRoot = TRUE;
+    if((src->type == XRT_WINDOW) &&
+       (stuff->srcDrawable == WindowTable[0]->drawable.id))
+	srcIsRoot = TRUE;
+
+    srcx = stuff->srcX; srcy = stuff->srcY;
+    dstx = stuff->dstX; dsty = stuff->dstY;
+ 
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->dstDrawable = dst->info[j].id;
+	stuff->srcDrawable = src->info[j].id;
+	stuff->gc          = gc->info[j].id;
+	if (srcIsRoot) {	
+	    stuff->srcX = srcx - panoramiXdataPtr[j].x;
+	    stuff->srcY = srcy - panoramiXdataPtr[j].y;
 	}
-	if (pMap)
-	    PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, 
-			              srcx, srcy, width, height, dstx, dsty, 
-				      1);
-	else 
-	    PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, 
-				      srcx, srcy, width, height, dstx, dsty,
-				      stuff->bitPlane);
-    }else {
-      FOR_NSCREENS_OR_ONCE(pPanoramiXDst, j) {
-	if (DstScr >= 0) {
-	    dstID = pPanoramiXDst->info[DstScr].id;
-	    GCID = pPanoramiXGC->info[DstScr].id;
-	} else {
-	    dstID = pPanoramiXDst->info[j].id;
-	    GCID = pPanoramiXGC->info[j].id;
+	if (dstIsRoot) {	
+	    stuff->dstX = dstx - panoramiXdataPtr[j].x;
+	    stuff->dstY = dsty - panoramiXdataPtr[j].y;
 	}
-	pDst = (DrawablePtr) SecurityLookupIDByClass(client, dstID, RC_DRAWABLE,
-						     SecurityReadAccess);
-	pGC = (GC *) LookupIDByType(GCID, RT_GC);
-	ValidateGC(pDst, pGC);
-	if (pMap) {
-	    pMap->drawable.pScreen = pDst->pScreen;
-	} else {
-	    srcID = pPanoramiXSrc->info[j].id;
-	    if (srcID != dstID) {
-		pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE,
-							     SecurityReadAccess);
-	    } else {
-		pSrc = pDst;
+
+	VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, pGC, client);
+	if (stuff->dstDrawable != stuff->srcDrawable) {
+	    SECURITY_VERIFY_DRAWABLE(psrcDraw, stuff->srcDrawable, client,
+                                 SecurityReadAccess);
+            if (pdstDraw->pScreen != psrcDraw->pScreen) {
+		client->errorValue = stuff->dstDrawable;
+		return (BadMatch);
 	    }
+	} else
+	    psrcDraw = pdstDraw;
+
+	if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
+		(stuff->bitPlane > (1L << (psrcDraw->depth - 1)))) {
+	    client->errorValue = stuff->bitPlane;
+	    return(BadValue);
 	}
-	if (pMap)
-	    PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, 
-			              srcx, srcy, width, height, dstx, dsty, 
-				      1); 
-	else 
-	    PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, 
-				      srcx, srcy, width, height, dstx, dsty,
-				      stuff->bitPlane);
-      }
-    }
-    
-    if (pMap) {
-	for (j = PanoramiXNumScreens - 1; j>=0; j--)
-	    if (PanoramiXRgnPtrs[j])
-		(*pDst->pScreen->RegionDestroy) (PanoramiXRgnPtrs[j]);
-	DEALLOCATE_LOCAL(PanoramiXRgnPtrs);
-	PanoramiXRgnPtrs = FetchRgnPtrs;
-	k = i;
-    }
-    j = 1;
-    i = 0;
-    pRgn = PanoramiXRgnPtrs[i];
-    while ((j < k) && pRgn && !REGION_NIL(pRgn)) {
-	if (PanoramiXRgnPtrs[j]) {
-	    (*pGC->pScreen->Intersect)(pRgn, pRgn, PanoramiXRgnPtrs[j++]);
-	} else {
-	    pRgn = PanoramiXRgnPtrs[i++];
+
+	pRgn[j] = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC, 
+				stuff->srcX, stuff->srcY,
+				stuff->width, stuff->height, 
+				stuff->dstX, stuff->dstY, stuff->bitPlane);
+
+	if(dstShared) {
+	    while(j--) pRgn[j] = NULL;
+	    break;
 	}
     }
-    for (j = 0 ; j < k; j++) {
-	pRgn = PanoramiXRgnPtrs[j];
-	GCID = pPanoramiXGC->info[j].id;
-	pGC = (GC *) LookupIDByType(GCID, RT_GC);
-	if (pGC && pGC->graphicsExposures)
-	    (*pDst->pScreen->SendGraphicsExpose) (client, pRgn,
-					    stuff->dstDrawable, X_CopyPlane, 0);
-	if (pRgn)
-	    (*pDst->pScreen->RegionDestroy) (pRgn);
-    }
-    DEALLOCATE_LOCAL(PanoramiXRgnPtrs);
-    if (pMap) {
-	PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
-	PanoramiXPmap *pback = PanoramiXPmapRoot;
-
-	for (; pPanoramiXPmap && (pPanoramiXPmap->info[0].id != pmapID); 
-					    pPanoramiXPmap = pPanoramiXPmap->next)
-	    pback = pPanoramiXPmap;
-	FreeResource(pPanoramiXPmap->info[0].id, RT_NONE);
-	if (pback) {
-	    pback->next = pPanoramiXPmap->next;
-	    Xfree(pPanoramiXPmap);
+
+    if(pGC->graphicsExposures) {
+	ScreenPtr pScreen = pdstDraw->pScreen;
+	RegionRec totalReg;
+	Bool overlap;
+
+	REGION_INIT(pScreen, &totalReg, NullBox, 1);
+	FOR_NSCREENS_BACKWARD(j) {
+	    if(pRgn[j]) {
+		REGION_APPEND(pScreen, &totalReg, pRgn[j]);
+		REGION_DESTROY(pScreen, pRgn[j]);
+	    }
 	}
+	REGION_VALIDATE(pScreen, &totalReg, &overlap);
+	(*pScreen->SendGraphicsExpose)(
+		client, &totalReg, stuff->dstDrawable, X_CopyPlane, 0);
+	REGION_UNINIT(pScreen, &totalReg);
     }
+
     return (client->noClientException);
 }
 
 
 int PanoramiXPolyPoint(ClientPtr client)
 {
-    int 	  result, npoint, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    int           x_off = 0, y_off = 0;
+    PanoramiXRes *gc, *draw;
+    int 	  result = 0, npoint, j;
     xPoint 	  *origPts;
-    xPoint	  *origPtr, *modPtr;
+    Bool	  isRoot;
     REQUEST(xPolyPointReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyPointReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, locDraw->id);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyPoint])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
     npoint = ((client->req_len << 2) - sizeof(xPolyPointReq)) >> 2;
     if (npoint > 0) {
         origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
         memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
-        FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	  if (pPanoramiXWin == PanoramiXWinRoot) {
-	      x_off = panoramiXdataPtr[j].x;
-	      y_off = panoramiXdataPtr[j].y;
-	  }else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
-	}
-	  modPtr = (xPoint *) &stuff[1];
-	  origPtr = origPts;
-	  for (i = npoint; i; i--) {
-	      modPtr->x = origPtr->x - x_off;
-	      modPtr++->y = origPtr++->y - y_off;
-	  }
-	  stuff->drawable = pPanoramiXWin->info[j].id;
-	  stuff->gc = pPanoramiXGC->info[j].id;
-	  result = (* SavedProcVector[X_PolyPoint])(client);
-	  BREAK_IF(result != Success);
+        FOR_NSCREENS_FORWARD(j){
+
+            if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
+
+            if (isRoot) {
+                int x_off = panoramiXdataPtr[j].x;
+                int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+                    xPoint *pnts = (xPoint*)&stuff[1];
+		    int i = (stuff->coordMode==CoordModePrevious) ? 1 : npoint;
+
+		    while(i--) {
+			pnts->x -= x_off;
+			pnts->y -= y_off;
+			pnts++;
+                    }
+		}
+            }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyPoint])(client);
+	    if(result != Success) break;
         }
         DEALLOCATE_LOCAL(origPts);
         return (result);
-    }else
+    } else
 	return (client->noClientException);
-
 }
 
 
 int PanoramiXPolyLine(ClientPtr client)
 {
-    int 	  result, npoint, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    int           x_off = 0, y_off = 0;
+    PanoramiXRes *gc, *draw;
+    int 	  result = 0, npoint, j;
     xPoint 	  *origPts;
-    xPoint	  *origPtr, *modPtr;
+    Bool	  isRoot;
     REQUEST(xPolyLineReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyLineReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, locDraw->id);
-    /* In the case of Multibuffering, we need to make sure the drawable
-       isn't really a pixmap associated to a drawable */ 
-    if (!pPanoramiXWin && (stuff->drawable != locDraw->id)) {
-         pPanoramiXWin = PanoramiXPmapRoot;
-	 PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    }
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyLine])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
     npoint = ((client->req_len << 2) - sizeof(xPolyLineReq)) >> 2;
     if (npoint > 0){
         origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
         memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
-        FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	  if (pPanoramiXWin == PanoramiXWinRoot) {
-	      x_off = panoramiXdataPtr[j].x;
-	      y_off = panoramiXdataPtr[j].y;
-	  }else {
-	    if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	    }
-	  }
-	  modPtr = (xPoint *) &stuff[1];
-	  origPtr = origPts;
-	  for (i = npoint; i; i--) {
-	      modPtr->x = origPtr->x - x_off;
-	      modPtr++->y = origPtr++->y - y_off;
-	  }
-	  stuff->drawable = pPanoramiXWin->info[j].id;
-	  stuff->gc = pPanoramiXGC->info[j].id;
-	  result = (* SavedProcVector[X_PolyLine])(client);
-	  BREAK_IF(result != Success);
+        FOR_NSCREENS_FORWARD(j){
+
+            if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
+
+            if (isRoot) {
+                int x_off = panoramiXdataPtr[j].x;
+                int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+		    xPoint *pnts = (xPoint*)&stuff[1];
+		    int i = (stuff->coordMode==CoordModePrevious) ? 1 : npoint;
+
+		    while(i--) {
+			pnts->x -= x_off;
+			pnts->y -= y_off;
+			pnts++;
+		    }
+		}
+            }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyLine])(client);
+	    if(result != Success) break;
         }
         DEALLOCATE_LOCAL(origPts);
         return (result);
-   }else
+   } else
 	return (client->noClientException);
 }
 
 
 int PanoramiXPolySegment(ClientPtr client)
 {
-    int		  result, nsegs, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    int		  x_off = 0, y_off = 0;
+    int		  result = 0, nsegs, i, j;
+    PanoramiXRes *gc, *draw;
     xSegment 	  *origSegs;
-    xSegment 	  *origPtr, *modPtr;
+    Bool	  isRoot;
     REQUEST(xPolySegmentReq);
 
     REQUEST_AT_LEAST_SIZE(xPolySegmentReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-					    ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    /* In the case of Multibuffering, we need to make sure the drawable
-       isn't really a pixmap associated to a drawable */ 
-    if (!pPanoramiXWin && (stuff->drawable != locDraw->id)) {
-         pPanoramiXWin = PanoramiXPmapRoot;
-         PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    }
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolySegment])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     nsegs = (client->req_len << 2) - sizeof(xPolySegmentReq);
-    IF_RETURN((nsegs & 4), BadLength);
+    if(nsegs & 4) return BadLength;
     nsegs >>= 3;
     if (nsegs > 0) {
-        origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
-        memcpy((char *) origSegs, (char *) &stuff[1], nsegs * 
-sizeof(xSegment));
-        FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	  if (pPanoramiXWin == PanoramiXWinRoot) {
-	      x_off = panoramiXdataPtr[j].x;
-	      y_off = panoramiXdataPtr[j].y;
-	  }else {
-	    if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	    }
-	  }
-	  modPtr = (xSegment *) &stuff[1];
-	  origPtr = origSegs;
-	  for (i = nsegs; i; i--) {
-	     modPtr->x1 = origPtr->x1 - x_off;
-	     modPtr->y1 = origPtr->y1 - y_off;
-	     modPtr->x2 = origPtr->x2 - x_off;
-	     modPtr++->y2 = origPtr++->y2 - y_off;
-	  }
-	  stuff->drawable = pPanoramiXWin->info[j].id;
-	  stuff->gc = pPanoramiXGC->info[j].id;
-	  result = (* SavedProcVector[X_PolySegment])(client);
-	  BREAK_IF(result != Success);
+	origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
+        memcpy((char *) origSegs, (char *) &stuff[1], nsegs * sizeof(xSegment));
+        FOR_NSCREENS_FORWARD(j){
+
+            if(j) memcpy(&stuff[1], origSegs, nsegs * sizeof(xSegment));
+
+            if (isRoot) {
+                int x_off = panoramiXdataPtr[j].x;
+                int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+		    xSegment *segs = (xSegment*)&stuff[1];
+
+		    for (i = nsegs; i--; segs++) {
+			segs->x1 -= x_off;
+			segs->x2 -= x_off;
+			segs->y1 -= y_off;
+			segs->y2 -= y_off;
+		    }
+		}
+            }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolySegment])(client);
+	    if(result != Success) break;
     	}
-    DEALLOCATE_LOCAL(origSegs);
-    return (result);
-    }else
+	DEALLOCATE_LOCAL(origSegs);
+	return (result);
+    } else
 	  return (client->noClientException);
 }
 
 
 int PanoramiXPolyRectangle(ClientPtr client)
 {
-    int 	  result, nrects, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    int		  x_off = 0, y_off = 0;
+    int 	  result = 0, nrects, i, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
     xRectangle 	  *origRecs;
-    xRectangle 	  *origPtr, *modPtr;
     REQUEST(xPolyRectangleReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyRectangleReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-					    ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyRectangle])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     nrects = (client->req_len << 2) - sizeof(xPolyRectangleReq);
-    IF_RETURN((nrects & 4), BadLength);
+    if(nrects & 4) return BadLength;
     nrects >>= 3;
     if (nrects > 0){
-       origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
-       memcpy((char *) origRecs, (char *) &stuff[1], nrects * 
-sizeof(xRectangle));
-       FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	if (pPanoramiXWin == PanoramiXWinRoot) {
-	    x_off = panoramiXdataPtr[j].x;
-	    y_off = panoramiXdataPtr[j].y;
-	}else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
-	}
-	modPtr = (xRectangle *) &stuff[1];
-	origPtr = origRecs;
-	for (i = nrects; i; i--) {
-	    modPtr->x = origPtr->x - x_off;
-	    modPtr->y = origPtr->y - y_off;
-	    modPtr->width = origPtr->width - x_off;
-	    modPtr++->height = origPtr++->height - y_off;
+	origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
+	memcpy((char *)origRecs,(char *)&stuff[1],nrects * sizeof(xRectangle));
+        FOR_NSCREENS_FORWARD(j){
+
+            if(j) memcpy(&stuff[1], origRecs, nrects * sizeof(xRectangle));
+
+	    if (isRoot) {
+		int x_off = panoramiXdataPtr[j].x;
+		int y_off = panoramiXdataPtr[j].y;
+
+
+		if(x_off || y_off) {
+	    	    xRectangle *rects = (xRectangle *) &stuff[1];
+
+		    for (i = nrects; i--; rects++) {
+			rects->x -= x_off;
+			rects->y -= y_off;
+		    }
+		}
+	    } 
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyRectangle])(client);
+	    if(result != Success) break;
 	}
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	result = (* SavedProcVector[X_PolyRectangle])(client);
-	BREAK_IF(result != Success);
-       }
-       DEALLOCATE_LOCAL(origRecs);
-       return (result);
-    }else
+	DEALLOCATE_LOCAL(origRecs);
+	return (result);
+    } else
        return (client->noClientException);
 }
 
 
 int PanoramiXPolyArc(ClientPtr client)
 {
-    int 	  result, narcs, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    GCPtr 	  locGC;
-    int           x_off = 0, y_off = 0;
+    int 	  result = 0, narcs, i, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
     xArc	  *origArcs;
-    xArc	  *origPtr, *modPtr;
     REQUEST(xPolyArcReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyArcReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-                                            ? PanoramiXPmapRoot : 
-PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyArc])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     narcs = (client->req_len << 2) - sizeof(xPolyArcReq);
-    IF_RETURN((narcs % sizeof(xArc)), BadLength);
+    if(narcs % sizeof(xArc)) return BadLength;
     narcs /= sizeof(xArc);
     if (narcs > 0){
-       origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
-       memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
-       FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-        if (pPanoramiXWin == PanoramiXWinRoot) {
-            x_off = panoramiXdataPtr[j].x;
-            y_off = panoramiXdataPtr[j].y;
-        }else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
-	}
-        modPtr = (xArc *) &stuff[1];
-        origPtr = origArcs;
-        for (i = narcs; i; i--) {
-            modPtr->x = origPtr->x - x_off;
-            modPtr++->y = origPtr++->y - y_off;
+	origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+	memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
+        FOR_NSCREENS_FORWARD(j){
+
+            if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
+
+	    if (isRoot) {
+		int x_off = panoramiXdataPtr[j].x;
+		int y_off = panoramiXdataPtr[j].y;
+	
+		if(x_off || y_off) {
+		    xArc *arcs = (xArc *) &stuff[1];
+
+		    for (i = narcs; i--; arcs++) {
+			arcs->x -= x_off;
+			arcs->y -= y_off;
+		    }
+		}
+            }
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyArc])(client);
+	    if(result != Success) break;
         }
-        stuff->drawable = pPanoramiXWin->info[j].id;
-        stuff->gc = pPanoramiXGC->info[j].id;
-        result = (* SavedProcVector[X_PolyArc])(client);
-	BREAK_IF(result != Success);
-       }
-       DEALLOCATE_LOCAL(origArcs);
-       return (result);
-    }else
+	DEALLOCATE_LOCAL(origArcs);
+	return (result);
+    } else
        return (client->noClientException);
 }
 
 
 int PanoramiXFillPoly(ClientPtr client)
 {
-    int 	  result, count, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    GCPtr 	  locGC;
-    int		  x_off = 0, y_off = 0;
+    int 	  result = 0, count, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
     DDXPointPtr	  locPts;
-    DDXPointPtr	  origPts, modPts;
     REQUEST(xFillPolyReq);
 
     REQUEST_AT_LEAST_SIZE(xFillPolyReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_FillPoly])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     count = ((client->req_len << 2) - sizeof(xFillPolyReq)) >> 2;
     if (count > 0){
-       locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
-       memcpy((char *) locPts, (char *) &stuff[1], count * 
-sizeof(DDXPointRec));
-       FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	if (pPanoramiXWin == PanoramiXWinRoot) {
-	    x_off = panoramiXdataPtr[j].x;
-	    y_off = panoramiXdataPtr[j].y;
-	}else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
-	}
-	modPts = (DDXPointPtr) &stuff[1];
-	origPts = locPts;
-	for (i = count; i; i--) {
-	    modPts->x = origPts->x - x_off;
-	    modPts++->y = origPts++->y - y_off;
+	locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
+	memcpy((char *)locPts, (char *)&stuff[1], count * sizeof(DDXPointRec));
+        FOR_NSCREENS_FORWARD(j){
+
+	    if(j) memcpy(&stuff[1], locPts, count * sizeof(DDXPointRec));
+
+	    if (isRoot) {
+		int x_off = panoramiXdataPtr[j].x;
+		int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+		    DDXPointPtr pnts = (DDXPointPtr)&stuff[1];
+		    int i = (stuff->coordMode==CoordModePrevious) ? 1 : count;
+
+		    while(i--) {
+			pnts->x -= x_off;
+			pnts->y -= y_off;
+			pnts++;
+		    }
+		}
+	    }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_FillPoly])(client);
+	    if(result != Success) break;
 	}
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	result = (* SavedProcVector[X_FillPoly])(client);
-	BREAK_IF(result != Success);
-       }
-       DEALLOCATE_LOCAL(locPts);
-       return (result);
-    }else
+	DEALLOCATE_LOCAL(locPts);
+	return (result);
+    } else
        return (client->noClientException);
 }
 
 
 int PanoramiXPolyFillRectangle(ClientPtr client)
 {
-    int 	  result, things, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    GCPtr 	  locGC;
-    int		  x_off = 0, y_off = 0;
-    xRectangle	  *origThings;
-    xRectangle	  *origPtr, *modPtr;
+    int 	  result = 0, things, i, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
+    xRectangle	  *origRects;
     REQUEST(xPolyFillRectangleReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-                                            ? PanoramiXPmapRoot : 
-PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyFillRectangle])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     things = (client->req_len << 2) - sizeof(xPolyFillRectangleReq);
-    IF_RETURN((things & 4), BadLength);
+    if(things & 4) return BadLength;
     things >>= 3;
     if (things > 0){
-       origThings = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
-       memcpy((char *) origThings, (char *)&stuff[1], things * 
-sizeof(xRectangle));
-       FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-        if (pPanoramiXWin == PanoramiXWinRoot) {
-            x_off = panoramiXdataPtr[j].x;
-            y_off = panoramiXdataPtr[j].y;
-        }else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
+	origRects = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
+	memcpy((char*)origRects,(char*)&stuff[1], things * sizeof(xRectangle));
+        FOR_NSCREENS_FORWARD(j){
+
+	    if(j) memcpy(&stuff[1], origRects, things * sizeof(xRectangle));
+
+	    if (isRoot) {
+		int x_off = panoramiXdataPtr[j].x;
+		int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+		    xRectangle *rects = (xRectangle *) &stuff[1];
+
+		    for (i = things; i--; rects++) {
+			rects->x -= x_off;
+			rects->y -= y_off;
+		    }
+		}
+	    }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyFillRectangle])(client);
+	    if(result != Success) break;
 	}
-        modPtr = (xRectangle *) &stuff[1];
-        origPtr = origThings;
-        for (i = things; i; i--) {
-            modPtr->x = origPtr->x - x_off;
-            modPtr++->y = origPtr++->y - y_off;
-        }
-        stuff->drawable = pPanoramiXWin->info[j].id;
-        stuff->gc = pPanoramiXGC->info[j].id;
-        result = (* SavedProcVector[X_PolyFillRectangle])(client);
-	BREAK_IF(result != Success);
-       }
-       DEALLOCATE_LOCAL(origThings);
-       return (result);
-    }else
+	DEALLOCATE_LOCAL(origRects);
+	return (result);
+    } else
        return (client->noClientException);
 }
 
 
 int PanoramiXPolyFillArc(ClientPtr client)
 {
-    int 	  result, arcs, i, j;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   locDraw;
-    GCPtr 	  locGC;
-    int		  x_off = 0, y_off = 0;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
+    int 	  result = 0, narcs, i, j;
     xArc	  *origArcs;
-    xArc	  *origPtr, *modPtr;
     REQUEST(xPolyFillArcReq);
 
     REQUEST_AT_LEAST_SIZE(xPolyFillArcReq);
-    locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						    SecurityReadAccess);
-    IF_RETURN(!locDraw, BadDrawable);
-    pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
-                                            ? PanoramiXPmapRoot : 
-PanoramiXWinRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
-    arcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);
-    IF_RETURN((arcs % sizeof(xArc)), BadLength);
-    arcs /= sizeof(xArc);
-    if (arcs > 0) {
-       origArcs = (xArc *) ALLOCATE_LOCAL(arcs * sizeof(xArc));
-       memcpy((char *) origArcs, (char *)&stuff[1], arcs * sizeof(xArc));
-       FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-        if (pPanoramiXWin == PanoramiXWinRoot) {
-            x_off = panoramiXdataPtr[j].x;
-            y_off = panoramiXdataPtr[j].y;
-        }else {
-	  if ( (locDraw->type == DRAWABLE_PIXMAP) &&
-	       /* add special case check for root window */ 
-	       (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	           x_off = panoramiXdataPtr[j].x;
-	           y_off = panoramiXdataPtr[j].y;
-	  }
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyFillArc])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
+    narcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);
+    IF_RETURN((narcs % sizeof(xArc)), BadLength);
+    narcs /= sizeof(xArc);
+    if (narcs > 0) {
+	origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+	memcpy((char *) origArcs, (char *)&stuff[1], narcs * sizeof(xArc));
+        FOR_NSCREENS_FORWARD(j){
+
+	    if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
+
+	    if (isRoot) {
+		int x_off = panoramiXdataPtr[j].x;
+		int y_off = panoramiXdataPtr[j].y;
+
+		if(x_off || y_off) {
+		    xArc *arcs = (xArc *) &stuff[1];
+
+		    for (i = narcs; i--; arcs++) {
+			arcs->x -= x_off;
+			arcs->y -= y_off;
+		    }
+		}
+	    }
+
+	    stuff->drawable = draw->info[j].id;
+	    stuff->gc = gc->info[j].id;
+	    result = (* SavedProcVector[X_PolyFillArc])(client);
+	    if(result != Success) break;
 	}
-        modPtr = (xArc *) &stuff[1];
-        origPtr = origArcs;
-        for (i = arcs; i; i--) {
-            modPtr->x = origPtr->x - x_off;
-            modPtr++->y = origPtr++->y - y_off;
-        }
-        stuff->drawable = pPanoramiXWin->info[j].id;
-        stuff->gc = pPanoramiXGC->info[j].id;
-        result = (* SavedProcVector[X_PolyFillArc])(client);
-	BREAK_IF(result != Success);
-       }
-       DEALLOCATE_LOCAL(origArcs);
-       return (result);
-    }else
+	DEALLOCATE_LOCAL(origArcs);
+	return (result);
+    } else
        return (client->noClientException);
 }
 
 
-/* 64-bit server notes: the protocol restricts padding of images to
- * 8-, 16-, or 32-bits. We would like to have 64-bits for the server
- * to use internally. Removes need for internal alignment checking.
- * All of the PutImage functions could be changed individually, but
- * as currently written, they call other routines which require things
- * to be 64-bit padded on scanlines, so we changed things here.
- * If an image would be padded differently for 64- versus 32-, then
- * copy each scanline to a 64-bit padded scanline.
- * Also, we need to make sure that the image is aligned on a 64-bit
- * boundary, even if the scanlines are padded to our satisfaction.
- */
-
-int PanoramiXPutImage(register ClientPtr client)
+int PanoramiXPutImage(ClientPtr client)
 {
-    register GC		 *pGC;
-    register DrawablePtr pDraw;
-    long 		 lengthProto, 	/* length of scanline protocl padded */
-			 length; 	/* length of scanline server padded */
-    char 		 *tmpImage;
-    int			 j;
-    PanoramiXWindow 	 *pPanoramiXWin;
-    PanoramiXWindow 	 *pPanoramiXRoot;
-    PanoramiXGC 		 *pPanoramiXGC = PanoramiXGCRoot;
-    int			 orig_x, orig_y;
-    int			 result;
-
-
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
+    int		  j, result = 0, orig_x, orig_y;
     REQUEST(xPutImageReq);
 
     REQUEST_AT_LEAST_SIZE(xPutImageReq);
-    pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable, 
-RC_DRAWABLE,
-						  SecurityReadAccess);
-    IF_RETURN(!pDraw, BadDrawable);
-    pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP) 
-					    ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXWin = pPanoramiXRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin,BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PutImage])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     orig_x = stuff->dstX;
     orig_y = stuff->dstY;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-      if (pPanoramiXWin == pPanoramiXRoot) {
+    FOR_NSCREENS_BACKWARD(j){
+	if (isRoot) {
     	  stuff->dstX = orig_x - panoramiXdataPtr[j].x;
 	  stuff->dstY = orig_y - panoramiXdataPtr[j].y;
-      }       
-      if (pDraw->type == DRAWABLE_PIXMAP) { 
-	  if (stuff->width > panoramiXdataPtr[j].width) 
-    	      stuff->dstX = orig_x - panoramiXdataPtr[j].x;
-	  if (stuff->height > panoramiXdataPtr[j].height)
-	      stuff->dstY = orig_y - panoramiXdataPtr[j].y;
-      }
-      stuff->drawable = pPanoramiXWin->info[j].id;
-      stuff->gc = pPanoramiXGC->info[j].id;
-      result = (* SavedProcVector[X_PutImage])(client);
-    }
-    return(result);
+	}
+	stuff->drawable = draw->info[j].id;
+	stuff->gc = gc->info[j].id;
+	result = (* SavedProcVector[X_PutImage])(client);
+	if(result != Success) break;
+    }
+    return (result);
 }
 
 
-typedef struct _SrcParts{
-    int x1, y1, x2, y2, width, ByteWidth;
-    char *buf;
-} SrcPartsRec;
-
-
-int PanoramiXGetImage(register ClientPtr client)
+int PanoramiXGetImage(ClientPtr client)
 {
-    register DrawablePtr pDraw;
-    int			nlines, linesPerBuf;
-    register int	height, linesDone;
-    long		widthBytesLine, length;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-    long		widthBytesLineProto, lengthProto;
-    char 		*tmpImage;
-#endif
-    Mask		plane;
-    char		*pBuf;
+    DrawablePtr 	drawables[MAXSCREENS];
+    DrawablePtr 	pDraw;
+    PanoramiXRes	*draw;
     xGetImageReply	xgi;
-    int			j, k, ScrNum;
-    DrawablePtr		locDraw;
-    SrcPartsRec		srcParts;
-    BoxRec		SrcBox;
-    char		*BufPtr, *PartPtr;
-    PanoramiXWindow	*pPanoramiXWin = PanoramiXWinRoot;
+    Bool		isRoot;
+    char		*pBuf;
+    int         	i, x, y, w, h, format;
+    Mask		plane = 0, planemask;
+    int			linesDone, nlines, linesPerBuf;
+    long		widthBytesLine, length;
 
     REQUEST(xGetImageReq);
 
-    height = stuff->height;
     REQUEST_SIZE_MATCH(xGetImageReq);
+
     if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) {
 	client->errorValue = stuff->format;
         return(BadValue);
     }
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;
+
+    if(draw->type == XRT_PIXMAP)
+	return (*SavedProcVector[X_GetImage])(client);
+
     VERIFY_DRAWABLE(pDraw, stuff->drawable, client);
-    ScrNum = 0;
-    if (stuff->drawable == PanoramiXWinRoot->info[0].id) {
-       for (j = 0; j <= (PanoramiXNumScreens - 1); j++) {
-	  ScrNum = j;
-	  VERIFY_DRAWABLE(pDraw, pPanoramiXWin->info[ScrNum].id, client);
-	  if (stuff->x < panoramiXdataPtr[ScrNum].x  && 
-	      stuff->y < panoramiXdataPtr[ScrNum].y ) 
-	      break;	
-       }
-    }
-    if (pDraw->type == DRAWABLE_WINDOW) {
-	if (!((WindowPtr) pDraw)->realized	    /* Check for viewable */
-	    || pDraw->x + stuff->x < 0		    /* Check for on screen */
-	    || pDraw->x + stuff->x + (int)stuff->width > PanoramiXPixWidth
-	    || pDraw->y + stuff->y < 0
-	    || pDraw->y + stuff->y + height > PanoramiXPixHeight
-	    || stuff->x < - wBorderWidth((WindowPtr)pDraw)  /* Inside border */
-	    || stuff->x + (int)stuff->width >
-			wBorderWidth((WindowPtr)pDraw) + (int) pDraw->width
-			+ panoramiXdataPtr[ScrNum].x
-	    || stuff->y < -wBorderWidth((WindowPtr)pDraw) 
-	    || stuff->y + height >
-			wBorderWidth ((WindowPtr)pDraw) + (int) pDraw->height
-			+ panoramiXdataPtr[ScrNum].y)
+
+    if(!((WindowPtr)pDraw)->realized)
+	return(BadMatch);
+
+    x = stuff->x;
+    y = stuff->y;
+    w = stuff->width;
+    h = stuff->height;
+    format = stuff->format;
+    planemask = stuff->planeMask;
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
+    if(isRoot) {
+      if( /* check for being onscreen */
+	x < 0 || x + w > PanoramiXPixWidth ||
+	y < 0 || y + h > PanoramiXPixHeight )
 	    return(BadMatch);
-        VERIFY_DRAWABLE(pDraw, stuff->drawable, client);
-	xgi.visual = wVisual (((WindowPtr) pDraw));
-	pPanoramiXWin = PanoramiXWinRoot;
-	PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-	IF_RETURN(!pPanoramiXWin, BadWindow);
     } else {
-	if (stuff->x < 0 || stuff->x + (int)stuff->width > pDraw->width
-	    || stuff->y < 0 || stuff->y + height > pDraw->height)
+      if( /* check for being onscreen */
+	panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
+	panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
+        panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
+	panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
+	 /* check for being inside of border */
+       	x < - wBorderWidth((WindowPtr)pDraw) ||
+	x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
+	y < -wBorderWidth((WindowPtr)pDraw) ||
+	y + h > wBorderWidth ((WindowPtr)pDraw) + (int)pDraw->height)
 	    return(BadMatch);
-	xgi.visual = None;
     }
+
+    drawables[0] = pDraw;
+    for(i = 1; i < PanoramiXNumScreens; i++)
+	VERIFY_DRAWABLE(drawables[i], draw->info[i].id, client);
+
+    xgi.visual = wVisual (((WindowPtr) pDraw));
     xgi.type = X_Reply;
     xgi.sequenceNumber = client->sequence;
     xgi.depth = pDraw->depth;
-    if (stuff->format == ZPixmap) {
-	widthBytesLine 	= PixmapBytePad(stuff->width, pDraw->depth);
-	length 		= widthBytesLine * height;
+    if(format == ZPixmap) {
+	widthBytesLine = PixmapBytePad(w, pDraw->depth);
+	length = widthBytesLine * h;
+
 
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-	widthBytesLineProto = PixmapBytePadProto(stuff->width, pDraw->depth);
-	lengthProto 	    = widthBytesLineProto * height;
-#endif
     } else {
-	widthBytesLine = BitmapBytePad(stuff->width);
+	widthBytesLine = BitmapBytePad(w);
 	plane = ((Mask)1) << (pDraw->depth - 1);
 	/* only planes asked for */
-	length = widthBytesLine * height *
-		 Ones(stuff->planeMask & (plane | (plane - 1)));
+	length = widthBytesLine * h *
+		 Ones(planemask & (plane | (plane - 1)));
 
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-	widthBytesLineProto = BitmapBytePadProto(stuff->width);
-	lengthProto = widthBytesLineProto * height *
-		 Ones(stuff->planeMask & (plane | (plane - 1)));
-#endif
     }
 
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-    xgi.length = (lengthProto + 3) >> 2;
-#else
     xgi.length = (length + 3) >> 2;
-#endif
 
-    if (widthBytesLine == 0 || height == 0) {
+    if (widthBytesLine == 0 || h == 0)
 	linesPerBuf = 0;
-    } else if (widthBytesLine >= IMAGE_BUFSIZE) {
+    else if (widthBytesLine >= XINERAMA_IMAGE_BUFSIZE)
 	linesPerBuf = 1;
-    } else {
-	linesPerBuf = IMAGE_BUFSIZE / widthBytesLine;
-	if (linesPerBuf > height)
-	    linesPerBuf = height;
+    else {
+	linesPerBuf = XINERAMA_IMAGE_BUFSIZE / widthBytesLine;
+	if (linesPerBuf > h)
+	    linesPerBuf = h;
     }
     length = linesPerBuf * widthBytesLine;
-    if (linesPerBuf < height) {
-
-	/*
-	 *	Have to make sure intermediate buffers don't need padding
-	 */
-
-	while ((linesPerBuf > 1)
-		&& (length & ((1 << LOG2_BYTES_PER_SCANLINE_PAD)-1))) {
-	    linesPerBuf--;
-	    length -= widthBytesLine;
-	}
-	while (length & ((1 << LOG2_BYTES_PER_SCANLINE_PAD)-1)) {
-	    linesPerBuf++;
-	    length += widthBytesLine;
-	}
-    }
-    IF_RETURN((!(pBuf = (char *) ALLOCATE_LOCAL(length))), BadAlloc);
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-    /*
-     *	Check for protocol/server padding differences
-     */
-
-    if (widthBytesLine != widthBytesLineProto)
-    	if (!(tmpImage = (char *) ALLOCATE_LOCAL(length))) {
-	    DEALLOCATE_LOCAL(pBuf);
-	    return (BadAlloc);
-	}
-#endif
+    if(!(pBuf = xalloc(length)))
+	return (BadAlloc);
 
     WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
 
     if (linesPerBuf == 0) {
-
-	/*
-	 *	Nothing to do
-	 */
-
-    } else if (stuff->format == ZPixmap) {
+	/* nothing to do */
+    }
+    else if (format == ZPixmap) {
         linesDone = 0;
-        while (height - linesDone > 0) {
-	  nlines = min(linesPerBuf, height - linesDone);
-	  if (pDraw->type == DRAWABLE_WINDOW) {
-	    SrcBox.x1 = pDraw->x + stuff->x;
-	    SrcBox.y1 = pDraw->y + stuff->y + linesDone;
-	    SrcBox.x2 = SrcBox.x1 + stuff->width;
-	    SrcBox.y2 = SrcBox.y1 + nlines;
-	    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-		
-		/*
-		 *	If it isn't even on this screen, just continue.
-		 */
+        while (h - linesDone > 0) {
+	    nlines = min(linesPerBuf, h - linesDone);
 
-		if ((SrcBox.x1 >= panoramiXdataPtr[j].x + panoramiXdataPtr[j].width)
-		    || (SrcBox.x2 <= panoramiXdataPtr[j].x)
-		    || (SrcBox.y1 >= panoramiXdataPtr[j].y+panoramiXdataPtr[j].height)
-		    || (SrcBox.y2 <= panoramiXdataPtr[j].y))
-		    continue;
-
-		srcParts.x1 = max(SrcBox.x1 - panoramiXdataPtr[j].x, 0);
-		srcParts.x2 = min(SrcBox.x2 - panoramiXdataPtr[j].x, 
-						    panoramiXdataPtr[j].width);
-		srcParts.y1 = max(SrcBox.y1 - panoramiXdataPtr[j].y, 0);
-		srcParts.y2 = min(SrcBox.y2 - panoramiXdataPtr[j].y,
-						    panoramiXdataPtr[j].height);
-		srcParts.width = srcParts.x2 - srcParts.x1;
-		srcParts.ByteWidth = PixmapBytePad(srcParts.width,pDraw->depth);
-		srcParts.buf = (char *) Xalloc(nlines * srcParts.ByteWidth);
-		locDraw = (DrawablePtr) SecurityLookupIDByClass(client,
-								pPanoramiXWin->info[j].id,
-								RC_DRAWABLE,
-								SecurityReadAccess);
-		(*pDraw->pScreen->GetImage)(locDraw,
-					   srcParts.x1 - locDraw->x,
-					   srcParts.y1 - locDraw->y,
-					   srcParts.width,
-					   srcParts.y2 - srcParts.y1,
-					   stuff->format,
-					   (unsigned long)stuff->planeMask,
-					   srcParts.buf);
-		BufPtr = pBuf
-		    + srcParts.x1 - stuff->x - (pDraw->x - panoramiXdataPtr[j].x)
-		    + widthBytesLine * (srcParts.y1 - stuff->y
-				- (pDraw->y + linesDone - panoramiXdataPtr[j].y));
-		PartPtr = srcParts.buf;
-		for (k = (srcParts.y2 - srcParts.y1); k; k--) {
-		    bcopy(PartPtr, BufPtr, srcParts.width);
-		    BufPtr += widthBytesLine;
-		    PartPtr += srcParts.ByteWidth;
-		}
-		Xfree(srcParts.buf);
-	    }
-	  } else {
-	    (*pDraw->pScreen->GetImage) (pDraw, stuff->x, stuff->y + linesDone,
-					 stuff->width, nlines, stuff->format, 
-					 (unsigned long)stuff->planeMask, pBuf);
-	  }
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-	    /*
-	     *	For 64-bit server, convert image to pad to 32 bits
-	     */
-
-	    if ( widthBytesLine != widthBytesLineProto ) {
-		register char * bufPtr, * protoPtr;
-		register int i;
-
-		bzero(tmpImage,length);
-
-		for (i = 0, bufPtr = pBuf, protoPtr = tmpImage; i < nlines;
-		    bufPtr += widthBytesLine, protoPtr += widthBytesLineProto, 
-			i++)
-		    memmove(protoPtr,bufPtr,widthBytesLineProto);
-
-	        /* 
-		 *	Note this is NOT a call to WriteSwappedDataToClient,
-		 *	as we do NOT byte swap
-		 */
-
-	        (void)WriteToClient(client, 
-		    (int)(nlines * widthBytesLineProto), tmpImage);
-	    } else
-#endif
-	    {
+	    if(pDraw->depth == 1)
+		bzero(pBuf, nlines * widthBytesLine);
 
-	        /*
-		 *	Note this is NOT a call to WriteSwappedDataToClient,
-                 *	as we do NOT byte swap
-		 */
+	    XineramaGetImageData(drawables, x, y + linesDone, w, nlines,
+			format, planemask, pBuf, widthBytesLine, isRoot);
 
-	        (void)WriteToClient(client, 
-		     (int)(nlines * widthBytesLine), pBuf);
-	    }
+		(void)WriteToClient(client,
+				    (int)(nlines * widthBytesLine),
+				    pBuf);
 	    linesDone += nlines;
         }
-    } else {						/* XYPixmap	*/
+    } else { /* XYPixmap */
         for (; plane; plane >>= 1) {
-	    if (stuff->planeMask & plane) {
+	    if (planemask & plane) {
 	        linesDone = 0;
-	        while (height - linesDone > 0) {
-		    nlines = min(linesPerBuf, height - linesDone);
-	            (*pDraw->pScreen->GetImage) (pDraw,
-	                                         stuff->x,
-				                 stuff->y + linesDone,
-				                 stuff->width, 
-				                 nlines,
-				                 stuff->format,
-				                 (unsigned long)plane,
-				                 pBuf);
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-	    	    /*
-		     *	For 64-bit server, convert image to pad to 32 bits
-		     */
-
-	    	    if (widthBytesLine != widthBytesLineProto) {
-			register char * bufPtr, * protoPtr;
-			register int i;
-
-			bzero(tmpImage, length);
-
-			for (i = 0,bufPtr = pBuf,protoPtr =tmpImage; i < nlines;
-		    	      bufPtr += widthBytesLine,
-			      protoPtr += widthBytesLineProto, 
-			      i++)
-		    	    bcopy(bufPtr, protoPtr, widthBytesLineProto);
-
-		        /*
-			 *	Note: NOT a call to WriteSwappedDataToClient,
-		         *	  as we do NOT byte swap
-			 */
-
-		        (void)WriteToClient(client, 
-				 (int)(nlines * widthBytesLineProto), tmpImage);
-	    	    } else
-#endif
-		    {
+	        while (h - linesDone > 0) {
+		    nlines = min(linesPerBuf, h - linesDone);
 
-		        /*
-			 *	Note: NOT a call to WriteSwappedDataToClient,
-		         *	  as we do NOT byte swap
-			 */
+		    bzero(pBuf, nlines * widthBytesLine);
+
+		    XineramaGetImageData(drawables, x, y + linesDone, w, 
+					nlines, format, plane, pBuf,
+					widthBytesLine, isRoot);
+
+		    (void)WriteToClient(client,
+				    (int)(nlines * widthBytesLine),
+				    pBuf);
 
-		        (void)WriteToClient(client, 
-				 (int)(nlines * widthBytesLine), pBuf);
-		    }
 		    linesDone += nlines;
 		}
             }
 	}
     }
-    DEALLOCATE_LOCAL(pBuf);
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
-    if (widthBytesLine != widthBytesLineProto) 
-        DEALLOCATE_LOCAL(tmpImage);
-#endif
+    xfree(pBuf);
     return (client->noClientException);
 }
 
 
+/* The text stuff should be rewritten so that duplication happens
+   at the GlyphBlt level.  That is, loading the font and getting
+   the glyphs should only happen once */
+
 int 
-PanoramiXPolyText8(register ClientPtr client)
+PanoramiXPolyText8(ClientPtr client)
 {
-    int 	  result, j;
-
-    PanoramiXWindow *pPanoramiXRoot;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC     *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr      pDraw;
-    PixmapPtr        pPixmap;
-    GC 		    *pGC;
-    int		     orig_x, orig_y;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
+    int 	  result = 0, j;
+    int	 	  orig_x, orig_y;
     REQUEST(xPolyTextReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
-    pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
-                      ? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXWin = pPanoramiXRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    /* In the case of Multibuffering, we need to make sure the drawable
-       isn't really a pixmap associated to a drawable */ 
-    if (!pPanoramiXWin && (stuff->drawable != pDraw->id)) {
-         pPanoramiXWin = PanoramiXPmapRoot;
-	 PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    }
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+    REQUEST_AT_LEAST_SIZE(xPolyTextReq);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyText8])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     orig_x = stuff->x;
     orig_y = stuff->y;
-    FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	stuff->x = orig_x;
-	stuff->y = orig_y; 
-	if (pPanoramiXWin == pPanoramiXRoot) {
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->drawable = draw->info[j].id;
+	stuff->gc = gc->info[j].id;
+	if (isRoot) {
 	    stuff->x = orig_x - panoramiXdataPtr[j].x;
 	    stuff->y = orig_y - panoramiXdataPtr[j].y;
-	} else {
-	  if ( (pDraw->type == DRAWABLE_PIXMAP) &&
-                /* special case root window bitmap */ 
-	        (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		 panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	         stuff->x = orig_x - panoramiXdataPtr[j].x;
-	         stuff->y = orig_y - panoramiXdataPtr[j].y;
-	  }
 	}
-	if (!j)
-	    noPanoramiXExtension = TRUE;
 	result = (*SavedProcVector[X_PolyText8])(client);
-	noPanoramiXExtension = FALSE;
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
 
 int 
-PanoramiXPolyText16(register ClientPtr client)
+PanoramiXPolyText16(ClientPtr client)
 {
-    int 	  result, j;
-
-    PanoramiXWindow *pPanoramiXRoot;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   pDraw;
-    GC 		  *pGC;
-    int		  orig_x, orig_y;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
+    int 	  result = 0, j;
+    int	 	  orig_x, orig_y;
     REQUEST(xPolyTextReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
-    pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXWin = pPanoramiXRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    /* In the case of Multibuffering, we need to make sure the drawable
-       isn't really a pixmap associated to a drawable */ 
-    if (!pPanoramiXWin && (stuff->drawable != pDraw->id)) {
-         pPanoramiXWin = PanoramiXPmapRoot;
-	 PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    }
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+    REQUEST_AT_LEAST_SIZE(xPolyTextReq);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_PolyText16])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     orig_x = stuff->x;
     orig_y = stuff->y;
-    FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	stuff->x = orig_x;
-	stuff->y = orig_y; 
-	if (pPanoramiXWin == pPanoramiXRoot)  {
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->drawable = draw->info[j].id;
+	stuff->gc = gc->info[j].id;
+	if (isRoot) {
 	    stuff->x = orig_x - panoramiXdataPtr[j].x;
 	    stuff->y = orig_y - panoramiXdataPtr[j].y;
-	} else {
-	  if ( (pDraw->type == DRAWABLE_PIXMAP) &&
-	       /* special case root window bitmap */ 
-	        (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		 panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	         stuff->x = orig_x - panoramiXdataPtr[j].x;
-	         stuff->y = orig_y - panoramiXdataPtr[j].y;
-	  }
 	}
-	if (!j)
-	    noPanoramiXExtension = TRUE;
 	result = (*SavedProcVector[X_PolyText16])(client);
-	noPanoramiXExtension = FALSE;
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
 
 
-
 int PanoramiXImageText8(ClientPtr client)
 {
-    int 	  result, j;
-    PanoramiXWindow *pPanoramiXRoot;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   pDraw;
-    GCPtr 	  pGC;
+    int 	  result = 0, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
     int		  orig_x, orig_y;
     REQUEST(xImageTextReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
-    pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXWin = pPanoramiXRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_ImageText8])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     orig_x = stuff->x;
     orig_y = stuff->y;
-    FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	if (pPanoramiXWin == pPanoramiXRoot) {
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->drawable = draw->info[j].id;
+	stuff->gc = gc->info[j].id;
+	if (isRoot) {
 	    stuff->x = orig_x - panoramiXdataPtr[j].x;
 	    stuff->y = orig_y - panoramiXdataPtr[j].y;
-	}else {
-	  if ( (pDraw->type == DRAWABLE_PIXMAP) &&
-                /* special case root window bitmap */ 
-	        (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		 panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	         stuff->x = orig_x - panoramiXdataPtr[j].x;
-	         stuff->y = orig_y - panoramiXdataPtr[j].y;
-	  }
 	}
 	result = (*SavedProcVector[X_ImageText8])(client);
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
@@ -2682,249 +2020,217 @@ int PanoramiXImageText8(ClientPtr client)
 
 int PanoramiXImageText16(ClientPtr client)
 {
-    int 	  result, j;
-    PanoramiXWindow *pPanoramiXRoot;
-    PanoramiXWindow *pPanoramiXWin;
-    PanoramiXGC 	  *pPanoramiXGC = PanoramiXGCRoot;
-    DrawablePtr   pDraw;
-    GCPtr 	  pGC;
+    int 	  result = 0, j;
+    PanoramiXRes *gc, *draw;
+    Bool	  isRoot;
     int		  orig_x, orig_y;
     REQUEST(xImageTextReq);
 
-    VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
-    pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
-					? PanoramiXPmapRoot : PanoramiXWinRoot;
-    pPanoramiXWin = pPanoramiXRoot;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
-    IF_RETURN(!pPanoramiXWin, BadDrawable);
-    PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
-    IF_RETURN(!pPanoramiXGC, BadGC);
+    REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars << 1);
+
+    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+	return BadDrawable;    
+
+    if(IS_SHARED_PIXMAP(draw))
+	return (*SavedProcVector[X_ImageText16])(client);
+
+    if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+	return BadGC;    
+
+    isRoot = (draw->type == XRT_WINDOW) &&
+		(stuff->drawable == WindowTable[0]->drawable.id);
+
     orig_x = stuff->x;
     orig_y = stuff->y;
-    FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
-	stuff->drawable = pPanoramiXWin->info[j].id;
-	stuff->gc = pPanoramiXGC->info[j].id;
-	if (pPanoramiXWin == pPanoramiXRoot) {
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->drawable = draw->info[j].id;
+	stuff->gc = gc->info[j].id;
+	if (isRoot) {
 	    stuff->x = orig_x - panoramiXdataPtr[j].x;
 	    stuff->y = orig_y - panoramiXdataPtr[j].y;
-	}else {
-	  if ( (pDraw->type == DRAWABLE_PIXMAP) &&
-                /* special case root window bitmap */ 
-	        (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
-		 panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
-	         stuff->x = orig_x - panoramiXdataPtr[j].x;
-	         stuff->y = orig_y - panoramiXdataPtr[j].y;
-	  }
 	}
 	result = (*SavedProcVector[X_ImageText16])(client);
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
 
 
-int PanoramiXCreateColormap(register ClientPtr client)
-{
-    VisualPtr		pVisual;
-    ColormapPtr		pmap;
-    Colormap		mid;
-    register WindowPtr	pWin;
-    ScreenPtr 		pScreen;
-    DepthPtr 		 pDepth;
 
+int PanoramiXCreateColormap(ClientPtr client)
+{
+    PanoramiXRes	*win, *newCmap;
+    int 		result = 0, j, orig_visual;
     REQUEST(xCreateColormapReq);
 
-    int 		i, result;
-    int                 vid_index, class_index;
-    int                 this_vid_index, this_class_index, this_depth;
-    int			j = 0;
-    VisualID            orig_visual;
-    Colormap		cmapID;
-    PanoramiXWindow 	*pPanoramiXWin = PanoramiXWinRoot;
-    PanoramiXCmap	*localCmap;
-    PanoramiXCmap	*pPanoramiXCmap = PanoramiXCmapRoot;
-    short		VisualClass;
-    Bool		ClassKnown;
-    Bool		FoundIt = FALSE;
-
     REQUEST_SIZE_MATCH(xCreateColormapReq);
 
-    mid = stuff->mid;
+    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+		client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+	return BadWindow;    
+
+    if(!stuff->visual || (stuff->visual > 255)) 
+	return BadValue;
+
+    if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
+
+    newCmap->type = XRT_COLORMAP;
+    newCmap->info[0].id = stuff->mid;
+    for(j = 1; j < PanoramiXNumScreens; j++)
+        newCmap->info[j].id = FakeClientID(client->index);
+
     orig_visual = stuff->visual;
-    j = 0;
-    PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
-    if (pPanoramiXWin) {
-	localCmap = (PanoramiXCmap *)Xcalloc(sizeof(PanoramiXCmap));
-	IF_RETURN(!localCmap, BadAlloc);
-    } else {
-	return BadWindow;
-    }
-    for (j = 0; j <= PanoramiXNumScreens - 1; j++) {
-	cmapID = j ? FakeClientID(client->index) : mid;
-	localCmap->info[j].id = cmapID;
-    }
-    localCmap->FreeMe = FALSE;
-    PANORAMIXFIND_LAST(pPanoramiXCmap, PanoramiXCmapRoot);
-    pPanoramiXCmap->next = localCmap;
-
-    /* Use Screen 0 to get the matching Visual ID */
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-                                           SecurityReadAccess);
-    if ( stuff->visual != CopyFromParent)
-      {
-       /* Find the correct visual for screen 0 */
-	for (class_index = 0; class_index < PanoramiXColorDepthTable[0].numVisuals; 
-class_index++)
-	  {
-	    for (j = 0; j < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index
-].numDepths; j++ )
-	      {
-		pDepth = (DepthPtr) &pWin->drawable.pScreen->allowedDepths[j];
-		for (vid_index = 0; vid_index < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[pDepth->depth].numVids; vid_index++)
-		  {
-		    if ( stuff->visual == PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[pDepth->depth].vid[vid_index] )
-		      {
-			this_class_index = class_index;
-			this_vid_index   = vid_index;
-			this_depth       = pDepth->depth;
-			FoundIt          = TRUE;
-			break;
-		      }
-		  }
-	      }
-	  }
-      }
-    if (!pWin)
-         return(BadWindow);
-    pScreen = pWin->drawable.pScreen;
-    FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-	stuff->mid = localCmap->info[j].id;
-	stuff->window = pPanoramiXWin->info[j].id;
-        /* Look for the matching visual class, and use its
-	   visual id for creating this colormap. */
-	if ( orig_visual != CopyFromParent && FoundIt ) 
-	  {
-	    stuff->visual = PanoramiXColorDepthTable[j].panoramiXScreenMap[this_class_index].vmap[this_depth].vid[this_vid_index];
-	  }
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->mid = newCmap->info[j].id;
+	stuff->window = win->info[j].id;
+	stuff->visual = PanoramiXVisualTable[(orig_visual * MAXSCREENS) + j];
 	result = (* SavedProcVector[X_CreateColormap])(client);
-	BREAK_IF(result != Success);
-    }
-    if (result != Success) {
-       pPanoramiXCmap->next = NULL ;
-       if (localCmap)
-           Xfree(localCmap);
+	if(result != Success) break;
     }
+ 
+    if (result == Success)
+        AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
+    else 
+        xfree(newCmap);
+
     return (result);
 }
 
 
 int PanoramiXFreeColormap(ClientPtr client)
 {
-    ColormapPtr	pmap;
+    PanoramiXRes *cmap;
+    int          result = 0, j;
     REQUEST(xResourceReq);
-    int         result, j;
-    PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
-    PanoramiXCmap *pPanoramiXCmapback = NULL;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
 
     REQUEST_SIZE_MATCH(xResourceReq);
 
-    for (; pPanoramiXCmap && (pPanoramiXCmap->info[0].id != stuff->id);
-					    pPanoramiXCmap = pPanoramiXCmap->next)
-        pPanoramiXCmapback = pPanoramiXCmap;
-    IF_RETURN(!pPanoramiXCmap, BadColor);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-        stuff->id = pPanoramiXCmap->info[j].id;
+    client->errorValue = stuff->id;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->id, XRT_COLORMAP, SecurityDestroyAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->id = cmap->info[j].id;
         result = (* SavedProcVector[X_FreeColormap])(client);
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
-    if ((result == Success) && pPanoramiXCmapback && 
-	       pPanoramiXCmap && pPanoramiXCmap->FreeMe) {
-        pPanoramiXCmapback->next = pPanoramiXCmap->next;
-        Xfree(pPanoramiXCmap);
+
+    /* Since ProcFreeColormap is using FreeResource, it will free
+	our resource for us on the last pass through the loop above */
+
+    return (result);
+}
+
+
+int
+PanoramiXCopyColormapAndFree(ClientPtr client)
+{
+    PanoramiXRes *cmap, *newCmap;
+    int          result = 0, j;
+    REQUEST(xCopyColormapAndFreeReq);
+
+    REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
+
+    client->errorValue = stuff->srcCmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->srcCmap, XRT_COLORMAP, 
+		SecurityReadAccess | SecurityWriteAccess)))
+        return BadColor;
+
+    if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
+
+    newCmap->type = XRT_COLORMAP;
+    newCmap->info[0].id = stuff->mid;
+    for(j = 1; j < PanoramiXNumScreens; j++)
+        newCmap->info[j].id = FakeClientID(client->index);
+
+    FOR_NSCREENS_BACKWARD(j){
+        stuff->srcCmap = cmap->info[j].id;
+	stuff->mid = newCmap->info[j].id;
+        result = (* SavedProcVector[X_CopyColormapAndFree])(client);
+	if(result != Success) break;
     }
-    PANORAMIX_FREE(client);
+
+    if (result == Success)
+        AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
+    else 
+        xfree(newCmap);
+
     return (result);
 }
 
 
-int PanoramiXInstallColormap(register ClientPtr client)
+int PanoramiXInstallColormap(ClientPtr client)
 {
-    ColormapPtr pcmp;
     REQUEST(xResourceReq);
-    int 	result, j;
-    PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+    int 	result = 0, j;
+    PanoramiXRes *cmap;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->id);
-    IF_RETURN(!pPanoramiXCmap, BadColor);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-	stuff->id = pPanoramiXCmap->info[j].id;
+
+    client->errorValue = stuff->id;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->id = cmap->info[j].id;
 	result = (* SavedProcVector[X_InstallColormap])(client);
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
 
 
-int PanoramiXUninstallColormap(register ClientPtr client)
+int PanoramiXUninstallColormap(ClientPtr client)
 {
-    ColormapPtr pcmp;
     REQUEST(xResourceReq);
-    int 	result, j;
-    PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
-
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
+    int 	result = 0, j;
+    PanoramiXRes *cmap;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->id);
-    IF_RETURN(!pPanoramiXCmap, BadColor);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-	stuff->id = pPanoramiXCmap->info[j].id;
+ 
+    client->errorValue = stuff->id;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j) {
+	stuff->id = cmap->info[j].id;
 	result = (* SavedProcVector[X_UninstallColormap])(client);
-	BREAK_IF(result != Success);
+	if(result != Success) break;
     }
-    PANORAMIX_FREE(client);
     return (result);
 }
 
 
 int PanoramiXAllocColor(ClientPtr client)
 {
-    int           result, j;
-    PanoramiXCmap	  *pPanoramiXCmap = PanoramiXCmapRoot;
+    int           result = 0, j;
+    PanoramiXRes *cmap;
     REQUEST(xAllocColorReq);
 
     REQUEST_SIZE_MATCH(xAllocColorReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
-    if (!pPanoramiXCmap){
-	noPanoramiXExtension = TRUE;
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+	return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->cmap = cmap->info[j].id;
 	result = (* SavedProcVector[X_AllocColor])(client);
-	noPanoramiXExtension = FALSE;
-    }else {
-        FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-            stuff->cmap = pPanoramiXCmap->info[j].id;
-	    if (!j)
-	        noPanoramiXExtension = TRUE;
-            result = (* SavedProcVector[X_AllocColor])(client);
-	    noPanoramiXExtension = FALSE;
-            BREAK_IF(result != Success);
-	}
+	if(result != Success) break;
     }
     return (result);
 }
@@ -2932,20 +2238,22 @@ int PanoramiXAllocColor(ClientPtr client)
 
 int PanoramiXAllocNamedColor(ClientPtr client)
 {
-    int           result, j;
-    PanoramiXCmap	  *pPanoramiXCmap = PanoramiXCmapRoot;
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
     REQUEST(xAllocNamedColorReq);
 
     REQUEST_FIXED_SIZE(xAllocNamedColorReq, stuff->nbytes);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
-    IF_RETURN(!pPanoramiXCmap, BadColor);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-        stuff->cmap = pPanoramiXCmap->info[j].id;
-	if (!j)
-	    noPanoramiXExtension = TRUE;
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j){
+        stuff->cmap = cmap->info[j].id;
         result = (* SavedProcVector[X_AllocNamedColor])(client);
-	noPanoramiXExtension = FALSE;
-        BREAK_IF(result != Success);
+	if(result != Success) break;
     }
     return (result);
 }
@@ -2953,82 +2261,114 @@ int PanoramiXAllocNamedColor(ClientPtr client)
 
 int PanoramiXAllocColorCells(ClientPtr client)
 {
-    int           result, j;
-    PanoramiXCmap	  *pPanoramiXCmap = PanoramiXCmapRoot;
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
     REQUEST(xAllocColorCellsReq);
 
     REQUEST_SIZE_MATCH(xAllocColorCellsReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
-    if (!pPanoramiXCmap) {
-	noPanoramiXExtension = TRUE;
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+	return BadColor;
+	
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->cmap = cmap->info[j].id;
 	result = (* SavedProcVector[X_AllocColorCells])(client);
-        noPanoramiXExtension = FALSE;
-    }else {
-        FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-            stuff->cmap = pPanoramiXCmap->info[j].id;
-	    if (!j)
-	        noPanoramiXExtension = TRUE;
-            result = (* SavedProcVector[X_AllocColorCells])(client);
-	    noPanoramiXExtension = FALSE;
-	    /* Because id's are eventually searched for in
-	       some client list, we don't check for success 
-	       on fake id's last id will be real, we really 
-	       only care about results related to real id's 
-	     BREAK_IF(result != Success);
-	     */
-	}
+	if(result != Success) break;
     }
     return (result);
 }
 
 
-int PanoramiXFreeColors(register ClientPtr client)
+int PanoramiXAllocColorPlanes(ClientPtr client)
 {
-    int           result, j;
-    PanoramiXCmap	  *pPanoramiXCmap = PanoramiXCmapRoot;
-    REQUEST(xFreeColorsReq);
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
+    REQUEST(xAllocColorPlanesReq);
 
-    PanoramiXGC           *pPanoramiXFreeGC;
-    PanoramiXGC           *pPanoramiXFreeGCback = NULL;
-    PanoramiXWindow       *pPanoramiXFreeWin;
-    PanoramiXWindow       *pPanoramiXFreeWinback = NULL;
-    PanoramiXCmap         *pPanoramiXFreeCmap;
-    PanoramiXCmap         *pPanoramiXFreeCmapback = NULL;
-    PanoramiXPmap         *pPanoramiXFreePmap;
-    PanoramiXPmap         *pPanoramiXFreePmapback = NULL;
+    REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+	return BadColor;
+	
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->cmap = cmap->info[j].id;
+	result = (* SavedProcVector[X_AllocColorPlanes])(client);
+	if(result != Success) break;
+    }
+    return (result);
+}
+
+
+
+int PanoramiXFreeColors(ClientPtr client)
+{
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
+    REQUEST(xFreeColorsReq);
 
     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
-    IF_RETURN(!pPanoramiXCmap, BadColor);
-    FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-        stuff->cmap = pPanoramiXCmap->info[j].id;
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j) {
+        stuff->cmap = cmap->info[j].id;
         result = (* SavedProcVector[X_FreeColors])(client);
-	/* Because id's are eventually searched for in
-	   some client list, we don't check for success 
-	   on fake id's last id will be real, we really 
-	   only care about results related to real id's */
     }
-    PANORAMIX_FREE(client);
     return (result);
 }
 
 
 int PanoramiXStoreColors(ClientPtr client)
 {
-    int           result, j;
-    PanoramiXCmap	  *pPanoramiXCmap = PanoramiXCmapRoot;
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
     REQUEST(xStoreColorsReq);
 
     REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
-    PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
-    if (!pPanoramiXCmap)
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->cmap = cmap->info[j].id;
 	result = (* SavedProcVector[X_StoreColors])(client);
-    else {
-        FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
-            stuff->cmap = pPanoramiXCmap->info[j].id;
-            result = (* SavedProcVector[X_StoreColors])(client);
-            BREAK_IF(result != Success);
-	}
+	if(result != Success) break;
+    }
+    return (result);
+}
+
+
+int PanoramiXStoreNamedColor(ClientPtr client)
+{
+    int           result = 0, j;
+    PanoramiXRes  *cmap;
+    REQUEST(xStoreNamedColorReq);
+
+    REQUEST_FIXED_SIZE(xStoreNamedColorReq, stuff->nbytes);
+
+    client->errorValue = stuff->cmap;
+
+    if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+        return BadColor;
+
+    FOR_NSCREENS_BACKWARD(j){
+	stuff->cmap = cmap->info[j].id;
+	result = (* SavedProcVector[X_StoreNamedColor])(client);
+	if(result != Success) break;
     }
     return (result);
 }