Merge branch '3.6.x'

12 files changed, 304 insertions, 2399 deletions

diff --git a/nx-X11/programs/Xserver/xfixes/Imakefile b/nx-X11/programs/Xserver/xfixes/Imakefile
index e467ed149..83e368488 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/Imakefile
+++ b/nx-X11/programs/Xserver/xfixes/Imakefile
@@ -1,14 +1,25 @@
 #include <Server.tmpl>
 
+       NULL =
+
        SRCS =	cursor.c region.c saveset.c select.c xfixes.c
 
        OBJS =	cursor.o region.o saveset.o select.o xfixes.o
 
    INCLUDES =   -I. -I../include -I../Xext -I../fixes  -I../render \
-		-I$(EXTINCSRC) -I$(XINCLUDESRC)
+		-I$(EXTINCSRC) -I$(XINCLUDESRC) \
+		`pkg-config --cflags-only-I pixman-1`
 
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
+#if defined(NXAgentServer) && NXAgentServer
+ NX_DEFINES = -DNXAGENT_SERVER
+#endif
+
+    DEFINES = 			\
+              $(NX_DEFINES)	\
+              $(NULL)
+
 NormalLibraryTarget(xfixes,$(OBJS))
 NormalLibraryObjectRule()
 LintLibraryTarget(xfixes,$(SRCS))
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index f6895d193..00a912be3 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -76,7 +76,7 @@ typedef struct _CursorScreen {
 
 #define GetCursorScreen(s)	((CursorScreenPtr) ((s)->devPrivates[CursorScreenPrivateIndex].ptr))
 #define GetCursorScreenIfSet(s) ((CursorScreenPrivateIndex != -1) ? GetCursorScreen(s) : NULL)
-#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (pointer) (p))
+#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (void *) (p))
 #define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)
 #define Unwrap(as,s,elt)	((s)->elt = (as)->elt)
 
@@ -96,13 +96,11 @@ CursorDisplayCursor (ScreenPtr pScreen,
 	CursorCurrent = pCursor;
 	for (e = cursorEvents; e; e = e->next)
 	{
-	    if ((e->eventMask & XFixesDisplayCursorNotifyMask) &&
-		!e->pClient->clientGone)
+	    if ((e->eventMask & XFixesDisplayCursorNotifyMask))
 	    {
 		xXFixesCursorNotifyEvent	ev;
 		ev.type = XFixesEventBase + XFixesCursorNotify;
 		ev.subtype = XFixesDisplayCursorNotify;
-		ev.sequenceNumber = e->pClient->sequence;
 		ev.window = e->pWindow->drawable.id;
 		ev.cursorSerial = pCursor->serialNumber;
 		ev.timestamp = currentTime.milliseconds;
@@ -116,17 +114,17 @@ CursorDisplayCursor (ScreenPtr pScreen,
 }
 
 static Bool
-CursorCloseScreen (int index, ScreenPtr pScreen)
+CursorCloseScreen (ScreenPtr pScreen)
 {
     CursorScreenPtr	cs = GetCursorScreen (pScreen);
     Bool		ret;
 
     Unwrap (cs, pScreen, CloseScreen);
     Unwrap (cs, pScreen, DisplayCursor);
-    ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (cs);
-    if (index == 0)
-	CursorScreenPrivateIndex = -1;
+    ret = (*pScreen->CloseScreen) (pScreen);
+    free (cs);
+    if (screenInfo.numScreens <= 1)
+       CursorScreenPrivateIndex = -1;
     return ret;
 }
 
@@ -157,7 +155,7 @@ XFixesSelectCursorInput (ClientPtr	pClient,
     }
     if (!e)
     {
-	e = (CursorEventPtr) xalloc (sizeof (CursorEventRec));
+	e = (CursorEventPtr) malloc (sizeof (CursorEventRec));
 	if (!e)
 	    return BadAlloc;
 
@@ -172,13 +170,13 @@ XFixesSelectCursorInput (ClientPtr	pClient,
 	 */
 	if (!LookupIDByType(pWindow->drawable.id, CursorWindowType))
 	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
-			      (pointer) pWindow))
+			      (void *) pWindow))
 	    {
-		xfree (e);
+		free (e);
 		return BadAlloc;
 	    }
 
-	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))
+	if (!AddResource (e->clientResource, CursorClientType, (void *) e))
 	    return BadAlloc;
 
 	*prev = e;
@@ -195,7 +193,7 @@ ProcXFixesSelectCursorInput (ClientPtr client)
 
     REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (stuff->eventMask & ~CursorAllEvents)
@@ -225,12 +223,11 @@ GetBit (unsigned char *line, int x)
 int
 SProcXFixesSelectCursorInput (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesSelectCursorInputReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->eventMask, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->eventMask);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
     
@@ -312,7 +309,7 @@ ProcXFixesGetCursorImage (ClientPtr client)
     width = pCursor->bits->width;
     height = pCursor->bits->height;
     npixels = width * height;
-    rep = xalloc (sizeof (xXFixesGetCursorImageReply) +
+    rep = malloc (sizeof (xXFixesGetCursorImageReply) +
 		  npixels * sizeof (CARD32));
     if (!rep)
 	return BadAlloc;
@@ -329,33 +326,30 @@ ProcXFixesGetCursorImage (ClientPtr client)
     rep->cursorSerial = pCursor->serialNumber;
 
     image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    if (client->swapped) {
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->x);
+	swaps(&rep->y);
+	swaps(&rep->width);
+	swaps(&rep->height);
+	swaps(&rep->xhot);
+	swaps(&rep->yhot);
+	swapl(&rep->cursorSerial);
+	SwapLongs(image, npixels);
     }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
+    WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
 			 (npixels << 2), (char *) rep);
-    xfree (rep);
+    free (rep);
     return client->noClientException;
 }
 
 int
 SProcXFixesGetCursorImage (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesGetCursorImageReq);
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -368,7 +362,7 @@ ProcXFixesSetCursorName (ClientPtr client)
     Atom atom;
 
     REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityWriteAccess);
+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixWriteAccess);
     tchar = (char *) &stuff[1];
     atom = MakeAtom (tchar, stuff->nbytes, TRUE);
     if (atom == BAD_RESOURCE)
@@ -381,13 +375,12 @@ ProcXFixesSetCursorName (ClientPtr client)
 int
 SProcXFixesSetCursorName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetCursorNameReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    swaps (&stuff->nbytes, n);
+    swapl(&stuff->cursor);
+    swaps(&stuff->nbytes);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -397,11 +390,11 @@ ProcXFixesGetCursorName (ClientPtr client)
     CursorPtr			pCursor;
     xXFixesGetCursorNameReply	reply;
     REQUEST(xXFixesGetCursorNameReq);
-    char *str;
+    const char *str;
     int len;
 
     REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityReadAccess);
+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixReadAccess);
     if (pCursor->name)
 	str = NameForAtom (pCursor->name);
     else
@@ -413,16 +406,14 @@ ProcXFixesGetCursorName (ClientPtr client)
     reply.sequenceNumber = client->sequence;
     reply.atom = pCursor->name;
     reply.nbytes = len;
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply.sequenceNumber, n);
-	swapl (&reply.length, n);
-	swapl (&reply.atom, n);
-	swaps (&reply.nbytes, n);
+    if (client->swapped) {
+	swaps(&reply.sequenceNumber);
+	swapl(&reply.length);
+	swapl(&reply.atom);
+	swaps(&reply.nbytes);
     }
     WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
-    (void)WriteToClient(client, len, str);
+    WriteToClient(client, len, str);
     
     return(client->noClientException);
 }
@@ -430,12 +421,11 @@ ProcXFixesGetCursorName (ClientPtr client)
 int
 SProcXFixesGetCursorName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetCursorNameReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    swapl (&stuff->cursor, n);
+    swapl(&stuff->cursor);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -447,7 +437,7 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     CursorPtr			pCursor;
     CARD32			*image;
     int				npixels;
-    char			*name;
+    const char			*name;
     int				nbytes, nbytesRound;
     int				width, height;
     int				x, y;
@@ -463,7 +453,7 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     name = pCursor->name ? NameForAtom (pCursor->name) : "";
     nbytes = strlen (name);
     nbytesRound = (nbytes + 3) & ~3;
-    rep = xalloc (sizeof (xXFixesGetCursorImageAndNameReply) +
+    rep = malloc (sizeof (xXFixesGetCursorImageAndNameReply) +
 		  npixels * sizeof (CARD32) + nbytesRound);
     if (!rep)
 	return BadAlloc;
@@ -482,36 +472,33 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     rep->nbytes = nbytes;
 
     image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    memcpy ((image + npixels), name, nbytes);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	swapl (&rep->cursorName, n);
-	swaps (&rep->nbytes, n);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    memcpy((image + npixels), name, nbytes);
+    if (client->swapped) {
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->x);
+	swaps(&rep->y);
+	swaps(&rep->width);
+	swaps(&rep->height);
+	swaps(&rep->xhot);
+	swaps(&rep->yhot);
+	swapl(&rep->cursorSerial);
+	swapl(&rep->cursorName);
+	swaps(&rep->nbytes);
+	SwapLongs(image, npixels);
     }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
+    WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
 			 (npixels << 2) + nbytesRound, (char *) rep);
-    xfree (rep);
+    free (rep);
     return client->noClientException;
 }
 
 int
 SProcXFixesGetCursorImageAndName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesGetCursorImageAndNameReq);
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -520,13 +507,13 @@ SProcXFixesGetCursorImageAndName (ClientPtr client)
  * whether it should be replaced with a reference to pCursor.
  */
 
-typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);
+typedef Bool (*TestCursorFunc) (CursorPtr pOld, void * closure);
 
 typedef struct {
     RESTYPE type;
     TestCursorFunc testCursor;
     CursorPtr pNew;
-    pointer closure;
+    void * closure;
 } ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
 
 static const RESTYPE    CursorRestypes[] = {
@@ -536,7 +523,7 @@ static const RESTYPE    CursorRestypes[] = {
 #define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))
 
 static Bool
-ReplaceCursorLookup (pointer value, XID id, pointer closure)
+ReplaceCursorLookup (void * value, XID id, void * closure)
 {
     ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
     WindowPtr		    pWin;
@@ -583,7 +570,7 @@ ReplaceCursorLookup (pointer value, XID id, pointer closure)
 static void
 ReplaceCursor (CursorPtr pCursor,
 	       TestCursorFunc testCursor,
-	       pointer closure)
+	       void * closure)
 {
     int	clientIndex;
     int resIndex;
@@ -612,15 +599,15 @@ ReplaceCursor (CursorPtr pCursor,
 	    LookupClientResourceComplex (clients[clientIndex], 
 					 rcl.type, 
 					 ReplaceCursorLookup,
-					 (pointer) &rcl);
+					 (void *) &rcl);
 	}
     }
     /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
-    WindowHasNewCursor (WindowTable[0]);
+    WindowHasNewCursor (screenInfo.screens[0]->root);
 }
 
 static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
+TestForCursor (CursorPtr pCursor, void * closure)
 {
     return (pCursor == (CursorPtr) closure);
 }
@@ -632,30 +619,30 @@ ProcXFixesChangeCursor (ClientPtr client)
     REQUEST(xXFixesChangeCursorReq);
 
     REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    VERIFY_CURSOR (pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_CURSOR (pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_CURSOR (pSource, stuff->source, client, DixReadAccess);
+    VERIFY_CURSOR (pDestination, stuff->destination, client, DixWriteAccess);
 
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
+    ReplaceCursor (pSource, TestForCursor, (void *) pDestination);
     return (client->noClientException);
 }
 
 int
 SProcXFixesChangeCursor (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesChangeCursorReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
+TestForCursorName (CursorPtr pCursor, void * closure)
 {
-    return (pCursor->name == (Atom) closure);
+    Atom *pName = closure;
+    return (pCursor->name == *pName);
 }
 
 int
@@ -667,29 +654,28 @@ ProcXFixesChangeCursorByName (ClientPtr client)
     REQUEST(xXFixesChangeCursorByNameReq);
 
     REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
-    VERIFY_CURSOR(pSource, stuff->source, client, SecurityReadAccess);
+    VERIFY_CURSOR(pSource, stuff->source, client, DixReadAccess);
     tchar = (char *) &stuff[1];
     name = MakeAtom (tchar, stuff->nbytes, FALSE);
     if (name)
-	ReplaceCursor (pSource, TestForCursorName, (pointer) name);
+	ReplaceCursor (pSource, TestForCursorName, &name);
     return (client->noClientException);
 }
 
 int
 SProcXFixesChangeCursorByName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesChangeCursorByNameReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->nbytes, n);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xXFixesChangeCursorByNameReq);
+    swapl(&stuff->source);
+    swaps(&stuff->nbytes);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
 static int
-CursorFreeClient (pointer data, XID id)
+CursorFreeClient (void * data, XID id)
 {
     CursorEventPtr	old = (CursorEventPtr) data;
     CursorEventPtr	*prev, e;
@@ -699,7 +685,7 @@ CursorFreeClient (pointer data, XID id)
 	if (e == old)
 	{
 	    *prev = e->next;
-	    xfree (e);
+	    free (e);
 	    break;
 	}
     }
@@ -707,7 +693,7 @@ CursorFreeClient (pointer data, XID id)
 }
 
 static int
-CursorFreeWindow (pointer data, XID id)
+CursorFreeWindow (void * data, XID id)
 {
     WindowPtr		pWindow = (WindowPtr) data;
     CursorEventPtr	e, next;
@@ -740,7 +726,7 @@ XFixesCursorInit (void)
 	ScreenPtr	pScreen = screenInfo.screens[i];
 	CursorScreenPtr	cs;
 
-	cs = (CursorScreenPtr) xalloc (sizeof (CursorScreenRec));
+	cs = (CursorScreenPtr) malloc (sizeof (CursorScreenRec));
 	if (!cs)
 	    return FALSE;
 	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c.NX.original b/nx-X11/programs/Xserver/xfixes/cursor.c.NX.original
deleted file mode 100755
index f6895d193..000000000
--- a/nx-X11/programs/Xserver/xfixes/cursor.c.NX.original
+++ /dev/null
@@ -1,754 +0,0 @@
-/*
- * $Id: cursor.c,v 1.6 2005/07/03 07:37:35 daniels Exp $
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-#include "scrnintstr.h"
-#include "cursorstr.h"
-#include "dixevents.h"
-#include "servermd.h"
-#include "inputstr.h"
-#include "windowstr.h"
-
-static RESTYPE		CursorClientType;
-static RESTYPE		CursorWindowType;
-static int		CursorScreenPrivateIndex = -1;
-static int		CursorGeneration;
-static CursorPtr	CursorCurrent;
-
-#define VERIFY_CURSOR(pCursor, cursor, client, access) { \
-    pCursor = (CursorPtr)SecurityLookupIDByType((client), (cursor), \
-					RT_CURSOR, (access)); \
-    if (!pCursor) { \
-	(client)->errorValue = (cursor); \
-	return BadCursor; \
-    } \
-}
-	
-/*
- * There is a global list of windows selecting for cursor events
- */
-
-typedef struct _CursorEvent *CursorEventPtr;
-
-typedef struct _CursorEvent {
-    CursorEventPtr	next;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} CursorEventRec;
-
-static CursorEventPtr	    cursorEvents;
-
-/*
- * Wrap DisplayCursor to catch cursor change events
- */
-
-typedef struct _CursorScreen {
-    DisplayCursorProcPtr	DisplayCursor;
-    CloseScreenProcPtr		CloseScreen;
-} CursorScreenRec, *CursorScreenPtr;
-
-#define GetCursorScreen(s)	((CursorScreenPtr) ((s)->devPrivates[CursorScreenPrivateIndex].ptr))
-#define GetCursorScreenIfSet(s) ((CursorScreenPrivateIndex != -1) ? GetCursorScreen(s) : NULL)
-#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (pointer) (p))
-#define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)
-#define Unwrap(as,s,elt)	((s)->elt = (as)->elt)
-
-static Bool
-CursorDisplayCursor (ScreenPtr pScreen,
-		     CursorPtr pCursor)
-{
-    CursorScreenPtr	cs = GetCursorScreen(pScreen);
-    Bool		ret;
-
-    Unwrap (cs, pScreen, DisplayCursor);
-    ret = (*pScreen->DisplayCursor) (pScreen, pCursor);
-    if (pCursor != CursorCurrent)
-    {
-	CursorEventPtr	e;
-
-	CursorCurrent = pCursor;
-	for (e = cursorEvents; e; e = e->next)
-	{
-	    if ((e->eventMask & XFixesDisplayCursorNotifyMask) &&
-		!e->pClient->clientGone)
-	    {
-		xXFixesCursorNotifyEvent	ev;
-		ev.type = XFixesEventBase + XFixesCursorNotify;
-		ev.subtype = XFixesDisplayCursorNotify;
-		ev.sequenceNumber = e->pClient->sequence;
-		ev.window = e->pWindow->drawable.id;
-		ev.cursorSerial = pCursor->serialNumber;
-		ev.timestamp = currentTime.milliseconds;
-		ev.name = pCursor->name;
-		WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	    }
-	}
-    }
-    Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-    return ret;
-}
-
-static Bool
-CursorCloseScreen (int index, ScreenPtr pScreen)
-{
-    CursorScreenPtr	cs = GetCursorScreen (pScreen);
-    Bool		ret;
-
-    Unwrap (cs, pScreen, CloseScreen);
-    Unwrap (cs, pScreen, DisplayCursor);
-    ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (cs);
-    if (index == 0)
-	CursorScreenPrivateIndex = -1;
-    return ret;
-}
-
-#define CursorAllEvents (XFixesDisplayCursorNotifyMask)
-
-static int
-XFixesSelectCursorInput (ClientPtr	pClient,
-			 WindowPtr	pWindow,
-			 CARD32		eventMask)
-{
-    CursorEventPtr	*prev, e;
-
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (CursorEventPtr) xalloc (sizeof (CursorEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	if (!LookupIDByType(pWindow->drawable.id, CursorWindowType))
-	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectCursorInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectCursorInputReq);
-    WindowPtr	pWin;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
-    if (!pWin)
-        return(BadWindow);
-    if (stuff->eventMask & ~CursorAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectCursorInput (client, pWin, stuff->eventMask);
-}
-
-static int
-GetBit (unsigned char *line, int x)
-{
-    unsigned char   mask;
-    
-    if (screenInfo.bitmapBitOrder == LSBFirst)
-	mask = (1 << (x & 7));
-    else
-	mask = (0x80 >> (x & 7));
-    /* XXX assumes byte order is host byte order */
-    line += (x >> 3);
-    if (*line & mask)
-	return 1;
-    return 0;
-}
-
-int
-SProcXFixesSelectCursorInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectCursorInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->eventMask, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-    
-void
-SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
-			  xXFixesCursorNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->cursorSerial, to->cursorSerial);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->name, to->name);
-}
-
-static void
-CopyCursorToImage (CursorPtr pCursor, CARD32 *image)
-{
-    int width = pCursor->bits->width;
-    int height = pCursor->bits->height;
-    int npixels = width * height;
-    
-#ifdef ARGB_CURSOR
-    if (pCursor->bits->argb)
-	memcpy (image, pCursor->bits->argb, npixels * sizeof (CARD32));
-    else
-#endif
-    {
-	unsigned char	*srcLine = pCursor->bits->source;
-	unsigned char	*mskLine = pCursor->bits->mask;
-	int		stride = BitmapBytePad (width);
-	int		x, y;
-	CARD32		fg, bg;
-	
-	fg = (0xff000000 | 
-	      ((pCursor->foreRed & 0xff00) << 8) |
-	      (pCursor->foreGreen & 0xff00) |
-	      (pCursor->foreBlue >> 8));
-	bg = (0xff000000 | 
-	      ((pCursor->backRed & 0xff00) << 8) |
-	      (pCursor->backGreen & 0xff00) |
-	      (pCursor->backBlue >> 8));
-	for (y = 0; y < height; y++)
-	{
-	    for (x = 0; x < width; x++)
-	    {
-		if (GetBit (mskLine, x))
-		{
-		    if (GetBit (srcLine, x))
-			*image++ = fg;
-		    else
-			*image++ = bg;
-		}
-		else
-		    *image++ = 0;
-	    }
-	    srcLine += stride;
-	    mskLine += stride;
-	}
-    }
-}
-
-int
-ProcXFixesGetCursorImage (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageReq); */
-    xXFixesGetCursorImageReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels;
-    int				width, height;
-    int				x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq);
-    pCursor = CursorCurrent;
-    if (!pCursor)
-	return BadCursor;
-    GetSpritePosition (&x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    rep = xalloc (sizeof (xXFixesGetCursorImageReply) +
-		  npixels * sizeof (CARD32));
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels;
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	SwapLongs (image, npixels);
-    }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
-			 (npixels << 2), (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImage (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesSetCursorName (ClientPtr client)
-{
-    CursorPtr pCursor;
-    char *tchar;
-    REQUEST(xXFixesSetCursorNameReq);
-    Atom atom;
-
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityWriteAccess);
-    tchar = (char *) &stuff[1];
-    atom = MakeAtom (tchar, stuff->nbytes, TRUE);
-    if (atom == BAD_RESOURCE)
-	return BadAlloc;
-    
-    pCursor->name = atom;
-    return(client->noClientException);
-}
-
-int
-SProcXFixesSetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesSetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorName (ClientPtr client)
-{
-    CursorPtr			pCursor;
-    xXFixesGetCursorNameReply	reply;
-    REQUEST(xXFixesGetCursorNameReq);
-    char *str;
-    int len;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityReadAccess);
-    if (pCursor->name)
-	str = NameForAtom (pCursor->name);
-    else
-	str = "";
-    len = strlen (str);
-    
-    reply.type = X_Reply;
-    reply.length = (len + 3) >> 2;
-    reply.sequenceNumber = client->sequence;
-    reply.atom = pCursor->name;
-    reply.nbytes = len;
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply.sequenceNumber, n);
-	swapl (&reply.length, n);
-	swapl (&reply.atom, n);
-	swaps (&reply.nbytes, n);
-    }
-    WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
-    (void)WriteToClient(client, len, str);
-    
-    return(client->noClientException);
-}
-
-int
-SProcXFixesGetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesSetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageAndNameReq); */
-    xXFixesGetCursorImageAndNameReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels;
-    char			*name;
-    int				nbytes, nbytesRound;
-    int				width, height;
-    int				x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageAndNameReq);
-    pCursor = CursorCurrent;
-    if (!pCursor)
-	return BadCursor;
-    GetSpritePosition (&x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    name = pCursor->name ? NameForAtom (pCursor->name) : "";
-    nbytes = strlen (name);
-    nbytesRound = (nbytes + 3) & ~3;
-    rep = xalloc (sizeof (xXFixesGetCursorImageAndNameReply) +
-		  npixels * sizeof (CARD32) + nbytesRound);
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels + (nbytesRound >> 2);
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-    rep->cursorName = pCursor->name;
-    rep->nbytes = nbytes;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    memcpy ((image + npixels), name, nbytes);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	swapl (&rep->cursorName, n);
-	swaps (&rep->nbytes, n);
-	SwapLongs (image, npixels);
-    }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
-			 (npixels << 2) + nbytesRound, (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageAndNameReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-/*
- * Find every cursor reference in the system, ask testCursor
- * whether it should be replaced with a reference to pCursor.
- */
-
-typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);
-
-typedef struct {
-    RESTYPE type;
-    TestCursorFunc testCursor;
-    CursorPtr pNew;
-    pointer closure;
-} ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
-
-static const RESTYPE    CursorRestypes[] = {
-    RT_WINDOW, RT_PASSIVEGRAB, RT_CURSOR
-};
-
-#define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))
-
-static Bool
-ReplaceCursorLookup (pointer value, XID id, pointer closure)
-{
-    ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
-    WindowPtr		    pWin;
-    GrabPtr		    pGrab;
-    CursorPtr		    pCursor = 0, *pCursorRef = 0;
-    XID			    cursor = 0;
-
-    switch (rcl->type) {
-    case RT_WINDOW:
-	pWin = (WindowPtr) value;
-	if (pWin->optional)
-	{
-	    pCursorRef = &pWin->optional->cursor;
-	    pCursor = *pCursorRef;
-	}
-	break;
-    case RT_PASSIVEGRAB:
-	pGrab = (GrabPtr) value;
-	pCursorRef = &pGrab->cursor;
-	pCursor = *pCursorRef;
-	break;
-    case RT_CURSOR:
-	pCursorRef = 0;
-	pCursor = (CursorPtr) value;
-	cursor = id;
-	break;
-    }
-    if (pCursor && pCursor != rcl->pNew)
-    {
-	if ((*rcl->testCursor) (pCursor, rcl->closure))
-	{
-	    rcl->pNew->refcnt++;
-	    /* either redirect reference or update resource database */
-	    if (pCursorRef)
-		*pCursorRef = rcl->pNew;
-	    else
-		ChangeResourceValue (id, RT_CURSOR, rcl->pNew);
-	    FreeCursor (pCursor, cursor);
-	}
-    }
-    return FALSE;   /* keep walking */
-}
-
-static void
-ReplaceCursor (CursorPtr pCursor,
-	       TestCursorFunc testCursor,
-	       pointer closure)
-{
-    int	clientIndex;
-    int resIndex;
-    ReplaceCursorLookupRec  rcl;
-    
-    /* 
-     * Cursors exist only in the resource database, windows and grabs.
-     * All of these are always pointed at by the resource database.  Walk
-     * the whole thing looking for cursors
-     */
-    rcl.testCursor = testCursor;
-    rcl.pNew = pCursor;
-    rcl.closure = closure;
-
-    /* for each client */
-    for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++)
-    {
-	if (!clients[clientIndex])
-	    continue;
-	for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++)
-	{
-	    rcl.type = CursorRestypes[resIndex];
-	    /*
-	     * This function walks the entire client resource database
-	     */
-	    LookupClientResourceComplex (clients[clientIndex], 
-					 rcl.type, 
-					 ReplaceCursorLookup,
-					 (pointer) &rcl);
-	}
-    }
-    /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
-    WindowHasNewCursor (WindowTable[0]);
-}
-
-static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
-{
-    return (pCursor == (CursorPtr) closure);
-}
-
-int
-ProcXFixesChangeCursor (ClientPtr client)
-{
-    CursorPtr	pSource, pDestination;
-    REQUEST(xXFixesChangeCursorReq);
-
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    VERIFY_CURSOR (pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_CURSOR (pDestination, stuff->destination, client, SecurityWriteAccess);
-
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursor (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
-{
-    return (pCursor->name == (Atom) closure);
-}
-
-int
-ProcXFixesChangeCursorByName (ClientPtr client)
-{
-    CursorPtr	pSource;
-    Atom	name;
-    char	*tchar;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
-    VERIFY_CURSOR(pSource, stuff->source, client, SecurityReadAccess);
-    tchar = (char *) &stuff[1];
-    name = MakeAtom (tchar, stuff->nbytes, FALSE);
-    if (name)
-	ReplaceCursor (pSource, TestForCursorName, (pointer) name);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursorByName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static int
-CursorFreeClient (pointer data, XID id)
-{
-    CursorEventPtr	old = (CursorEventPtr) data;
-    CursorEventPtr	*prev, e;
-    
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-CursorFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    CursorEventPtr	e, next;
-
-    for (e = cursorEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-Bool
-XFixesCursorInit (void)
-{
-    int	i;
-    
-    if (CursorGeneration != serverGeneration)
-    {
-	CursorScreenPrivateIndex = AllocateScreenPrivateIndex ();
-	if (CursorScreenPrivateIndex < 0)
-	    return FALSE;
-	CursorGeneration = serverGeneration;
-    }
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ScreenPtr	pScreen = screenInfo.screens[i];
-	CursorScreenPtr	cs;
-
-	cs = (CursorScreenPtr) xalloc (sizeof (CursorScreenRec));
-	if (!cs)
-	    return FALSE;
-	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
-	Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-	SetCursorScreen (pScreen, cs);
-    }
-    CursorClientType = CreateNewResourceType(CursorFreeClient);
-    CursorWindowType = CreateNewResourceType(CursorFreeWindow);
-    return CursorClientType && CursorWindowType;
-}
-
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c.X.original b/nx-X11/programs/Xserver/xfixes/cursor.c.X.original
deleted file mode 100755
index bcc1ab962..000000000
--- a/nx-X11/programs/Xserver/xfixes/cursor.c.X.original
+++ /dev/null
@@ -1,753 +0,0 @@
-/*
- * $Id: cursor.c,v 1.6 2005/07/03 07:37:35 daniels Exp $
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-#include "scrnintstr.h"
-#include "cursorstr.h"
-#include "dixevents.h"
-#include "servermd.h"
-#include "inputstr.h"
-#include "windowstr.h"
-
-static RESTYPE		CursorClientType;
-static RESTYPE		CursorWindowType;
-static int		CursorScreenPrivateIndex = -1;
-static int		CursorGeneration;
-static CursorPtr	CursorCurrent;
-
-#define VERIFY_CURSOR(pCursor, cursor, client, access) { \
-    pCursor = (CursorPtr)SecurityLookupIDByType((client), (cursor), \
-					RT_CURSOR, (access)); \
-    if (!pCursor) { \
-	(client)->errorValue = (cursor); \
-	return BadCursor; \
-    } \
-}
-	
-/*
- * There is a global list of windows selecting for cursor events
- */
-
-typedef struct _CursorEvent *CursorEventPtr;
-
-typedef struct _CursorEvent {
-    CursorEventPtr	next;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} CursorEventRec;
-
-static CursorEventPtr	    cursorEvents;
-
-/*
- * Wrap DisplayCursor to catch cursor change events
- */
-
-typedef struct _CursorScreen {
-    DisplayCursorProcPtr	DisplayCursor;
-    CloseScreenProcPtr		CloseScreen;
-} CursorScreenRec, *CursorScreenPtr;
-
-#define GetCursorScreen(s)	((CursorScreenPtr) ((s)->devPrivates[CursorScreenPrivateIndex].ptr))
-#define GetCursorScreenIfSet(s) ((CursorScreenPrivateIndex != -1) ? GetCursorScreen(s) : NULL)
-#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (pointer) (p))
-#define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)
-#define Unwrap(as,s,elt)	((s)->elt = (as)->elt)
-
-static Bool
-CursorDisplayCursor (ScreenPtr pScreen,
-		     CursorPtr pCursor)
-{
-    CursorScreenPtr	cs = GetCursorScreen(pScreen);
-    Bool		ret;
-
-    Unwrap (cs, pScreen, DisplayCursor);
-    ret = (*pScreen->DisplayCursor) (pScreen, pCursor);
-    if (pCursor != CursorCurrent)
-    {
-	CursorEventPtr	e;
-
-	CursorCurrent = pCursor;
-	for (e = cursorEvents; e; e = e->next)
-	{
-	    if (e->eventMask & XFixesDisplayCursorNotifyMask)
-	    {
-		xXFixesCursorNotifyEvent	ev;
-		ev.type = XFixesEventBase + XFixesCursorNotify;
-		ev.subtype = XFixesDisplayCursorNotify;
-		ev.sequenceNumber = e->pClient->sequence;
-		ev.window = e->pWindow->drawable.id;
-		ev.cursorSerial = pCursor->serialNumber;
-		ev.timestamp = currentTime.milliseconds;
-		ev.name = pCursor->name;
-		WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	    }
-	}
-    }
-    Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-    return ret;
-}
-
-static Bool
-CursorCloseScreen (int index, ScreenPtr pScreen)
-{
-    CursorScreenPtr	cs = GetCursorScreen (pScreen);
-    Bool		ret;
-
-    Unwrap (cs, pScreen, CloseScreen);
-    Unwrap (cs, pScreen, DisplayCursor);
-    ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (cs);
-    if (index == 0)
-	CursorScreenPrivateIndex = -1;
-    return ret;
-}
-
-#define CursorAllEvents (XFixesDisplayCursorNotifyMask)
-
-static int
-XFixesSelectCursorInput (ClientPtr	pClient,
-			 WindowPtr	pWindow,
-			 CARD32		eventMask)
-{
-    CursorEventPtr	*prev, e;
-
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (CursorEventPtr) xalloc (sizeof (CursorEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	if (!LookupIDByType(pWindow->drawable.id, CursorWindowType))
-	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectCursorInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectCursorInputReq);
-    WindowPtr	pWin;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
-    if (!pWin)
-        return(BadWindow);
-    if (stuff->eventMask & ~CursorAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectCursorInput (client, pWin, stuff->eventMask);
-}
-
-static int
-GetBit (unsigned char *line, int x)
-{
-    unsigned char   mask;
-    
-    if (screenInfo.bitmapBitOrder == LSBFirst)
-	mask = (1 << (x & 7));
-    else
-	mask = (0x80 >> (x & 7));
-    /* XXX assumes byte order is host byte order */
-    line += (x >> 3);
-    if (*line & mask)
-	return 1;
-    return 0;
-}
-
-int
-SProcXFixesSelectCursorInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectCursorInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->eventMask, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-    
-void
-SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
-			  xXFixesCursorNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->cursorSerial, to->cursorSerial);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->name, to->name);
-}
-
-static void
-CopyCursorToImage (CursorPtr pCursor, CARD32 *image)
-{
-    int width = pCursor->bits->width;
-    int height = pCursor->bits->height;
-    int npixels = width * height;
-    
-#ifdef ARGB_CURSOR
-    if (pCursor->bits->argb)
-	memcpy (image, pCursor->bits->argb, npixels * sizeof (CARD32));
-    else
-#endif
-    {
-	unsigned char	*srcLine = pCursor->bits->source;
-	unsigned char	*mskLine = pCursor->bits->mask;
-	int		stride = BitmapBytePad (width);
-	int		x, y;
-	CARD32		fg, bg;
-	
-	fg = (0xff000000 | 
-	      ((pCursor->foreRed & 0xff00) << 8) |
-	      (pCursor->foreGreen & 0xff00) |
-	      (pCursor->foreBlue >> 8));
-	bg = (0xff000000 | 
-	      ((pCursor->backRed & 0xff00) << 8) |
-	      (pCursor->backGreen & 0xff00) |
-	      (pCursor->backBlue >> 8));
-	for (y = 0; y < height; y++)
-	{
-	    for (x = 0; x < width; x++)
-	    {
-		if (GetBit (mskLine, x))
-		{
-		    if (GetBit (srcLine, x))
-			*image++ = fg;
-		    else
-			*image++ = bg;
-		}
-		else
-		    *image++ = 0;
-	    }
-	    srcLine += stride;
-	    mskLine += stride;
-	}
-    }
-}
-
-int
-ProcXFixesGetCursorImage (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageReq); */
-    xXFixesGetCursorImageReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels;
-    int				width, height;
-    int				x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq);
-    pCursor = CursorCurrent;
-    if (!pCursor)
-	return BadCursor;
-    GetSpritePosition (&x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    rep = xalloc (sizeof (xXFixesGetCursorImageReply) +
-		  npixels * sizeof (CARD32));
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels;
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	SwapLongs (image, npixels);
-    }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
-			 (npixels << 2), (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImage (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesSetCursorName (ClientPtr client)
-{
-    CursorPtr pCursor;
-    char *tchar;
-    REQUEST(xXFixesSetCursorNameReq);
-    Atom atom;
-
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityWriteAccess);
-    tchar = (char *) &stuff[1];
-    atom = MakeAtom (tchar, stuff->nbytes, TRUE);
-    if (atom == BAD_RESOURCE)
-	return BadAlloc;
-    
-    pCursor->name = atom;
-    return(client->noClientException);
-}
-
-int
-SProcXFixesSetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesSetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorName (ClientPtr client)
-{
-    CursorPtr			pCursor;
-    xXFixesGetCursorNameReply	reply;
-    REQUEST(xXFixesGetCursorNameReq);
-    char *str;
-    int len;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityReadAccess);
-    if (pCursor->name)
-	str = NameForAtom (pCursor->name);
-    else
-	str = "";
-    len = strlen (str);
-    
-    reply.type = X_Reply;
-    reply.length = (len + 3) >> 2;
-    reply.sequenceNumber = client->sequence;
-    reply.atom = pCursor->name;
-    reply.nbytes = len;
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply.sequenceNumber, n);
-	swapl (&reply.length, n);
-	swapl (&reply.atom, n);
-	swaps (&reply.nbytes, n);
-    }
-    WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
-    (void)WriteToClient(client, len, str);
-    
-    return(client->noClientException);
-}
-
-int
-SProcXFixesGetCursorName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesSetCursorNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-int
-ProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-/*    REQUEST(xXFixesGetCursorImageAndNameReq); */
-    xXFixesGetCursorImageAndNameReply	*rep;
-    CursorPtr			pCursor;
-    CARD32			*image;
-    int				npixels;
-    char			*name;
-    int				nbytes, nbytesRound;
-    int				width, height;
-    int				x, y;
-
-    REQUEST_SIZE_MATCH(xXFixesGetCursorImageAndNameReq);
-    pCursor = CursorCurrent;
-    if (!pCursor)
-	return BadCursor;
-    GetSpritePosition (&x, &y);
-    width = pCursor->bits->width;
-    height = pCursor->bits->height;
-    npixels = width * height;
-    name = pCursor->name ? NameForAtom (pCursor->name) : "";
-    nbytes = strlen (name);
-    nbytesRound = (nbytes + 3) & ~3;
-    rep = xalloc (sizeof (xXFixesGetCursorImageAndNameReply) +
-		  npixels * sizeof (CARD32) + nbytesRound);
-    if (!rep)
-	return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels + (nbytesRound >> 2);
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot; 
-    rep->cursorSerial = pCursor->serialNumber;
-    rep->cursorName = pCursor->name;
-    rep->nbytes = nbytes;
-
-    image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    memcpy ((image + npixels), name, nbytes);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	swapl (&rep->cursorName, n);
-	swaps (&rep->nbytes, n);
-	SwapLongs (image, npixels);
-    }
-    (void) WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
-			 (npixels << 2) + nbytesRound, (char *) rep);
-    xfree (rep);
-    return client->noClientException;
-}
-
-int
-SProcXFixesGetCursorImageAndName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesGetCursorImageAndNameReq);
-    swaps (&stuff->length, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-/*
- * Find every cursor reference in the system, ask testCursor
- * whether it should be replaced with a reference to pCursor.
- */
-
-typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);
-
-typedef struct {
-    RESTYPE type;
-    TestCursorFunc testCursor;
-    CursorPtr pNew;
-    pointer closure;
-} ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
-
-static const RESTYPE    CursorRestypes[] = {
-    RT_WINDOW, RT_PASSIVEGRAB, RT_CURSOR
-};
-
-#define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))
-
-static Bool
-ReplaceCursorLookup (pointer value, XID id, pointer closure)
-{
-    ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
-    WindowPtr		    pWin;
-    GrabPtr		    pGrab;
-    CursorPtr		    pCursor = 0, *pCursorRef = 0;
-    XID			    cursor = 0;
-
-    switch (rcl->type) {
-    case RT_WINDOW:
-	pWin = (WindowPtr) value;
-	if (pWin->optional)
-	{
-	    pCursorRef = &pWin->optional->cursor;
-	    pCursor = *pCursorRef;
-	}
-	break;
-    case RT_PASSIVEGRAB:
-	pGrab = (GrabPtr) value;
-	pCursorRef = &pGrab->cursor;
-	pCursor = *pCursorRef;
-	break;
-    case RT_CURSOR:
-	pCursorRef = 0;
-	pCursor = (CursorPtr) value;
-	cursor = id;
-	break;
-    }
-    if (pCursor && pCursor != rcl->pNew)
-    {
-	if ((*rcl->testCursor) (pCursor, rcl->closure))
-	{
-	    rcl->pNew->refcnt++;
-	    /* either redirect reference or update resource database */
-	    if (pCursorRef)
-		*pCursorRef = rcl->pNew;
-	    else
-		ChangeResourceValue (id, RT_CURSOR, rcl->pNew);
-	    FreeCursor (pCursor, cursor);
-	}
-    }
-    return FALSE;   /* keep walking */
-}
-
-static void
-ReplaceCursor (CursorPtr pCursor,
-	       TestCursorFunc testCursor,
-	       pointer closure)
-{
-    int	clientIndex;
-    int resIndex;
-    ReplaceCursorLookupRec  rcl;
-    
-    /* 
-     * Cursors exist only in the resource database, windows and grabs.
-     * All of these are always pointed at by the resource database.  Walk
-     * the whole thing looking for cursors
-     */
-    rcl.testCursor = testCursor;
-    rcl.pNew = pCursor;
-    rcl.closure = closure;
-
-    /* for each client */
-    for (clientIndex = 0; clientIndex < currentMaxClients; clientIndex++)
-    {
-	if (!clients[clientIndex])
-	    continue;
-	for (resIndex = 0; resIndex < NUM_CURSOR_RESTYPES; resIndex++)
-	{
-	    rcl.type = CursorRestypes[resIndex];
-	    /*
-	     * This function walks the entire client resource database
-	     */
-	    LookupClientResourceComplex (clients[clientIndex], 
-					 rcl.type, 
-					 ReplaceCursorLookup,
-					 (pointer) &rcl);
-	}
-    }
-    /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
-    WindowHasNewCursor (WindowTable[0]);
-}
-
-static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
-{
-    return (pCursor == (CursorPtr) closure);
-}
-
-int
-ProcXFixesChangeCursor (ClientPtr client)
-{
-    CursorPtr	pSource, pDestination;
-    REQUEST(xXFixesChangeCursorReq);
-
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    VERIFY_CURSOR (pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_CURSOR (pDestination, stuff->destination, client, SecurityWriteAccess);
-
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursor (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
-{
-    return (pCursor->name == (Atom) closure);
-}
-
-int
-ProcXFixesChangeCursorByName (ClientPtr client)
-{
-    CursorPtr	pSource;
-    Atom	name;
-    char	*tchar;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
-    VERIFY_CURSOR(pSource, stuff->source, client, SecurityReadAccess);
-    tchar = (char *) &stuff[1];
-    name = MakeAtom (tchar, stuff->nbytes, FALSE);
-    if (name)
-	ReplaceCursor (pSource, TestForCursorName, (pointer) name);
-    return (client->noClientException);
-}
-
-int
-SProcXFixesChangeCursorByName (ClientPtr client)
-{
-    int n;
-    REQUEST(xXFixesChangeCursorByNameReq);
-
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->nbytes, n);
-    return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
-}
-
-static int
-CursorFreeClient (pointer data, XID id)
-{
-    CursorEventPtr	old = (CursorEventPtr) data;
-    CursorEventPtr	*prev, e;
-    
-    for (prev = &cursorEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-CursorFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    CursorEventPtr	e, next;
-
-    for (e = cursorEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-Bool
-XFixesCursorInit (void)
-{
-    int	i;
-    
-    if (CursorGeneration != serverGeneration)
-    {
-	CursorScreenPrivateIndex = AllocateScreenPrivateIndex ();
-	if (CursorScreenPrivateIndex < 0)
-	    return FALSE;
-	CursorGeneration = serverGeneration;
-    }
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	ScreenPtr	pScreen = screenInfo.screens[i];
-	CursorScreenPtr	cs;
-
-	cs = (CursorScreenPtr) xalloc (sizeof (CursorScreenRec));
-	if (!cs)
-	    return FALSE;
-	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
-	Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
-	SetCursorScreen (pScreen, cs);
-    }
-    CursorClientType = CreateNewResourceType(CursorFreeClient);
-    CursorWindowType = CreateNewResourceType(CursorFreeWindow);
-    return CursorClientType && CursorWindowType;
-}
-
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index 9ceff6d51..18b1d3ff4 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -39,24 +39,24 @@ extern int RenderErrBase;
 RESTYPE	    RegionResType;
 
 static int
-RegionResFree (pointer data, XID id)
+RegionResFree (void * data, XID id)
 {
     RegionPtr    pRegion = (RegionPtr) data;
 
-    REGION_DESTROY (0, pRegion);
+    RegionDestroy(pRegion);
     return Success;
 }
 
 RegionPtr
 XFixesRegionCopy (RegionPtr pRegion)
 {
-    RegionPtr   pNew = REGION_CREATE (0, REGION_EXTENTS(0, pRegion),
-				      REGION_NUM_RECTS(pRegion));
+    RegionPtr   pNew = RegionCreate(RegionExtents(pRegion),
+				      RegionNumRects(pRegion));
     if (!pNew)
 	return 0;
-    if (!REGION_COPY (0, pNew, pRegion))
+    if (!RegionCopy(pNew, pRegion))
     {
-	REGION_DESTROY (0, pNew);
+	RegionDestroy(pNew);
 	return 0;
     }
     return pNew;
@@ -84,10 +84,10 @@ ProcXFixesCreateRegion (ClientPtr client)
 	return BadLength;
     things >>= 3;
 
-    pRegion = RECTS_TO_REGION(0, things, (xRectangle *) (stuff + 1), CT_UNSORTED);
+    pRegion = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
     if (!pRegion)
 	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -96,12 +96,11 @@ ProcXFixesCreateRegion (ClientPtr client)
 int
 SProcXFixesCreateRegion (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesCreateRegionReq);
-    
-    swaps(&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
-    swapl(&stuff->region, n);
+    swapl(&stuff->region);
     SwapRestS(stuff);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
@@ -118,7 +117,7 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
 
     pPixmap = (PixmapPtr) SecurityLookupIDByType (client, stuff->bitmap,
 						  RT_PIXMAP,
-						  SecurityReadAccess);
+						  DixReadAccess);
     if (!pPixmap)
     {
 	client->errorValue = stuff->bitmap;
@@ -127,12 +126,12 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
     if (pPixmap->drawable.depth != 1)
 	return BadMatch;
 
-    pRegion = BITMAP_TO_REGION(pPixmap->drawable.pScreen, pPixmap);
+    pRegion = BitmapToRegion(pPixmap->drawable.pScreen, pPixmap);
 
     if (!pRegion)
 	return BadAlloc;
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -141,13 +140,12 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
 int
 SProcXFixesCreateRegionFromBitmap (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromBitmapReq);
+    REQUEST(xXFixesCreateRegionFromBitmapReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->bitmap, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq);
+    swapl(&stuff->region);
+    swapl(&stuff->bitmap);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -196,7 +194,7 @@ ProcXFixesCreateRegionFromWindow (ClientPtr client)
 	pRegion = XFixesRegionCopy (pRegion);
     if (!pRegion)
 	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -205,13 +203,12 @@ ProcXFixesCreateRegionFromWindow (ClientPtr client)
 int
 SProcXFixesCreateRegionFromWindow (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromWindowReq);
+    REQUEST(xXFixesCreateRegionFromWindowReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq);
+    swapl(&stuff->region);
+    swapl(&stuff->window);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -225,11 +222,11 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
     REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
     LEGAL_NEW_RESOURCE (stuff->region, client);
 
-    SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityReadAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixReadAccess);
     
     switch (pGC->clientClipType) {
     case CT_PIXMAP:
-	pRegion = BITMAP_TO_REGION(pGC->pScreen, (PixmapPtr) pGC->clientClip);
+	pRegion = BitmapToRegion(pGC->pScreen, (PixmapPtr) pGC->clientClip);
 	if (!pRegion)
 	    return BadAlloc;
 	break;
@@ -243,7 +240,7 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
 	return BadImplementation;   /* assume sane server bits */
     }
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -252,13 +249,12 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
 int
 SProcXFixesCreateRegionFromGC (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromGCReq);
+    REQUEST(xXFixesCreateRegionFromGCReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->gc, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq);
+    swapl(&stuff->region);
+    swapl(&stuff->gc);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -273,12 +269,12 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
     REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
     LEGAL_NEW_RESOURCE (stuff->region, client);
 
-    VERIFY_PICTURE(pPicture, stuff->picture, client, SecurityReadAccess,
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixReadAccess,
 		   RenderErrBase + BadPicture);
     
     switch (pPicture->clientClipType) {
     case CT_PIXMAP:
-	pRegion = BITMAP_TO_REGION(pPicture->pDrawable->pScreen,
+	pRegion = BitmapToRegion(pPicture->pDrawable->pScreen,
 				   (PixmapPtr) pPicture->clientClip);
 	if (!pRegion)
 	    return BadAlloc;
@@ -292,7 +288,7 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
 	return BadImplementation;   /* assume sane server bits */
     }
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -304,13 +300,12 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
 int
 SProcXFixesCreateRegionFromPicture (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromPictureReq);
+    REQUEST(xXFixesCreateRegionFromPictureReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->picture, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq);
+    swapl(&stuff->region);
+    swapl(&stuff->picture);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -321,7 +316,7 @@ ProcXFixesDestroyRegion (ClientPtr client)
     RegionPtr	pRegion;
 
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
     FreeResource (stuff->region, RT_NONE);
     return(client->noClientException);
 }
@@ -329,12 +324,11 @@ ProcXFixesDestroyRegion (ClientPtr client)
 int
 SProcXFixesDestroyRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesDestroyRegionReq);
+    REQUEST(xXFixesDestroyRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -346,34 +340,33 @@ ProcXFixesSetRegion (ClientPtr client)
     REQUEST (xXFixesSetRegionReq);
 
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
     
     things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
     if (things & 4)
 	return BadLength;
     things >>= 3;
 
-    pNew = RECTS_TO_REGION(0, things, (xRectangle *) (stuff + 1), CT_UNSORTED);
+    pNew = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
     if (!pNew)
 	return BadAlloc;
-    if (!REGION_COPY (0, pRegion, pNew))
+    if (!RegionCopy(pRegion, pNew))
     {
-	REGION_DESTROY (0, pNew);
+	RegionDestroy(pNew);
 	return BadAlloc;
     }
-    REGION_DESTROY (0, pNew);
+    RegionDestroy(pNew);
     return(client->noClientException);
 }
 
 int
 SProcXFixesSetRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesSetRegionReq);
+    REQUEST(xXFixesSetRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     SwapRestS(stuff);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
@@ -384,10 +377,10 @@ ProcXFixesCopyRegion (ClientPtr client)
     RegionPtr	pSource, pDestination;
     REQUEST (xXFixesCopyRegionReq);
     
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
-    if (!REGION_COPY(pScreen, pDestination, pSource))
+    if (!RegionCopy(pDestination, pSource))
 	return BadAlloc;
 
     return(client->noClientException);
@@ -396,13 +389,12 @@ ProcXFixesCopyRegion (ClientPtr client)
 int
 SProcXFixesCopyRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCopyRegionReq);
+    REQUEST(xXFixesCopyRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCopyRegionReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -414,21 +406,21 @@ ProcXFixesCombineRegion (ClientPtr client)
     REQUEST (xXFixesCombineRegionReq);
 
     REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
-    VERIFY_REGION(pSource1, stuff->source1, client, SecurityReadAccess);
-    VERIFY_REGION(pSource2, stuff->source2, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess);
+    VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
     switch (stuff->xfixesReqType) {
     case X_XFixesUnionRegion:
-	if (!REGION_UNION (0, pDestination, pSource1, pSource2))
+	if (!RegionUnion(pDestination, pSource1, pSource2))
 	    ret = BadAlloc;
 	break;
     case X_XFixesIntersectRegion:
-	if (!REGION_INTERSECT (0, pDestination, pSource1, pSource2))
+	if (!RegionIntersect(pDestination, pSource1, pSource2))
 	    ret = BadAlloc;
 	break;
     case X_XFixesSubtractRegion:
-	if (!REGION_SUBTRACT (0, pDestination, pSource1, pSource2))
+	if (!RegionSubtract(pDestination, pSource1, pSource2))
 	    ret = BadAlloc;
 	break;
     }
@@ -441,14 +433,13 @@ ProcXFixesCombineRegion (ClientPtr client)
 int
 SProcXFixesCombineRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCombineRegionReq);
+    REQUEST(xXFixesCombineRegionReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
-    swapl (&stuff->source1, n);
-    swapl (&stuff->source2, n);
-    swapl (&stuff->destination, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCombineRegionReq);
+    swapl(&stuff->source1);
+    swapl(&stuff->source2);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -461,8 +452,8 @@ ProcXFixesInvertRegion (ClientPtr client)
     REQUEST(xXFixesInvertRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
 
     /* Compute bounds, limit to 16 bits */
     bounds.x1 = stuff->x;
@@ -477,7 +468,7 @@ ProcXFixesInvertRegion (ClientPtr client)
     else
 	bounds.y2 = stuff->y + stuff->height;
 
-    if (!REGION_INVERSE(0, pDestination, pSource, &bounds))
+    if (!RegionInverse(pDestination, pSource, &bounds))
 	ret = BadAlloc;
 
     if (ret == Success)
@@ -488,17 +479,16 @@ ProcXFixesInvertRegion (ClientPtr client)
 int
 SProcXFixesInvertRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesInvertRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->x, n);
-    swaps (&stuff->y, n);
-    swaps (&stuff->width, n);
-    swaps (&stuff->height, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -509,23 +499,22 @@ ProcXFixesTranslateRegion (ClientPtr client)
     REQUEST(xXFixesTranslateRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
 
-    REGION_TRANSLATE(pScreen, pRegion, stuff->dx, stuff->dy);
+    RegionTranslate(pRegion, stuff->dx, stuff->dy);
     return (client->noClientException);
 }
 
 int
 SProcXFixesTranslateRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesTranslateRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
-    swapl (&stuff->region, n);
-    swaps (&stuff->dx, n);
-    swaps (&stuff->dy, n);
+    swapl(&stuff->region);
+    swaps(&stuff->dx);
+    swaps(&stuff->dy);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -536,10 +525,10 @@ ProcXFixesRegionExtents (ClientPtr client)
     REQUEST(xXFixesRegionExtentsReq);
 
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
 
-    REGION_RESET (0, pDestination, REGION_EXTENTS (0, pSource));
+    RegionReset(pDestination, RegionExtents(pSource));
 
     return (client->noClientException);
 }
@@ -547,13 +536,12 @@ ProcXFixesRegionExtents (ClientPtr client)
 int
 SProcXFixesRegionExtents (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesRegionExtentsReq);
-    
-    swaps (&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -569,13 +557,13 @@ ProcXFixesFetchRegion (ClientPtr client)
     REQUEST(xXFixesFetchRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityReadAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
 
-    pExtent = REGION_EXTENTS (0, pRegion);
-    pBox = REGION_RECTS (pRegion);
-    nBox = REGION_NUM_RECTS (pRegion);
+    pExtent = RegionExtents(pRegion);
+    pBox = RegionRects (pRegion);
+    nBox = RegionNumRects (pRegion);
     
-    reply = xalloc (sizeof (xXFixesFetchRegionReply) +
+    reply = malloc (sizeof (xXFixesFetchRegionReply) +
 		    nBox * sizeof (xRectangle));
     if (!reply)
 	return BadAlloc;
@@ -595,32 +583,29 @@ ProcXFixesFetchRegion (ClientPtr client)
 	pRect[i].width = pBox[i].x2 - pBox[i].x1;
 	pRect[i].height = pBox[i].y2 - pBox[i].y1;
     }
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply->sequenceNumber, n);
-	swapl (&reply->length, n);
-	swaps (&reply->x, n);
-	swaps (&reply->y, n);
-	swaps (&reply->width, n);
-	swaps (&reply->height, n);
-	SwapShorts ((INT16 *) pRect, nBox * 4);
+    if (client->swapped) {
+	swaps(&reply->sequenceNumber);
+	swapl(&reply->length);
+	swaps(&reply->x);
+	swaps(&reply->y);
+	swaps(&reply->width);
+	swaps(&reply->height);
+	SwapShorts((INT16 *) pRect, nBox * 4);
     }
-    (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
-			 nBox * sizeof (xRectangle), (char *) reply);
-    xfree (reply);
+    WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
+			 nBox * sizeof (xRectangle), reply);
+    free (reply);
     return (client->noClientException);
 }
 
 int
 SProcXFixesFetchRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesFetchRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -633,8 +618,8 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
     REQUEST(xXFixesSetGCClipRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
-    SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityWriteAccess);
-    VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, SecurityReadAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixWriteAccess);
+    VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, DixReadAccess);
 
     if (pRegion)
     {
@@ -646,7 +631,7 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
     vals[0] = stuff->xOrigin;
     vals[1] = stuff->yOrigin;
     DoChangeGC (pGC, GCClipXOrigin|GCClipYOrigin, vals, 0);
-    (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (pointer)pRegion, 0);
+    (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (void *)pRegion, 0);
 
     return (client->noClientException);
 }
@@ -654,15 +639,14 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
 int
 SProcXFixesSetGCClipRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetGCClipRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
-    swapl (&stuff->gc, n);
-    swapl (&stuff->region, n);
-    swaps (&stuff->xOrigin, n);
-    swaps (&stuff->yOrigin, n);
+    swapl(&stuff->gc);
+    swapl(&stuff->region);
+    swaps(&stuff->xOrigin);
+    swaps(&stuff->yOrigin);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -685,7 +669,7 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 	client->errorValue = stuff->dest;
 	return BadWindow;
     }
-    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess);
     pScreen = pWin->drawable.pScreen;
     switch (stuff->destKind) {
     case ShapeBounding:
@@ -716,7 +700,7 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 	    break;
 	}
 	if (stuff->xOff || stuff->yOff)
-	    REGION_TRANSLATE (0, pRegion, stuff->xOff, stuff->yOff);
+	    RegionTranslate(pRegion, stuff->xOff, stuff->yOff);
     }
     else
     {
@@ -739,7 +723,7 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 	    pDestRegion = &pRegion; /* a NULL region pointer */
     }
     if (*pDestRegion)
-	REGION_DESTROY(pScreen, *pDestRegion);
+	RegionDestroy(*pDestRegion);
     *pDestRegion = pRegion;
     (*pScreen->SetShape) (pWin);
     SendShapeNotify (pWin, stuff->destKind);
@@ -752,15 +736,14 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 int
 SProcXFixesSetWindowShapeRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
-    swapl (&stuff->region, n);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -770,16 +753,12 @@ ProcXFixesSetPictureClipRegion (ClientPtr client)
 #ifdef RENDER
     PicturePtr		pPicture;
     RegionPtr		pRegion;
-    ScreenPtr		pScreen;
-    PictureScreenPtr	ps;
     REQUEST(xXFixesSetPictureClipRegionReq);
     
     REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
-    VERIFY_PICTURE(pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess,
 		   RenderErrBase + BadPicture);
-    pScreen = pPicture->pDrawable->pScreen;
-    ps = GetPictureScreen (pScreen);
-    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, SecurityReadAccess);
+    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
     
     return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin,
 				 pRegion);
@@ -791,15 +770,14 @@ ProcXFixesSetPictureClipRegion (ClientPtr client)
 int
 SProcXFixesSetPictureClipRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetPictureClipRegionReq);
-    
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
-    swapl (&stuff->picture, n);
-    swapl (&stuff->region, n);
-    swaps (&stuff->xOrigin, n);
-    swaps (&stuff->yOrigin, n);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
+    swapl(&stuff->picture);
+    swapl(&stuff->region);
+    swaps(&stuff->xOrigin);
+    swaps(&stuff->yOrigin);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -815,14 +793,14 @@ ProcXFixesExpandRegion (ClientPtr client)
     int		i;
 
     REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
-    nBoxes = REGION_NUM_RECTS(pSource);
-    pSrc = REGION_RECTS(pSource);
+    nBoxes = RegionNumRects(pSource);
+    pSrc = RegionRects(pSource);
     if (nBoxes)
     {
-	pTmp = xalloc (nBoxes * sizeof (BoxRec));
+	pTmp = malloc (nBoxes * sizeof (BoxRec));
 	if (!pTmp)
 	    return BadAlloc;
 	for (i = 0; i < nBoxes; i++)
@@ -832,13 +810,14 @@ ProcXFixesExpandRegion (ClientPtr client)
 	    pTmp[i].y1 = pSrc[i].y1 - stuff->top;
 	    pTmp[i].y2 = pSrc[i].y2 + stuff->bottom;
 	}
-	REGION_EMPTY (pScreen, pDestination);
+	RegionEmpty(pDestination);
 	for (i = 0; i < nBoxes; i++)
 	{
 	    RegionRec	r;
-	    REGION_INIT (pScreen, &r, &pTmp[i], 0);
-	    REGION_UNION (pScreen, pDestination, pDestination, &r);
+	    RegionInit(&r, &pTmp[i], 0);
+	    RegionUnion(pDestination, pDestination, &r);
 	}
+	free(pTmp);
     }
     if (ret == Success) 
 	ret = client->noClientException;
@@ -848,17 +827,15 @@ ProcXFixesExpandRegion (ClientPtr client)
 int
 SProcXFixesExpandRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesExpandRegionReq);
+    REQUEST(xXFixesExpandRegionReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
-    swaps (&stuff->left, n);
-    swaps (&stuff->right, n);
-    swaps (&stuff->top, n);
-    swaps (&stuff->bottom, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesExpandRegionReq);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
+    swaps(&stuff->left);
+    swaps(&stuff->right);
+    swaps(&stuff->top);
+    swaps(&stuff->bottom);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
-
diff --git a/nx-X11/programs/Xserver/xfixes/saveset.c b/nx-X11/programs/Xserver/xfixes/saveset.c
index 934651218..0a5b2b8da 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/saveset.c
+++ b/nx-X11/programs/Xserver/xfixes/saveset.c
@@ -38,7 +38,7 @@ ProcXFixesChangeSaveSet(ClientPtr client)
 		  
     REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
@@ -70,10 +70,9 @@ ProcXFixesChangeSaveSet(ClientPtr client)
 int
 SProcXFixesChangeSaveSet(ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesChangeSaveSetReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return ProcXFixesChangeSaveSet(client);
 }
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index c72e19e9a..b21301d1c 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -52,7 +52,7 @@ typedef struct _SelectionEvent {
 static SelectionEventPtr	selectionEvents;
 
 static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
+XFixesSelectionCallback (CallbackListPtr *callbacks, void * data, void * args)
 {
     SelectionEventPtr	e;
     SelectionInfoRec	*info = (SelectionInfoRec *) args;
@@ -79,14 +79,14 @@ XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
     for (e = selectionEvents; e; e = e->next)
     {
 	if (e->selection == selection->selection && 
-	    (e->eventMask & eventMask) &&
-	    !e->pClient->clientGone)
+	    (e->eventMask & eventMask))
 	{
 	    xXFixesSelectionNotifyEvent	ev;
 
+	    memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
+
 	    ev.type = XFixesEventBase + XFixesSelectionNotify;
 	    ev.subtype = subtype;
-	    ev.sequenceNumber = e->pClient->sequence;
 	    ev.window = e->pWindow->drawable.id;
 	    if (subtype == XFixesSetSelectionOwnerNotify)
 		ev.owner = selection->window;
@@ -154,7 +154,7 @@ XFixesSelectSelectionInput (ClientPtr	pClient,
     }
     if (!e)
     {
-	e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
+	e = (SelectionEventPtr) malloc (sizeof (SelectionEventRec));
 	if (!e)
 	    return BadAlloc;
 
@@ -170,13 +170,13 @@ XFixesSelectSelectionInput (ClientPtr	pClient,
 	 */
 	if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType))
 	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
-			      (pointer) pWindow))
+			      (void *) pWindow))
 	    {
-		xfree (e);
+		free (e);
 		return BadAlloc;
 	    }
 
-	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
+	if (!AddResource (e->clientResource, SelectionClientType, (void *) e))
 	    return BadAlloc;
 
 	*prev = e;
@@ -198,7 +198,7 @@ ProcXFixesSelectSelectionInput (ClientPtr client)
 
     REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (stuff->eventMask & ~SelectionAllEvents)
@@ -213,13 +213,13 @@ ProcXFixesSelectSelectionInput (ClientPtr client)
 int
 SProcXFixesSelectSelectionInput (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesSelectSelectionInputReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->eventMask, n);
+    REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->selection);
+    swapl(&stuff->eventMask);
     return ProcXFixesSelectSelectionInput(client);
 }
     
@@ -237,7 +237,7 @@ SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
 }
 
 static int
-SelectionFreeClient (pointer data, XID id)
+SelectionFreeClient (void * data, XID id)
 {
     SelectionEventPtr	old = (SelectionEventPtr) data;
     SelectionEventPtr	*prev, e;
@@ -247,7 +247,7 @@ SelectionFreeClient (pointer data, XID id)
 	if (e == old)
 	{
 	    *prev = e->next;
-	    xfree (e);
+	    free (e);
 	    CheckSelectionCallback ();
 	    break;
 	}
@@ -256,7 +256,7 @@ SelectionFreeClient (pointer data, XID id)
 }
 
 static int
-SelectionFreeWindow (pointer data, XID id)
+SelectionFreeWindow (void * data, XID id)
 {
     WindowPtr		pWindow = (WindowPtr) data;
     SelectionEventPtr	e, next;
diff --git a/nx-X11/programs/Xserver/xfixes/select.c.NX.original b/nx-X11/programs/Xserver/xfixes/select.c.NX.original
deleted file mode 100755
index c72e19e9a..000000000
--- a/nx-X11/programs/Xserver/xfixes/select.c.NX.original
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * $Id: select.c,v 1.6 2005/07/03 07:37:35 daniels Exp $
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-
-static RESTYPE		SelectionClientType, SelectionWindowType;
-static Bool		SelectionCallbackRegistered = FALSE;
-
-/*
- * There is a global list of windows selecting for selection events
- * on every selection.  This should be plenty efficient for the
- * expected usage, if it does become a problem, it should be easily
- * replaced with a hash table of some kind keyed off the selection atom
- */
-
-typedef struct _SelectionEvent *SelectionEventPtr;
-
-typedef struct _SelectionEvent {
-    SelectionEventPtr	next;
-    Atom		selection;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} SelectionEventRec;
-
-static SelectionEventPtr	selectionEvents;
-
-static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
-{
-    SelectionEventPtr	e;
-    SelectionInfoRec	*info = (SelectionInfoRec *) args;
-    Selection		*selection = info->selection;
-    int			subtype;
-    CARD32		eventMask;
-    
-    switch (info->kind) {
-    case SelectionSetOwner:
-	subtype = XFixesSetSelectionOwnerNotify;
-	eventMask = XFixesSetSelectionOwnerNotifyMask;
-	break;
-    case SelectionWindowDestroy:
-	subtype = XFixesSelectionWindowDestroyNotify;
-	eventMask = XFixesSelectionWindowDestroyNotifyMask;
-	break;
-    case SelectionClientClose:
-	subtype = XFixesSelectionClientCloseNotify;
-	eventMask = XFixesSelectionClientCloseNotifyMask;
-	break;
-    default:
-	return;
-    }
-    for (e = selectionEvents; e; e = e->next)
-    {
-	if (e->selection == selection->selection && 
-	    (e->eventMask & eventMask) &&
-	    !e->pClient->clientGone)
-	{
-	    xXFixesSelectionNotifyEvent	ev;
-
-	    ev.type = XFixesEventBase + XFixesSelectionNotify;
-	    ev.subtype = subtype;
-	    ev.sequenceNumber = e->pClient->sequence;
-	    ev.window = e->pWindow->drawable.id;
-	    if (subtype == XFixesSetSelectionOwnerNotify)
-		ev.owner = selection->window;
-	    else
-		ev.owner = 0;
-	    ev.selection = e->selection;
-	    ev.timestamp = currentTime.milliseconds;
-	    ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
-	    WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	}
-    }
-}
-
-static Bool
-CheckSelectionCallback (void)
-{
-    if (selectionEvents)
-    {
-	if (!SelectionCallbackRegistered)
-	{
-	    if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))
-		return FALSE;
-	    SelectionCallbackRegistered = TRUE;
-	}
-    }
-    else
-    {
-	if (SelectionCallbackRegistered)
-	{
-	    DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);
-	    SelectionCallbackRegistered = FALSE;
-	}
-    }
-    return TRUE;
-}
-
-#define SelectionAllEvents (XFixesSetSelectionOwnerNotifyMask |\
-			    XFixesSelectionWindowDestroyNotifyMask |\
-			    XFixesSelectionClientCloseNotifyMask)
-
-static int
-XFixesSelectSelectionInput (ClientPtr	pClient,
-			    Atom	selection,
-			    WindowPtr	pWindow,
-			    CARD32	eventMask)
-{
-    SelectionEventPtr	*prev, e;
-
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->selection == selection &&
-	    e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->selection = selection;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType))
-	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-	if (!CheckSelectionCallback ())
-	{
-	    FreeResource (e->clientResource, 0);
-	    return BadAlloc;
-	}
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectSelectionInputReq);
-    WindowPtr	pWin;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
-    if (!pWin)
-        return(BadWindow);
-    if (stuff->eventMask & ~SelectionAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectSelectionInput (client, stuff->selection,
-				       pWin, stuff->eventMask);
-}
-
-int
-SProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectSelectionInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->eventMask, n);
-    return ProcXFixesSelectSelectionInput(client);
-}
-    
-void
-SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
-			     xXFixesSelectionNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->owner, to->owner);
-    cpswapl (from->selection, to->selection);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->selectionTimestamp, to->selectionTimestamp);
-}
-
-static int
-SelectionFreeClient (pointer data, XID id)
-{
-    SelectionEventPtr	old = (SelectionEventPtr) data;
-    SelectionEventPtr	*prev, e;
-    
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    CheckSelectionCallback ();
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-SelectionFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    SelectionEventPtr	e, next;
-
-    for (e = selectionEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-Bool
-XFixesSelectionInit (void)
-{
-    SelectionClientType = CreateNewResourceType(SelectionFreeClient);
-    SelectionWindowType = CreateNewResourceType(SelectionFreeWindow);
-    return SelectionClientType && SelectionWindowType;
-}
diff --git a/nx-X11/programs/Xserver/xfixes/select.c.X.original b/nx-X11/programs/Xserver/xfixes/select.c.X.original
deleted file mode 100755
index 6a28da93b..000000000
--- a/nx-X11/programs/Xserver/xfixes/select.c.X.original
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * $Id: select.c,v 1.6 2005/07/03 07:37:35 daniels Exp $
- *
- * Copyright © 2002 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "xfixesint.h"
-
-static RESTYPE		SelectionClientType, SelectionWindowType;
-static Bool		SelectionCallbackRegistered = FALSE;
-
-/*
- * There is a global list of windows selecting for selection events
- * on every selection.  This should be plenty efficient for the
- * expected usage, if it does become a problem, it should be easily
- * replaced with a hash table of some kind keyed off the selection atom
- */
-
-typedef struct _SelectionEvent *SelectionEventPtr;
-
-typedef struct _SelectionEvent {
-    SelectionEventPtr	next;
-    Atom		selection;
-    CARD32		eventMask;
-    ClientPtr		pClient;
-    WindowPtr		pWindow;
-    XID			clientResource;
-} SelectionEventRec;
-
-static SelectionEventPtr	selectionEvents;
-
-static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
-{
-    SelectionEventPtr	e;
-    SelectionInfoRec	*info = (SelectionInfoRec *) args;
-    Selection		*selection = info->selection;
-    int			subtype;
-    CARD32		eventMask;
-    
-    switch (info->kind) {
-    case SelectionSetOwner:
-	subtype = XFixesSetSelectionOwnerNotify;
-	eventMask = XFixesSetSelectionOwnerNotifyMask;
-	break;
-    case SelectionWindowDestroy:
-	subtype = XFixesSelectionWindowDestroyNotify;
-	eventMask = XFixesSelectionWindowDestroyNotifyMask;
-	break;
-    case SelectionClientClose:
-	subtype = XFixesSelectionClientCloseNotify;
-	eventMask = XFixesSelectionClientCloseNotifyMask;
-	break;
-    default:
-	return;
-    }
-    for (e = selectionEvents; e; e = e->next)
-    {
-	if (e->selection == selection->selection && (e->eventMask & eventMask))
-	{
-	    xXFixesSelectionNotifyEvent	ev;
-
-	    ev.type = XFixesEventBase + XFixesSelectionNotify;
-	    ev.subtype = subtype;
-	    ev.sequenceNumber = e->pClient->sequence;
-	    ev.window = e->pWindow->drawable.id;
-	    if (subtype == XFixesSetSelectionOwnerNotify)
-		ev.owner = selection->window;
-	    else
-		ev.owner = 0;
-	    ev.selection = e->selection;
-	    ev.timestamp = currentTime.milliseconds;
-	    ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
-	    WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
-	}
-    }
-}
-
-static Bool
-CheckSelectionCallback (void)
-{
-    if (selectionEvents)
-    {
-	if (!SelectionCallbackRegistered)
-	{
-	    if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))
-		return FALSE;
-	    SelectionCallbackRegistered = TRUE;
-	}
-    }
-    else
-    {
-	if (SelectionCallbackRegistered)
-	{
-	    DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);
-	    SelectionCallbackRegistered = FALSE;
-	}
-    }
-    return TRUE;
-}
-
-#define SelectionAllEvents (XFixesSetSelectionOwnerNotifyMask |\
-			    XFixesSelectionWindowDestroyNotifyMask |\
-			    XFixesSelectionClientCloseNotifyMask)
-
-static int
-XFixesSelectSelectionInput (ClientPtr	pClient,
-			    Atom	selection,
-			    WindowPtr	pWindow,
-			    CARD32	eventMask)
-{
-    SelectionEventPtr	*prev, e;
-
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e->selection == selection &&
-	    e->pClient == pClient &&
-	    e->pWindow == pWindow)
-	{
-	    break;
-	}
-    }
-    if (!eventMask)
-    {
-	if (e)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-	return Success;
-    }
-    if (!e)
-    {
-	e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
-	if (!e)
-	    return BadAlloc;
-
-	e->next = 0;
-	e->selection = selection;
-	e->pClient = pClient;
-	e->pWindow = pWindow;
-	e->clientResource = FakeClientID(pClient->index);
-
-	/*
-	 * Add a resource hanging from the window to
-	 * catch window destroy
-	 */
-	if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType))
-	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
-			      (pointer) pWindow))
-	    {
-		xfree (e);
-		return BadAlloc;
-	    }
-
-	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
-	    return BadAlloc;
-
-	*prev = e;
-	if (!CheckSelectionCallback ())
-	{
-	    FreeResource (e->clientResource, 0);
-	    return BadAlloc;
-	}
-    }
-    e->eventMask = eventMask;
-    return Success;
-}
-
-int
-ProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    REQUEST (xXFixesSelectSelectionInputReq);
-    WindowPtr	pWin;
-
-    REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
-    pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
-    if (!pWin)
-        return(BadWindow);
-    if (stuff->eventMask & ~SelectionAllEvents)
-    {
-	client->errorValue = stuff->eventMask;
-	return( BadValue );
-    }
-    return XFixesSelectSelectionInput (client, stuff->selection,
-				       pWin, stuff->eventMask);
-}
-
-int
-SProcXFixesSelectSelectionInput (ClientPtr client)
-{
-    register int n;
-    REQUEST(xXFixesSelectSelectionInputReq);
-
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->eventMask, n);
-    return ProcXFixesSelectSelectionInput(client);
-}
-    
-void
-SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
-			     xXFixesSelectionNotifyEvent *to)
-{
-    to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->window, to->window);
-    cpswapl (from->owner, to->owner);
-    cpswapl (from->selection, to->selection);
-    cpswapl (from->timestamp, to->timestamp);
-    cpswapl (from->selectionTimestamp, to->selectionTimestamp);
-}
-
-static int
-SelectionFreeClient (pointer data, XID id)
-{
-    SelectionEventPtr	old = (SelectionEventPtr) data;
-    SelectionEventPtr	*prev, e;
-    
-    for (prev = &selectionEvents; (e = *prev); prev = &e->next)
-    {
-	if (e == old)
-	{
-	    *prev = e->next;
-	    xfree (e);
-	    CheckSelectionCallback ();
-	    break;
-	}
-    }
-    return 1;
-}
-
-static int
-SelectionFreeWindow (pointer data, XID id)
-{
-    WindowPtr		pWindow = (WindowPtr) data;
-    SelectionEventPtr	e, next;
-
-    for (e = selectionEvents; e; e = next)
-    {
-	next = e->next;
-	if (e->pWindow == pWindow)
-	{
-	    FreeResource (e->clientResource, 0);
-	}
-    }
-    return 1;
-}
-
-Bool
-XFixesSelectionInit (void)
-{
-    SelectionClientType = CreateNewResourceType(SelectionFreeClient);
-    SelectionWindowType = CreateNewResourceType(SelectionFreeWindow);
-    return SelectionClientType && SelectionWindowType;
-}
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.c b/nx-X11/programs/Xserver/xfixes/xfixes.c
index 1569b311e..1403be8c5 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/xfixes.c
+++ b/nx-X11/programs/Xserver/xfixes/xfixes.c
@@ -27,6 +27,7 @@
 #endif
 
 #include "xfixesint.h"
+#include "protocol-versions.h"
 
 unsigned char	XFixesReqCode;
 int		XFixesEventBase;
@@ -38,33 +39,33 @@ ProcXFixesQueryVersion(ClientPtr client)
 {
     XFixesClientPtr pXFixesClient = GetXFixesClient (client);
     xXFixesQueryVersionReply rep;
-    register int n;
     REQUEST(xXFixesQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
+    memset(&rep, 0, sizeof(xXFixesQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
-    if (stuff->majorVersion < XFIXES_MAJOR) {
-	rep.majorVersion = stuff->majorVersion;
-	rep.minorVersion = stuff->minorVersion;
+    if (stuff->majorVersion < SERVER_XFIXES_MAJOR_VERSION) {
+        rep.majorVersion = stuff->majorVersion;
+        rep.minorVersion = stuff->minorVersion;
     } else {
-	rep.majorVersion = XFIXES_MAJOR;
-	if (stuff->majorVersion == XFIXES_MAJOR && 
-	    stuff->minorVersion < XFIXES_MINOR)
-	    rep.minorVersion = stuff->minorVersion;
-	else
-	    rep.minorVersion = XFIXES_MINOR;
+        rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
+        if (stuff->majorVersion == SERVER_XFIXES_MAJOR_VERSION &&
+            stuff->minorVersion < SERVER_XFIXES_MINOR_VERSION)
+            rep.minorVersion = stuff->minorVersion;
+        else
+            rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
     }
     pXFixesClient->major_version = rep.majorVersion;
     pXFixesClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXFixesQueryVersionReply), &rep);
     return(client->noClientException);
 }
 
@@ -119,7 +120,7 @@ ProcXFixesDispatch (ClientPtr client)
     REQUEST(xXFixesReq);
     XFixesClientPtr pXFixesClient = GetXFixesClient (client);
 
-    if (pXFixesClient->major_version > NUM_VERSION_REQUESTS)
+    if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)
 	return BadRequest;
     if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])
 	return BadRequest;
@@ -129,12 +130,11 @@ ProcXFixesDispatch (ClientPtr client)
 static int
 SProcXFixesQueryVersion(ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesQueryVersionReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swaps(&stuff->length);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -184,8 +184,8 @@ SProcXFixesDispatch (ClientPtr client)
 
 static void
 XFixesClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+		      void		*closure,
+		      void		*data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.h b/nx-X11/programs/Xserver/xfixes/xfixes.h
index fcd941778..fcd941778 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/xfixes.h
+++ b/nx-X11/programs/Xserver/xfixes/xfixes.h
diff --git a/nx-X11/programs/Xserver/xfixes/xfixesint.h b/nx-X11/programs/Xserver/xfixes/xfixesint.h
index 4892654be..70550f5f1 100755..100644
--- a/nx-X11/programs/Xserver/xfixes/xfixesint.h
+++ b/nx-X11/programs/Xserver/xfixes/xfixesint.h
@@ -29,14 +29,13 @@
 #ifndef _XFIXESINT_H_
 #define _XFIXESINT_H_
 
-#define NEED_EVENTS
-#include <X11/X.h>
-#include <X11/Xproto.h>
+#include <nx-X11/X.h>
+#include <nx-X11/Xproto.h>
 #include "misc.h"
 #include "os.h"
 #include "dixstruct.h"
 #include "extnsionst.h"
-#include <X11/extensions/xfixesproto.h>
+#include <nx-X11/extensions/xfixesproto.h>
 #include "windowstr.h"
 #include "selection.h"
 #include "xfixes.h"