Merge branch 'sunweaver-pr/nxagent-no-compiler-warnings' into arctica-3.6.x

Attributes GH PR #102: https://github.com/ArcticaProject/nx-libs/pull/102

130 files changed, 2464 insertions, 3293 deletions

diff --git a/nx-X11/config/cf/xorg.cf b/nx-X11/config/cf/xorg.cf
index 8e2604c4a..a6eaddc72 100644
--- a/nx-X11/config/cf/xorg.cf
+++ b/nx-X11/config/cf/xorg.cf
@@ -786,9 +786,9 @@ XFREE86JAPANESEDOCDIR = $(DOCDIR)/Japanese
 # endif
 # ifndef DefaultCCOptions
 #  if defined(UseInstalled)
-#   define DefaultCCOptions /* -ansi */
+#   define DefaultCCOptions /* -std=c99 */
 #  else
-#   define DefaultCCOptions -ansi GccWarningOptions
+#   define DefaultCCOptions -std=c99 GccWarningOptions
 #  endif
 # endif
 # if defined(UseInstalled)
diff --git a/nx-X11/programs/Xserver/GL/glx/Imakefile b/nx-X11/programs/Xserver/GL/glx/Imakefile
index 506ef5539..bf2d760a0 100644
--- a/nx-X11/programs/Xserver/GL/glx/Imakefile
+++ b/nx-X11/programs/Xserver/GL/glx/Imakefile
@@ -43,7 +43,8 @@ LinkSourceFile(indirect_size.h, $(MESASRCDIR)/src/glx/x11)
      INCLUDES = -I$(SERVERSRC)/GL/glx -I$(SERVERSRC)/GL/include -I$(SERVERSRC)/include -I$(INCLUDESRC) -I$(MESASRCDIR)/include \
                 -I$(XINCLUDESRC) -I$(SERVERSRC)/mi \
                 -I$(EXTINCSRC) -I$(LIBSRC)/GL/include \
-                -I$(XF86SRC)
+                -I$(XF86SRC) \
+                `pkg-config --cflags-only-I pixman-1`
 
 #if defined(DarwinArchitecture) && ((OSMajorVersion == 6 && OSMinorVersion < 3) || OSMajorVersion < 6)
   NO_EXT_DEFS = -DMISSING_GL_EXTS
diff --git a/nx-X11/programs/Xserver/GL/mesa/X/Imakefile b/nx-X11/programs/Xserver/GL/mesa/X/Imakefile
index ee728b556..9fb00ef73 100644
--- a/nx-X11/programs/Xserver/GL/mesa/X/Imakefile
+++ b/nx-X11/programs/Xserver/GL/mesa/X/Imakefile
@@ -39,7 +39,8 @@ LinkSourceFile(compsize.c,$(MESASRCDIR)/src/glx/x11)
 		-I$(SERVERSRC)/include -I$(SERVERSRC)/GL/include \
 		-I$(SERVERSRC)/GL/glx \
 		-I$(XF86OSSRC) \
-		-I$(DRMSRCDIR)/shared-core
+		-I$(DRMSRCDIR)/shared-core \
+		`pkg-config --cflags-only-I pixman-1`
 
       DEFINES = $(GLX_DEFINES) $(GLXSRV_DEFINES) -DNXAGENT_SERVER /*-DUSE_X86_ASM*/ /*-DUSE_SPARC_ASM*/
 
diff --git a/nx-X11/programs/Xserver/Imakefile b/nx-X11/programs/Xserver/Imakefile
index c7e1af550..a2a3f7ced 100644
--- a/nx-X11/programs/Xserver/Imakefile
+++ b/nx-X11/programs/Xserver/Imakefile
@@ -384,10 +384,12 @@ NXAGENTOBJS = hw/nxagent/miinitext.o     \
               dix/main.o
 #endif
 
-XPMLIB =  -lXpm
+XPMLIB    =  -lXpm
+XMLLIB    =  `pkg-config --libs libxml-2.0`
+PIXMANLIB =  `pkg-config --libs pixman-1`
 NXAGENT = hw/nxagent/LibraryTargetName(nxagent)
 NXAGENTLIBS = PreFbLibs $(NXAGENT) FbPostFbLibs $(NXAGENT) $(MI)
-NXAGENTSYSLIBS = $(LDPRELIBS) $(XLIB) $(SYSLIBS) $(XPMLIB)
+NXAGENTSYSLIBS = $(LDPRELIBS) $(XLIB) $(SYSLIBS) $(XPMLIB) $(XMLLIB) $(PIXMANLIB)
 #if HasParallelMake
 MakeMutex($(NXAGENTDIRS) $(NXAGENTOBJS) $(NXAGENTLIBS) $(NXAGENTSYSLIBS))
 #endif
@@ -403,18 +405,15 @@ $(NXAGENTOBJS) $(NXAGENTLIBS) $(NXAGENTSYSLIBS):: $(NXAGENTDIRS)
 #if defined(SunArchitecture)
 NXAGENTNXLIBS = -L ../../../nxcomp -L ../../../nxcompext -L ../../../nxcompshad \
                 -lXcomp -lXcompext -lXcompshad -lrt -L/usr/sfw/lib -lXrender -lXfixes -lXfont \
-                -L../../../nx-X11/exports/lib -lXtst -lXrandr -lXcomposite -lXdmcp \
-`pkg-config --libs libxml-2.0`
+                -L../../../nx-X11/exports/lib -lXtst -lXrandr -lXcomposite -lXdmcp
 #elif defined(cygwinArchitecture)
 NXAGENTNXLIBS = -L ../../../nxcomp -L ../../../nxcompext \
                 -lXcomp -lXcompext -lXrender -lX11 -lNX_Xext -lXcomposite -lXfixes -lXfont \
-                -L ../../../nxcompshad -lXcompshad -L../../../nx-X11/exports/lib -lXtst -lXdmcp \
-`pkg-config --libs libxml-2.0`
+                -L ../../../nxcompshad -lXcompshad -L../../../nx-X11/exports/lib -lXtst -lXdmcp
 #else
 NXAGENTNXLIBS = -L ../../../nxcomp -L ../../../nxcompext -L ../../../nxcompshad \
                 -lXcomp -lXcompext -lXcompshad -lXrender -lNX_X11 -lNX_Xext -lXfixes -lXfont \
-                -L../../../nx-X11/exports/lib -lXtst -lXrandr -lXcomposite -lXinerama -lXdmcp \
-`pkg-config --libs libxml-2.0`
+                -L../../../nx-X11/exports/lib -lXtst -lXrandr -lXcomposite -lXinerama -lXdmcp
 #endif
 
 #endif
diff --git a/nx-X11/programs/Xserver/XTrap/Imakefile b/nx-X11/programs/Xserver/XTrap/Imakefile
index 2362634c7..c61712f1d 100644
--- a/nx-X11/programs/Xserver/XTrap/Imakefile
+++ b/nx-X11/programs/Xserver/XTrap/Imakefile
@@ -11,7 +11,7 @@ XCOMM $XFree86: xc/programs/Xserver/XTrap/Imakefile,v 1.1 2001/11/02 23:29:29 da
 #endif
          SRCS = xtrapddmi.c xtrapdi.c xtrapdiswp.c xtrapditbl.c
          OBJS = xtrapddmi.o xtrapdi.o xtrapdiswp.o xtrapditbl.o
-     INCLUDES = -I../include -I$(EXTINCSRC) -I$(XINCLUDESRC) -I$(SERVERSRC)/Xext
+     INCLUDES = -I../include -I$(EXTINCSRC) -I$(XINCLUDESRC) -I$(SERVERSRC)/Xext `pkg-config --cflags-only-I pixman-1`
 
 NormalLibraryTarget(xtrap,$(OBJS))
 LintLibraryTarget(xtrap,$(SRCS))
diff --git a/nx-X11/programs/Xserver/Xext/Imakefile b/nx-X11/programs/Xserver/Xext/Imakefile
index eb4588e37..199e59f1d 100644
--- a/nx-X11/programs/Xserver/Xext/Imakefile
+++ b/nx-X11/programs/Xserver/Xext/Imakefile
@@ -161,7 +161,8 @@ XF86INCLUDES = -I$(XF86COMSRC)
 #endif
     INCLUDES = -I. -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) \
 		$(PNRXINCLUDES) $(XF86INCLUDES) \
-		$(FONTCACHEINCLUDES) $(DMXINCLUDES)
+		$(FONTCACHEINCLUDES) $(DMXINCLUDES) \
+		`pkg-config --cflags-only-I pixman-1`
     LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
 #if defined(NXAgentServer) && NXAgentServer
diff --git a/nx-X11/programs/Xserver/Xext/mbuf.c b/nx-X11/programs/Xserver/Xext/mbuf.c
index e6dec8f6f..5379f2656 100644
--- a/nx-X11/programs/Xserver/Xext/mbuf.c
+++ b/nx-X11/programs/Xserver/Xext/mbuf.c
@@ -903,9 +903,9 @@ ProcClearImageBufferArea (client)
 	box.y1 = clearRect.y;
 	box.x2 = clearRect.x + clearRect.width;
 	box.y2 = clearRect.y + clearRect.height;
-	REGION_INIT(pScreen, &region, &box, 1);
+	RegionInit(&region, &box, 1);
 	MultibufferExpose(pMultibuffer, &region);
-	REGION_UNINIT(pScreen, &region);
+	RegionUninit(&region);
     }
     return Success;
 }
@@ -1202,13 +1202,13 @@ PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf)
 		     * window-relative so that region ops involving
 		     * pExposed and pWinSize behave sensibly.
 		     */
-		    REGION_TRANSLATE(pWin->drawable.pScreen, pWinSize,
+		    RegionTranslate(pWinSize,
 				     -pWin->drawable.x, -pWin->drawable.y);
-		    REGION_INTERSECT(pWin->drawable.pScreen, pExposed,
+		    RegionIntersect(pExposed,
 				     pExposed, pWinSize);
-		    REGION_DESTROY(pWin->drawable.pScreen, pWinSize);
+		    RegionDestroy(pWinSize);
 	    	    MultibufferExpose (pPrevMultibuffer, pExposed);
-	    	    REGION_DESTROY(pWin->drawable.pScreen, pExposed);
+		    RegionDestroy(pExposed);
 	    	}
 	    	graphicsExpose = FALSE;
 	    	DoChangeGC (pGC, GCGraphicsExposures, &graphicsExpose, FALSE);
@@ -1371,7 +1371,7 @@ MultibufferExpose (pMultibuffer, pRegion)
     MultibufferPtr	pMultibuffer;
     RegionPtr	pRegion;
 {
-    if (pRegion && !REGION_NIL(pRegion))
+    if (pRegion && !RegionNil(pRegion))
     {
 	xEvent *pEvent;
 	PixmapPtr   pPixmap;
@@ -1381,11 +1381,11 @@ MultibufferExpose (pMultibuffer, pRegion)
 	int numRects;
 
 	pPixmap = pMultibuffer->pPixmap;
-	REGION_TRANSLATE(pPixmap->drawable.pScreen, pRegion,
+	RegionTranslate(pRegion,
 		    -pPixmap->drawable.x, -pPixmap->drawable.y);
 	/* XXX MultibufferExpose "knows" the region representation */
-	numRects = REGION_NUM_RECTS(pRegion);
-	pBox = REGION_RECTS(pRegion);
+	numRects = RegionNumRects(pRegion);
+	pBox = RegionRects(pRegion);
 
 	pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent));
 	if (pEvent) {
diff --git a/nx-X11/programs/Xserver/Xext/mbufbf.c b/nx-X11/programs/Xserver/Xext/mbufbf.c
index 318fa6756..359fb63aa 100644
--- a/nx-X11/programs/Xserver/Xext/mbufbf.c
+++ b/nx-X11/programs/Xserver/Xext/mbufbf.c
@@ -245,9 +245,9 @@ bufMultibufferInit(pScreen, pMBScreen)
     box.y2 = pScreen->height;
 
     pMBPriv->rgnChanged = TRUE;
-    REGION_INIT(pScreen, &pMBPriv->backBuffer, &box, 1);
-    REGION_INIT(pScreen, &pMBPriv->subtractRgn, &box, 1);
-    REGION_NULL(pScreen, &pMBPriv->unionRgn);
+    RegionInit(&pMBPriv->backBuffer, &box, 1);
+    RegionInit(&pMBPriv->subtractRgn, &box, 1);
+    RegionNull(&pMBPriv->unionRgn);
 
     /* Misc functions */
     pMBPriv->CopyBufferBits  = bufCopyBufferBitsFunc[pScreen->myNum];
@@ -374,10 +374,10 @@ bufCreateImageBuffers (pWin, nbuf, ids, action, hint)
     pMBScreen = MB_SCREEN_PRIV(pScreen);
     pMBWindow = MB_WINDOW_PRIV(pWin);
 
-    pMBWindow->devPrivate.ptr = (void *) REGION_CREATE(pScreen, 0,0);
+    pMBWindow->devPrivate.ptr = (void *) RegionCreate(0,0);
     if (!pMBWindow->devPrivate.ptr)
 	return(0);
-    REGION_COPY(pScreen, (RegionPtr) pMBWindow->devPrivate.ptr,
+    RegionCopy((RegionPtr) pMBWindow->devPrivate.ptr,
 			    &pWin->clipList);
 
     for (i = 0; i < nbuf; i++)
@@ -429,7 +429,7 @@ bufDestroyImageBuffers(pWin)
 	if (pWin->realized && (pMBWindow->displayedMultibuffer == BACK_BUFFER))
 	{
 	    (* pMBPriv->CopyBufferBits)(pMBWindow, BACK_BUFFER, FRONT_BUFFER);
-	    REGION_SUBTRACT(pScreen, &pMBPriv->backBuffer,
+	    RegionSubtract(&pMBPriv->backBuffer,
 				  &pMBPriv->backBuffer, &pWin->clipList);
 	    (* pMBPriv->DrawSelectPlane)(pScreen, pMBPriv->selectPlane,
 			    &pWin->clipList, FRONT_BUFFER);
@@ -439,7 +439,7 @@ bufDestroyImageBuffers(pWin)
 	pWin->devPrivates[frameWindowPrivateIndex] =
 	    pMBPriv->frameBuffer[FRONT_BUFFER];
 
-	REGION_DESTROY(pScreen, (RegionPtr) pMBWindow->devPrivate.ptr);
+	RegionDestroy((RegionPtr) pMBWindow->devPrivate.ptr);
 	pMBWindow->devPrivate.ptr = NULL;
     }
 }
@@ -506,7 +506,7 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
     box.y2 = y2;
 
     pScreen = pBuffer->drawable.pScreen;
-    REGION_INIT(pScreen, &reg, &box, 1);
+    RegionInit(&reg, &box, 1);
     if (pBuffer->backStorage)
     {
 	/*
@@ -520,7 +520,7 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
 						 generateExposures);
     }
 
-    REGION_INTERSECT(pScreen, &reg, &reg, &pBuffer->clipList);
+    RegionIntersect(&reg, &reg, &pBuffer->clipList);
     if (pBuffer->backgroundState != None)
 	(*pScreen->PaintWindowBackground)(pBuffer, &reg, PW_BACKGROUND);
     if (generateExposures)
@@ -537,9 +537,9 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
     else if (pBuffer->backgroundState != None)
         (*pScreen->PaintWindowBackground)(pBuffer, &reg, PW_BACKGROUND);
 #endif
-    REGION_UNINIT(pScreen, &reg);
+    RegionUninit(&reg);
     if (pBSReg)
-	REGION_DESTROY(pScreen, pBSReg);
+	RegionDestroy(pBSReg);
 }
 
 static void
@@ -567,9 +567,9 @@ bufResetProc(pScreen)
      * whoever called RegisterDoubleBufferHardware
      */
 
-    REGION_UNINIT(pScreen, &pMBPriv->backBuffer);
-    REGION_UNINIT(pScreen, &pMBPriv->subtractRgn);
-    REGION_UNINIT(pScreen, &pMBPriv->unionRgn);
+    RegionUninit(&pMBPriv->backBuffer);
+    RegionUninit(&pMBPriv->subtractRgn);
+    RegionUninit(&pMBPriv->unionRgn);
     xfree(pMBPriv);
 }
 
@@ -624,7 +624,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
     int numRects;
     XID	value;
 
-    if (REGION_NUM_RECTS(prgn) == 0)
+    if (RegionNumRects(prgn) == 0)
 	return;
 
     pDrawable = (DrawablePtr) selectPlane.ptr;
@@ -632,7 +632,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
     if (!pGC)
 	return;
 
-    prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
+    prect = (xRectangle *)ALLOCATE_LOCAL(RegionNumRects(prgn) *
 					 sizeof(xRectangle));
     if (!prect)
     {
@@ -644,8 +644,8 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
     DoChangeGC(pGC, GCForeground, &value, 0);
     ValidateGC(pDrawable, pGC);
 
-    numRects = REGION_NUM_RECTS(prgn);
-    pbox = REGION_RECTS(prgn);
+    numRects = RegionNumRects(prgn);
+    pbox = RegionRects(prgn);
     for (i= numRects; --i >= 0; pbox++, prect++)
     {
 	prect->x = pbox->x1;
@@ -697,10 +697,10 @@ bufDisplayImageBuffers(pScreen, ppMBWindow, ppMBBuffer, nbuf)
 			    &pWin->clipList, number);
 
 	    if (number == BACK_BUFFER)
-		REGION_UNION(pScreen, backBuffer, backBuffer,
+		RegionUnion(backBuffer, backBuffer,
 				   &pWin->clipList);
 	    else
-		REGION_SUBTRACT(pScreen, backBuffer, backBuffer,
+		RegionSubtract(backBuffer, backBuffer,
 				   &pWin->clipList);
 
 	    /* Switch which framebuffer the window draws into */
@@ -764,36 +764,36 @@ bufPostValidateTree(pParent, pChild, kind)
 
 	pSubtractRgn = &pMBPriv->subtractRgn;
 	pUnionRgn    = &pMBPriv->unionRgn;
-	REGION_VALIDATE(pScreen, pSubtractRgn, &overlap);
+	RegionValidate(pSubtractRgn, &overlap);
 #ifdef DEBUG
 	if (overlap)
 	    FatalError("bufPostValidateTree: subtractRgn overlaps");
 #endif
-	REGION_VALIDATE(pScreen, pUnionRgn, &overlap);
+	RegionValidate(pUnionRgn, &overlap);
 #ifdef DEBUG
 	if (overlap)
 	    FatalError("bufPostValidateTree: unionRgn overlaps");
 #endif
 
 	/* Update backBuffer: subtract must come before union */
-	REGION_SUBTRACT(pScreen, &pMBPriv->backBuffer, &pMBPriv->backBuffer,
+	RegionSubtract(&pMBPriv->backBuffer, &pMBPriv->backBuffer,
 			      pSubtractRgn);
-	REGION_UNION(pScreen, &pMBPriv->backBuffer, &pMBPriv->backBuffer,
+	RegionUnion(&pMBPriv->backBuffer, &pMBPriv->backBuffer,
 			      pUnionRgn);
 
 	/* Paint gained and lost backbuffer areas in select plane */
-	REGION_NULL(pScreen, &exposed);
-	REGION_SUBTRACT(pScreen, &exposed, pSubtractRgn, pUnionRgn);
+	RegionNull(&exposed);
+	RegionSubtract(&exposed, pSubtractRgn, pUnionRgn);
 	(* pMBPriv->DrawSelectPlane)(pScreen, pMBPriv->selectPlane,
 				     &exposed, FRONT_BUFFER);
 
-	REGION_SUBTRACT(pScreen, &exposed, pUnionRgn, pSubtractRgn);
+	RegionSubtract(&exposed, pUnionRgn, pSubtractRgn);
 	(* pMBPriv->DrawSelectPlane)(pScreen, pMBPriv->selectPlane,
 				    &exposed, BACK_BUFFER);
 	
-	REGION_UNINIT(pScreen, &exposed);
-	REGION_EMPTY(pScreen, pSubtractRgn);
-	REGION_EMPTY(pScreen, pUnionRgn);
+	RegionUninit(&exposed);
+	RegionEmpty(pSubtractRgn);
+	RegionEmpty(pUnionRgn);
     }
 }
 
@@ -826,16 +826,16 @@ bufClipNotify(pWin, dx,dy)
     {
 	RegionPtr pOldClipList = (RegionPtr) pMBWindow->devPrivate.ptr;
 
-	if (! REGION_EQUAL(pScreen, pOldClipList, &pWin->clipList))
+	if (! RegionEqual(pOldClipList, &pWin->clipList))
 	{
 	    if (pMBWindow->displayedMultibuffer == BACK_BUFFER)
 	    {
 		pMBPriv->rgnChanged = TRUE;
-		REGION_APPEND(pScreen, &pMBPriv->subtractRgn, pOldClipList);
-		REGION_APPEND(pScreen, &pMBPriv->unionRgn, &pWin->clipList);
+		RegionAppend(&pMBPriv->subtractRgn, pOldClipList);
+		RegionAppend(&pMBPriv->unionRgn, &pWin->clipList);
 	    }
 
-	    REGION_COPY(pScreen, pOldClipList,&pWin->clipList);
+	    RegionCopy(pOldClipList,&pWin->clipList);
 	}
 
 	/* Update buffer x,y,w,h, and clipList */
@@ -912,13 +912,13 @@ bufWindowExposures(pWin, prgn, other_exposed)
 
     handleBuffers = (!pMBPriv->inClearToBackground) &&
 	(pWin->drawable.type == DRAWABLE_WINDOW) &&
-	pMBWindow && (prgn && !REGION_NIL(prgn));
+	pMBWindow && (prgn && !RegionNil(prgn));
 
     /* miWindowExposures munges prgn and other_exposed. */
     if (handleBuffers)
     {
-	REGION_NULL(pScreen, &tmp_rgn);
-	REGION_COPY(pScreen, &tmp_rgn, prgn);
+	RegionNull(&tmp_rgn);
+	RegionCopy(&tmp_rgn, prgn);
     }
 
     UNWRAP_SCREEN_FUNC(pScreen, pMBPriv, void, WindowExposures);
@@ -950,7 +950,7 @@ bufWindowExposures(pWin, prgn, other_exposed)
 	    MultibufferExpose(pMBBuffer, &tmp_rgn);
     }
 
-    REGION_UNINIT(pScreen, &tmp_rgn);
+    RegionUninit(&tmp_rgn);
 }
 
 /*
@@ -1018,7 +1018,7 @@ bufCopyWindow(pWin, ptOldOrg, prgnSrc)
      */
 
     /* CopyWindow translates prgnSrc... translate it back for 2nd call. */
-    REGION_TRANSLATE(pScreen, prgnSrc,
+    RegionTranslate(prgnSrc,
 				  ptOldOrg.x - pWin->drawable.x,
 				  ptOldOrg.y - pWin->drawable.y);
     pwinroot->devPrivates[frameWindowPrivateIndex] =
diff --git a/nx-X11/programs/Xserver/Xext/mbufpx.c b/nx-X11/programs/Xserver/Xext/mbufpx.c
index 0e9ae1628..3d28d3ff3 100644
--- a/nx-X11/programs/Xserver/Xext/mbufpx.c
+++ b/nx-X11/programs/Xserver/Xext/mbufpx.c
@@ -262,8 +262,8 @@ MultibufferPaintBackgroundRegion(pWin, pDrawable, pRegion)
     RegionPtr pRegion;
 {
     xRectangle *pRects;
-    int nrects  = REGION_NUM_RECTS(pRegion);
-    BoxPtr pbox = REGION_RECTS(pRegion);
+    int nrects  = RegionNumRects(pRegion);
+    BoxPtr pbox = RegionRects(pRegion);
 
     pRects = (xRectangle *)ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
     if (pRects)
@@ -390,13 +390,13 @@ pixDisplayImageBuffers(pScreen, ppMBWindow, ppMBBuffer, nbuf)
 			 * window-relative so that region ops involving
 			 * pExposed and pWinSize behave sensibly.
 			 */
-			REGION_TRANSLATE(pScreen, pWinSize,
+			RegionTranslate(pWinSize,
 						     -pWin->drawable.x,
 						     -pWin->drawable.y);
-			REGION_INTERSECT(pScreen, pExposed, pExposed, pWinSize);
-			REGION_DESTROY(pScreen, pWinSize);
+			RegionIntersect(pExposed, pExposed, pWinSize);
+			RegionDestroy(pWinSize);
 			MultibufferExpose (pPrevMBBuffer, pExposed);
-			REGION_DESTROY(pScreen, pExposed);
+			RegionDestroy(pExposed);
 		    }
 		    bool = FALSE;
 		    DoChangeGC (pGC, GCGraphicsExposures, &bool, FALSE);
@@ -522,7 +522,7 @@ pixPositionWindow (pWin, x, y)
 	box.x1 = box.y1 = 0;
 	box.x2 = width;
 	box.y2 = height;
-	REGION_INIT(pScreen, &exposedRegion, &box, 1);
+	RegionInit(&exposedRegion, &box, 1);
 	if (pWin->bitGravity != ForgetGravity)
 	{
 	    RegionRec preservedRegion;
@@ -530,9 +530,9 @@ pixPositionWindow (pWin, x, y)
 	    box.y1 = desty;
 	    box.x2 = destx + savewidth;
 	    box.y2 = desty + saveheight;
-	    REGION_INIT(pScreen, &preservedRegion, &box, 1);
-	    REGION_SUBTRACT(pScreen, &exposedRegion, &exposedRegion, &preservedRegion);
-	    REGION_UNINIT(pScreen, &preservedRegion);
+	    RegionInit(&preservedRegion, &box, 1);
+	    RegionSubtract(&exposedRegion, &exposedRegion, &preservedRegion);
+	    RegionUninit(&preservedRegion);
 	}
 
     } /* end if (clear) */
@@ -575,7 +575,7 @@ pixPositionWindow (pWin, x, y)
     }
     FreeScratchGC (pGC);
     if (clear)
-	REGION_UNINIT(pScreen, &exposedRegion);
+	RegionUninit(&exposedRegion);
     return TRUE;
 }
 
@@ -628,7 +628,7 @@ pixClearImageBufferArea(pMBBuffer, x,y, width,height, exposures)
     if (box.x2 > w_width)  box.x2 = w_width;
     if (box.y2 > w_height) box.y2 = w_height;
 
-    REGION_INIT(pScreen, &region, &box, 1);
+    RegionInit(&region, &box, 1);
 
     if (pMBBuffer->number == pMBBuffer->pMBWindow->displayedMultibuffer)
       pDrawable = (DrawablePtr) pWin;
@@ -640,7 +640,7 @@ pixClearImageBufferArea(pMBBuffer, x,y, width,height, exposures)
     if (exposures)
 	MultibufferExpose(pMBBuffer, &region);
 
-    REGION_UNINIT(pScreen, &region);
+    RegionUninit(&region);
 }
 
 static void
diff --git a/nx-X11/programs/Xserver/Xext/panoramiX.c b/nx-X11/programs/Xserver/Xext/panoramiX.c
index 000c4bf04..2671ba0d3 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiX.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiX.c
@@ -161,9 +161,9 @@ XineramaCloseScreen (int i, ScreenPtr pScreen)
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
     pScreen->CreateGC = pScreenPriv->CreateGC;
 
-    REGION_UNINIT(pScreen, &XineramaScreenRegions[pScreen->myNum]);
+    RegionUninit(&XineramaScreenRegions[pScreen->myNum]);
     if (pScreen->myNum == 0)
-	REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
+	RegionUninit(&PanoramiXScreenRegion);
 
     xfree ((void *) pScreenPriv);
 
@@ -434,7 +434,7 @@ static void XineramaInitData(ScreenPtr pScreen)
 {
     int i, w, h;
 
-    REGION_NULL(pScreen, &PanoramiXScreenRegion)
+    RegionNull(&PanoramiXScreenRegion);
     for (i = 0; i < PanoramiXNumScreens; i++) {
 	BoxRec TheBox;
 
@@ -450,8 +450,8 @@ static void XineramaInitData(ScreenPtr pScreen)
 	TheBox.y1 = panoramiXdataPtr[i].y;
 	TheBox.y2 = TheBox.y1 + panoramiXdataPtr[i].height;
 
-	REGION_INIT(pScreen, &XineramaScreenRegions[i], &TheBox, 1);
-	REGION_UNION(pScreen, &PanoramiXScreenRegion, &PanoramiXScreenRegion,
+	RegionInit(&XineramaScreenRegions[i], &TheBox, 1);
+	RegionUnion(&PanoramiXScreenRegion, &PanoramiXScreenRegion,
 		     &XineramaScreenRegions[i]);
     }
 
@@ -473,9 +473,9 @@ void XineramaReinitData(ScreenPtr pScreen)
 {
     int i;
 
-    REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
+    RegionUninit(&PanoramiXScreenRegion);
     for (i = 0; i < PanoramiXNumScreens; i++)
-	REGION_UNINIT(pScreen, &XineramaScreenRegions[i]);
+	RegionUninit(&XineramaScreenRegions[i]);
 
     XineramaInitData(pScreen);
 }
@@ -1182,15 +1182,15 @@ XineramaGetImageData(
     SrcBox.x2 = SrcBox.x1 + width;
     SrcBox.y2 = SrcBox.y1 + height;
     
-    REGION_INIT(pScreen, &SrcRegion, &SrcBox, 1);
-    REGION_NULL(pScreen, &GrabRegion);
+    RegionInit(&SrcRegion, &SrcBox, 1);
+    RegionNull(&GrabRegion);
 
     depth = (format == XYPixmap) ? 1 : pDraw->depth;
 
     for(i = 0; i < PanoramiXNumScreens; i++) {
 	pDraw = pDrawables[i];
 
-	inOut = RECT_IN_REGION(pScreen,&XineramaScreenRegions[i],&SrcBox);
+	inOut = RegionContainsRect(&XineramaScreenRegions[i],&SrcBox);
 
 	if(inOut == rgnIN) {	   
 	    (*pDraw->pScreen->GetImage)(pDraw, 
@@ -1201,13 +1201,13 @@ XineramaGetImageData(
 	} else if (inOut == rgnOUT)
 	    continue;
 
-	REGION_INTERSECT(pScreen, &GrabRegion, &SrcRegion, 
+	RegionIntersect(&GrabRegion, &SrcRegion,
 					&XineramaScreenRegions[i]);
 
-	nbox = REGION_NUM_RECTS(&GrabRegion);
+	nbox = RegionNumRects(&GrabRegion);
 
 	if(nbox) {
-	    pbox = REGION_RECTS(&GrabRegion);
+	    pbox = RegionRects(&GrabRegion);
 
 	    while(nbox--) {
 		w = pbox->x2 - pbox->x1;
@@ -1284,8 +1284,8 @@ XineramaGetImageData(
 		pbox++;
 	    }
 
-	    REGION_SUBTRACT(pScreen, &SrcRegion, &SrcRegion, &GrabRegion);
-	    if(!REGION_NOTEMPTY(pScreen, &SrcRegion))
+	    RegionSubtract(&SrcRegion, &SrcRegion, &GrabRegion);
+	    if(!RegionNotEmpty(&SrcRegion))
 		break;
 	}
 	
@@ -1294,6 +1294,6 @@ XineramaGetImageData(
     if(ScratchMem)
 	xfree(ScratchMem);
 
-    REGION_UNINIT(pScreen, &SrcRegion);
-    REGION_UNINIT(pScreen, &GrabRegion);
+    RegionUninit(&SrcRegion);
+    RegionUninit(&GrabRegion);
 }
diff --git a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
index 2f2b2c63e..8078e2bd0 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
@@ -621,7 +621,7 @@ int PanoramiXTranslateCoords(ClientPtr client)
 		 * borderSize
 		 */
 		&& (!wBoundingShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen, 
+		    RegionContainsPoint(
 					wBoundingShape(pWin), 
 					x - pWin->drawable.x, 
 					y - pWin->drawable.y, &box))
@@ -1109,21 +1109,21 @@ int PanoramiXCopyArea(ClientPtr client)
 	    RegionRec totalReg;
 	    Bool overlap;
 
-	    REGION_NULL(pScreen, &totalReg);
+	    RegionNull(&totalReg);
 	    FOR_NSCREENS_BACKWARD(j) {
 		if(pRgn[j]) {
 		   if(srcIsRoot) {
-		       REGION_TRANSLATE(pScreen, pRgn[j], 
+		       RegionTranslate(pRgn[j],
 				panoramiXdataPtr[j].x, panoramiXdataPtr[j].y);
 		   }
-		   REGION_APPEND(pScreen, &totalReg, pRgn[j]);
-		   REGION_DESTROY(pScreen, pRgn[j]);
+		   RegionAppend(&totalReg, pRgn[j]);
+		   RegionDestroy(pRgn[j]);
 		}
 	    }
-	    REGION_VALIDATE(pScreen, &totalReg, &overlap);
+	    RegionValidate(&totalReg, &overlap);
 	    (*pScreen->SendGraphicsExpose)(
 		client, &totalReg, stuff->dstDrawable, X_CopyArea, 0);
-	    REGION_UNINIT(pScreen, &totalReg);
+	    RegionUninit(&totalReg);
 	}
 	
 	result = client->noClientException;
@@ -1220,17 +1220,17 @@ int PanoramiXCopyPlane(ClientPtr client)
 	RegionRec totalReg;
 	Bool overlap;
 
-	REGION_NULL(pScreen, &totalReg);
+	RegionNull(&totalReg);
 	FOR_NSCREENS_BACKWARD(j) {
 	    if(pRgn[j]) {
-		REGION_APPEND(pScreen, &totalReg, pRgn[j]);
-		REGION_DESTROY(pScreen, pRgn[j]);
+		RegionAppend(&totalReg, pRgn[j]);
+		RegionDestroy(pRgn[j]);
 	    }
 	}
-	REGION_VALIDATE(pScreen, &totalReg, &overlap);
+	RegionValidate(&totalReg, &overlap);
 	(*pScreen->SendGraphicsExpose)(
 		client, &totalReg, stuff->dstDrawable, X_CopyPlane, 0);
-	REGION_UNINIT(pScreen, &totalReg);
+	RegionUninit(&totalReg);
     }
 
     return (client->noClientException);
diff --git a/nx-X11/programs/Xserver/Xext/sampleEVI.c b/nx-X11/programs/Xserver/Xext/sampleEVI.c
index 598992742..961c108f9 100644
--- a/nx-X11/programs/Xserver/Xext/sampleEVI.c
+++ b/nx-X11/programs/Xserver/Xext/sampleEVI.c
@@ -37,11 +37,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "EVIstruct.h"
 #include "scrnintstr.h"
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
 
 static int sampleGetVisualInfo(
     VisualID32 *visual,
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index bcc8574cb..ccf80b401 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -1400,12 +1400,12 @@ SecurityCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
     imageBox.y1 = y;
     imageBox.x2 = x + w;
     imageBox.y2 = y + h;
-    REGION_INIT(pScreen, &imageRegion, &imageBox, 1);
-    REGION_NULL(pScreen, &censorRegion);
+    RegionInit(&imageRegion, &imageBox, 1);
+    RegionNull(&censorRegion);
 
     /* censorRegion = imageRegion - visibleRegion */
-    REGION_SUBTRACT(pScreen, &censorRegion, &imageRegion, pVisibleRegion);
-    nRects = REGION_NUM_RECTS(&censorRegion);
+    RegionSubtract(&censorRegion, &imageRegion, pVisibleRegion);
+    nRects = RegionNumRects(&censorRegion);
     if (nRects > 0)
     { /* we have something to censor */
 	GCPtr pScratchGC = NULL;
@@ -1425,7 +1425,7 @@ SecurityCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
 	    failed = TRUE;
 	    goto failSafe;
 	}
-	for (pBox = REGION_RECTS(&censorRegion), i = 0;
+	for (pBox = RegionRects(&censorRegion), i = 0;
 	     i < nRects;
 	     i++, pBox++)
 	{
@@ -1475,8 +1475,8 @@ SecurityCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
 	if (pScratchGC) FreeScratchGC(pScratchGC);
 	if (pPix)       FreeScratchPixmapHeader(pPix);
     }
-    REGION_UNINIT(pScreen, &imageRegion);
-    REGION_UNINIT(pScreen, &censorRegion);
+    RegionUninit(&imageRegion);
+    RegionUninit(&censorRegion);
 } /* SecurityCensorImage */
 
 /**********************************************************************/
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index 78d3be319..8516192c0 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -186,11 +186,11 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
     ScreenPtr	pScreen = pWin->drawable.pScreen;
 
     if (srcRgn && (xoff || yoff))
-	REGION_TRANSLATE(pScreen, srcRgn, xoff, yoff);
+	RegionTranslate(srcRgn, xoff, yoff);
     if (!pWin->parent)
     {
 	if (srcRgn)
-	    REGION_DESTROY(pScreen, srcRgn);
+	    RegionDestroy(srcRgn);
 	return Success;
     }
 
@@ -201,7 +201,7 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
      */
     if (srcRgn == NULL) {
       if (*destRgnp != NULL) {
-	REGION_DESTROY (pScreen, *destRgnp);
+	RegionDestroy(*destRgnp);
 	*destRgnp = 0;
 	/* go on to remove shape and generate ShapeNotify */
       }
@@ -220,17 +220,17 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
     else switch (op) {
     case ShapeSet:
 	if (*destRgnp)
-	    REGION_DESTROY(pScreen, *destRgnp);
+	    RegionDestroy(*destRgnp);
 	*destRgnp = srcRgn;
 	srcRgn = 0;
 	break;
     case ShapeUnion:
 	if (*destRgnp)
-	    REGION_UNION(pScreen, *destRgnp, *destRgnp, srcRgn);
+	    RegionUnion(*destRgnp, *destRgnp, srcRgn);
 	break;
     case ShapeIntersect:
 	if (*destRgnp)
-	    REGION_INTERSECT(pScreen, *destRgnp, *destRgnp, srcRgn);
+	    RegionIntersect(*destRgnp, *destRgnp, srcRgn);
 	else {
 	    *destRgnp = srcRgn;
 	    srcRgn = 0;
@@ -239,20 +239,20 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
     case ShapeSubtract:
 	if (!*destRgnp)
 	    *destRgnp = (*create)(pWin);
-	REGION_SUBTRACT(pScreen, *destRgnp, *destRgnp, srcRgn);
+	RegionSubtract(*destRgnp, *destRgnp, srcRgn);
 	break;
     case ShapeInvert:
 	if (!*destRgnp)
-	    *destRgnp = REGION_CREATE(pScreen, (BoxPtr) 0, 0);
+	    *destRgnp = RegionCreate((BoxPtr) 0, 0);
 	else
-	    REGION_SUBTRACT(pScreen, *destRgnp, srcRgn, *destRgnp);
+	    RegionSubtract(*destRgnp, srcRgn, *destRgnp);
 	break;
     default:
 	client->errorValue = op;
 	return BadValue;
     }
     if (srcRgn)
-	REGION_DESTROY(pScreen, srcRgn);
+	RegionDestroy(srcRgn);
     (*pScreen->SetShape) (pWin);
     SendShapeNotify (pWin, kind);
     return Success;
@@ -268,7 +268,7 @@ CreateBoundingShape (pWin)
     extents.y1 = -wBorderWidth (pWin);
     extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
     extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
-    return REGION_CREATE(pWin->drawable.pScreen, &extents, 1);
+    return RegionCreate(&extents, 1);
 }
 
 RegionPtr
@@ -281,7 +281,7 @@ CreateClipShape (pWin)
     extents.y1 = 0;
     extents.x2 = pWin->drawable.width;
     extents.y2 = pWin->drawable.height;
-    return REGION_CREATE(pWin->drawable.pScreen, &extents, 1);
+    return RegionCreate(&extents, 1);
 }
 
 static int
@@ -360,7 +360,7 @@ ProcShapeRectangles (client)
     ctype = VerifyRectOrder(nrects, prects, (int)stuff->ordering);
     if (ctype < 0)
 	return BadMatch;
-    srcRgn = RECTS_TO_REGION(pScreen, nrects, prects, ctype);
+    srcRgn = RegionFromRects(nrects, prects, ctype);
 
     if (!pWin->optional)
 	MakeWindowOptional (pWin);
@@ -455,7 +455,7 @@ ProcShapeMask (client)
 	if (pPixmap->drawable.pScreen != pScreen ||
 	    pPixmap->drawable.depth != 1)
 	    return BadMatch;
-	srcRgn = BITMAP_TO_REGION(pScreen, pPixmap);
+	srcRgn = BitmapToRegion(pScreen, pPixmap);
 	if (!srcRgn)
 	    return BadAlloc;
     }
@@ -581,8 +581,8 @@ ProcShapeCombine (client)
     }
 
     if (srcRgn) {
-        tmp = REGION_CREATE(pScreen, (BoxPtr) 0, 0);
-        REGION_COPY(pScreen, tmp, srcRgn);
+        tmp = RegionCreate((BoxPtr) 0, 0);
+        RegionCopy(tmp, srcRgn);
         srcRgn = tmp;
     } else
 	srcRgn = (*createSrc) (pSrcWin);
@@ -673,7 +673,7 @@ ProcShapeOffset (client)
     pScreen = pWin->drawable.pScreen;
     if (srcRgn)
     {
-        REGION_TRANSLATE(pScreen, srcRgn, stuff->xOff, stuff->yOff);
+        RegionTranslate(srcRgn, stuff->xOff, stuff->yOff);
         (*pScreen->SetShape) (pWin);
     }
     SendShapeNotify (pWin, (int)stuff->destKind);
@@ -729,7 +729,7 @@ ProcShapeQueryExtents (client)
     rep.clipShaped = (wClipShape(pWin) != 0);
     if ((region = wBoundingShape(pWin))) {
      /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
-	pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
+	pExtents = RegionExtents(region);
 	extents = *pExtents;
     } else {
 	extents.x1 = -wBorderWidth (pWin);
@@ -743,7 +743,7 @@ ProcShapeQueryExtents (client)
     rep.heightBoundingShape = extents.y2 - extents.y1;
     if ((region = wClipShape(pWin))) {
      /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
-	pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
+	pExtents = RegionExtents(region);
 	extents = *pExtents;
     } else {
 	extents.x1 = 0;
@@ -932,7 +932,7 @@ SendShapeNotify (pWin, which)
     case ShapeBounding:
 	region = wBoundingShape(pWin);
 	if (region) {
-	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
+	    extents = *RegionExtents(region);
 	    shaped = xTrue;
 	} else {
 	    extents.x1 = -wBorderWidth (pWin);
@@ -945,7 +945,7 @@ SendShapeNotify (pWin, which)
     case ShapeClip:
 	region = wClipShape(pWin);
 	if (region) {
-	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
+	    extents = *RegionExtents(region);
 	    shaped = xTrue;
 	} else {
 	    extents.x1 = 0;
@@ -958,7 +958,7 @@ SendShapeNotify (pWin, which)
     case ShapeInput:
 	region = wInputShape(pWin);
 	if (region) {
-	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
+	    extents = *RegionExtents(region);
 	    shaped = xTrue;
 	} else {
 	    extents.x1 = -wBorderWidth (pWin);
@@ -1087,8 +1087,8 @@ ProcShapeGetRectangles (client)
 	}
     } else {
 	BoxPtr box;
-	nrects = REGION_NUM_RECTS(region);
-	box = REGION_RECTS(region);
+	nrects = RegionNumRects(region);
+	box = RegionRects(region);
 	rects = (xRectangle *) ALLOCATE_LOCAL (nrects * sizeof (xRectangle));
 	if (!rects && nrects)
 	    return BadAlloc;
diff --git a/nx-X11/programs/Xserver/Xext/xcmisc.c b/nx-X11/programs/Xserver/Xext/xcmisc.c
index 1d7ad0e09..e353d65ac 100644
--- a/nx-X11/programs/Xserver/Xext/xcmisc.c
+++ b/nx-X11/programs/Xserver/Xext/xcmisc.c
@@ -44,11 +44,7 @@ from The Open Group.
 #include <nx-X11/extensions/xcmiscstr.h>
 #include "modinit.h"
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
 
 #if 0
 static unsigned char XCMiscCode;
diff --git a/nx-X11/programs/Xserver/Xext/xtest.c b/nx-X11/programs/Xserver/Xext/xtest.c
index 482ad91d4..8a03db5f9 100644
--- a/nx-X11/programs/Xserver/Xext/xtest.c
+++ b/nx-X11/programs/Xserver/Xext/xtest.c
@@ -402,11 +402,11 @@ ProcXTestFakeInput(client)
 	    int       i;
 	    int       x = ev->u.keyButtonPointer.rootX + panoramiXdataPtr[0].x;
 	    int       y = ev->u.keyButtonPointer.rootY + panoramiXdataPtr[0].y;
-	    if (!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+	    if (!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
 				 x, y, &box)) {
 		FOR_NSCREENS(i) {
 		    if (i == pScreen->myNum) continue;
-		    if (POINT_IN_REGION(pScreen,
+		    if (RegionContainsPoint(
 					&XineramaScreenRegions[i],
 					x, y, &box)) {
 			root = WindowTable[i];
diff --git a/nx-X11/programs/Xserver/Xi/Imakefile b/nx-X11/programs/Xserver/Xi/Imakefile
index 27e1f5df0..29190b711 100644
--- a/nx-X11/programs/Xserver/Xi/Imakefile
+++ b/nx-X11/programs/Xserver/Xi/Imakefile
@@ -83,7 +83,7 @@ XCOMM $XFree86: xc/programs/Xserver/Xi/Imakefile,v 3.2 1999/04/17 09:08:22 dawes
 		ungrdev.o \
 		ungrdevb.o \
 		ungrdevk.o 
-   INCLUDES = -I../include -I$(EXTINCSRC) -I$(XINCLUDESRC)
+   INCLUDES = -I../include -I$(EXTINCSRC) -I$(XINCLUDESRC) `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
 NormalLibraryTarget(xinput,$(OBJS))
diff --git a/nx-X11/programs/Xserver/composite/Imakefile b/nx-X11/programs/Xserver/composite/Imakefile
index c45aa7f6a..f121e0bbe 100644
--- a/nx-X11/programs/Xserver/composite/Imakefile
+++ b/nx-X11/programs/Xserver/composite/Imakefile
@@ -6,7 +6,8 @@
 
    INCLUDES =   -I../include -I../mi -I../Xext -I../render -I../xfixes \
 		-I../damageext -I../miext/damage -I$(EXTINCSRC) \
-		-I$(XINCLUDESRC)
+		-I$(XINCLUDESRC) \
+		`pkg-config --cflags-only-I pixman-1`
 
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
diff --git a/nx-X11/programs/Xserver/composite/compalloc.c b/nx-X11/programs/Xserver/composite/compalloc.c
index d496ee9ba..f66a90989 100644
--- a/nx-X11/programs/Xserver/composite/compalloc.c
+++ b/nx-X11/programs/Xserver/composite/compalloc.c
@@ -103,7 +103,7 @@ compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update)
 	if (wasMapped)
 	    UnmapWindow (pWin, FALSE);
 
-	REGION_NULL (pScreen, &cw->borderClip);
+	RegionNull(&cw->borderClip);
 	cw->update = CompositeRedirectAutomatic;
 	cw->clients = 0;
 	cw->oldx = COMP_ORIGIN_INVALID;
@@ -177,7 +177,7 @@ compFreeClientWindow (WindowPtr pWin, XID id)
 	if (cw->damage)
 	    DamageDestroy (cw->damage);
 	
-	REGION_UNINIT (pScreen, &cw->borderClip);
+	RegionUninit(&cw->borderClip);
     
 	pWin->devPrivates[CompWindowPrivateIndex].ptr = 0;
 	xfree (cw);
@@ -503,7 +503,7 @@ compFreePixmap (WindowPtr pWin)
      * case correctly.  Unmap adds the window borderClip to the
      * parent exposed area; regions beyond the parent cause crashes
      */
-    REGION_COPY (pScreen, &pWin->borderClip, &cw->borderClip);
+    RegionCopy(&pWin->borderClip, &cw->borderClip);
     pRedirectPixmap = (*pScreen->GetWindowPixmap) (pWin);
     pParentPixmap = (*pScreen->GetWindowPixmap) (pWin->parent);
     pWin->redirectDraw = FALSE;
diff --git a/nx-X11/programs/Xserver/composite/compext.c b/nx-X11/programs/Xserver/composite/compext.c
index d182da1fd..f57235d46 100644
--- a/nx-X11/programs/Xserver/composite/compext.c
+++ b/nx-X11/programs/Xserver/composite/compext.c
@@ -201,7 +201,7 @@ ProcCompositeCreateRegionFromBorderClip (ClientPtr client)
     pRegion = XFixesRegionCopy (pBorderClip);
     if (!pRegion)
 	return BadAlloc;
-    REGION_TRANSLATE (pScreen, pRegion, -pWin->drawable.x, -pWin->drawable.y);
+    RegionTranslate(pRegion, -pWin->drawable.x, -pWin->drawable.y);
     
     if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
diff --git a/nx-X11/programs/Xserver/composite/compwindow.c b/nx-X11/programs/Xserver/composite/compwindow.c
index 2bb581329..fbdc44420 100644
--- a/nx-X11/programs/Xserver/composite/compwindow.c
+++ b/nx-X11/programs/Xserver/composite/compwindow.c
@@ -79,10 +79,10 @@ compRepaintBorder (ClientPtr pClient, void * closure)
     {
 	RegionRec exposed;
 
-	REGION_NULL(pScreen, &exposed);
-	REGION_SUBTRACT(pScreen, &exposed, &pWindow->borderClip, &pWindow->winSize);
+	RegionNull(&exposed);
+	RegionSubtract(&exposed, &pWindow->borderClip, &pWindow->winSize);
 	(*pWindow->drawable.pScreen->PaintWindowBorder)(pWindow, &exposed, PW_BORDER);
-	REGION_UNINIT(pScreen, &exposed);
+	RegionUninit(&exposed);
     }
     return TRUE;
 }
@@ -245,7 +245,7 @@ compClipNotify (WindowPtr pWin, int dx, int dy)
 	if (cw->borderClipX != pWin->drawable.x || 
 	    cw->borderClipY != pWin->drawable.y)
 	{
-	    REGION_TRANSLATE (pScreen, &cw->borderClip,
+	    RegionTranslate(&cw->borderClip,
 			      pWin->drawable.x - cw->borderClipX,
 			      pWin->drawable.y - cw->borderClipY);
 	    cw->borderClipX = pWin->drawable.x;
@@ -492,14 +492,14 @@ compCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 	    
 	    dx = ptOldOrg.x - pWin->drawable.x;
 	    dy = ptOldOrg.y - pWin->drawable.y;
-	    REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
+	    RegionTranslate(prgnSrc, -dx, -dy);
 
-	    REGION_NULL (pWin->drawable.pScreen, &rgnDst);
+	    RegionNull(&rgnDst);
 
-	    REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst,
+	    RegionIntersect(&rgnDst,
 			     &pWin->borderClip, prgnSrc);
 	    
-	    REGION_TRANSLATE (pWin->drawable.pScreen, &rgnDst, 
+	    RegionTranslate(&rgnDst,
 			      -pPixmap->screen_x, -pPixmap->screen_y);
 	    
 	    dx = dx + pPixmap->screen_x - cw->oldx;
@@ -507,8 +507,8 @@ compCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 	    pGC = GetScratchGC (pPixmap->drawable.depth, pScreen);
 	    if (pGC)
 	    {
-		BoxPtr	pBox = REGION_RECTS (&rgnDst);
-		int	nBox = REGION_NUM_RECTS (&rgnDst);
+		BoxPtr	pBox = RegionRects (&rgnDst);
+		int	nBox = RegionNumRects (&rgnDst);
 		
 		ValidateGC(&pPixmap->drawable, pGC);
 		while (nBox--)
@@ -536,16 +536,16 @@ compCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
     if (ptOldOrg.x != pWin->drawable.x || ptOldOrg.y != pWin->drawable.y)
     {
 	if (dx || dy)
-	    REGION_TRANSLATE (pScreen, prgnSrc, dx, dy);
+	    RegionTranslate(prgnSrc, dx, dy);
 	(*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
 	if (dx || dy)
-	    REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
+	    RegionTranslate(prgnSrc, -dx, -dy);
     }
     else
     {
 	ptOldOrg.x -= dx;
 	ptOldOrg.y -= dy;
-	REGION_TRANSLATE (prgnSrc, prgnSrc,
+	RegionTranslate(prgnSrc,
 			  pWin->drawable.x - ptOldOrg.x,
 			  pWin->drawable.y - ptOldOrg.y);
 	DamageDamageRegion (&pWin->drawable, prgnSrc);
@@ -613,26 +613,26 @@ compSetRedirectBorderClip (WindowPtr pWin, RegionPtr pRegion)
     CompWindowPtr   cw = GetCompWindow (pWin);
     RegionRec	    damage;
 
-    REGION_NULL (pScreen, &damage);
+    RegionNull(&damage);
     /*
      * Align old border clip with new border clip
      */
-    REGION_TRANSLATE (pScreen, &cw->borderClip,
+    RegionTranslate(&cw->borderClip,
 		      pWin->drawable.x - cw->borderClipX,
 		      pWin->drawable.y - cw->borderClipY);
     /*
      * Compute newly visible portion of window for repaint
      */
-    REGION_SUBTRACT (pScreen, &damage, pRegion, &cw->borderClip);
+    RegionSubtract(&damage, pRegion, &cw->borderClip);
     /*
      * Report that as damaged so it will be redrawn
      */
     DamageDamageRegion (&pWin->drawable, &damage);
-    REGION_UNINIT (pScreen, &damage);
+    RegionUninit(&damage);
     /*
      * Save the new border clip region
      */
-    REGION_COPY (pScreen, &cw->borderClip, pRegion);
+    RegionCopy(&cw->borderClip, pRegion);
     cw->borderClipX = pWin->drawable.x;
     cw->borderClipY = pWin->drawable.y;
 }
@@ -694,18 +694,18 @@ compWindowUpdateAutomatic (WindowPtr pWin)
     /*
      * First move the region from window to screen coordinates
      */
-    REGION_TRANSLATE (pScreen, pRegion, 
+    RegionTranslate(pRegion,
 		      pWin->drawable.x, pWin->drawable.y);
     
     /*
      * Clip against the "real" border clip
      */
-    REGION_INTERSECT (pScreen, pRegion, pRegion, &cw->borderClip);
+    RegionIntersect(pRegion, pRegion, &cw->borderClip);
 
     /*
      * Now translate from screen to dest coordinates
      */
-    REGION_TRANSLATE (pScreen, pRegion, 
+    RegionTranslate(pRegion,
 		      -pParent->drawable.x, -pParent->drawable.y);
     
     /*
diff --git a/nx-X11/programs/Xserver/damageext/Imakefile b/nx-X11/programs/Xserver/damageext/Imakefile
index f7ce4573b..24dcee85c 100644
--- a/nx-X11/programs/Xserver/damageext/Imakefile
+++ b/nx-X11/programs/Xserver/damageext/Imakefile
@@ -5,7 +5,8 @@
        OBJS =	damageext.o
 
    INCLUDES =   -I../include -I../Xext -I../render -I../xfixes -I../miext/damage \
-		-I$(EXTINCSRC) -I$(XINCLUDESRC)
+		-I$(EXTINCSRC) -I$(XINCLUDESRC) \
+		`pkg-config --cflags-only-I pixman-1`
 
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index 33cbb5f7b..8d03dfed5 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -99,10 +99,10 @@ DamageExtReport (DamagePtr pDamage, RegionPtr pRegion, void *closure)
     switch (pDamageExt->level) {
     case DamageReportRawRegion:
     case DamageReportDeltaRegion:
-	DamageExtNotify (pDamageExt, REGION_RECTS(pRegion), REGION_NUM_RECTS(pRegion));
+	DamageExtNotify (pDamageExt, RegionRects(pRegion), RegionNumRects(pRegion));
 	break;
     case DamageReportBoundingBox:
-	DamageExtNotify (pDamageExt, REGION_EXTENTS(prScreen, pRegion), 1);
+	DamageExtNotify (pDamageExt, RegionExtents(pRegion), 1);
 	break;
     case DamageReportNonEmpty:
 	DamageExtNotify (pDamageExt, NullBox, 0);
@@ -261,14 +261,14 @@ ProcDamageSubtract (ClientPtr client)
 	if (pRepair)
 	{
 	    if (pParts)
-		REGION_INTERSECT (prScreen, pParts, DamageRegion (pDamage), pRepair);
+		RegionIntersect(pParts, DamageRegion (pDamage), pRepair);
 	    if (DamageSubtract (pDamage, pRepair))
 		DamageExtReport (pDamage, DamageRegion (pDamage), (void *) pDamageExt);
 	}
 	else
 	{
 	    if (pParts)
-		REGION_COPY (prScreen, pParts, DamageRegion (pDamage));
+		RegionCopy(pParts, DamageRegion (pDamage));
 	    DamageEmpty (pDamage);
 	}
     }
diff --git a/nx-X11/programs/Xserver/dbe/Imakefile b/nx-X11/programs/Xserver/dbe/Imakefile
index 9d9c3fd67..5e5eac4a1 100644
--- a/nx-X11/programs/Xserver/dbe/Imakefile
+++ b/nx-X11/programs/Xserver/dbe/Imakefile
@@ -17,7 +17,7 @@ XCOMM $XFree86: xc/programs/Xserver/dbe/Imakefile,v 3.10 2001/01/17 22:36:41 daw
 
        SRCS = dbe.c midbe.c 
        OBJS = dbe.o midbe.o 
-   INCLUDES = -I$(SERVERSRC)/include -I$(XINCLUDESRC) -I$(EXTINCSRC)  $(EXTRAINCLUDES)
+   INCLUDES = -I$(SERVERSRC)/include -I$(XINCLUDESRC) -I$(EXTINCSRC)  $(EXTRAINCLUDES) `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
 NormalLibraryObjectRule()
diff --git a/nx-X11/programs/Xserver/dix/Imakefile b/nx-X11/programs/Xserver/dix/Imakefile
index 47e617718..20be46390 100644
--- a/nx-X11/programs/Xserver/dix/Imakefile
+++ b/nx-X11/programs/Xserver/dix/Imakefile
@@ -17,15 +17,16 @@ FFS_OBJ = ffs.o
 
 SRCS = atom.c colormap.c cursor.c devices.c dispatch.c dixutils.c events.c \
 	extension.c gc.c globals.c glyphcurs.c grabs.c \
-	main.c property.c resource.c swaprep.c swapreq.c \
+	main.c property.c region.c resource.c swaprep.c swapreq.c \
 	tables.c window.c initatoms.c dixfonts.c privates.c pixmap.c $(FFS_SRC)
 OBJS = atom.o colormap.o cursor.o devices.o dispatch.o dixutils.o events.o \
 	extension.o gc.o globals.o glyphcurs.o grabs.o \
-	main.o property.o resource.o swaprep.o swapreq.o \
+	main.o property.o region.o resource.o swaprep.o swapreq.o \
 	tables.o window.o initatoms.o dixfonts.o privates.o pixmap.o $(FFS_OBJ)
 
     INCLUDES = -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) \
-	       -I$(SERVERSRC)/Xext -I$(SERVERSRC)/lbx
+	       -I$(SERVERSRC)/Xext -I$(SERVERSRC)/lbx \
+	       `pkg-config --cflags-only-I pixman-1`
     LINTLIBS = ../os/llib-los.ln
 
 /*
diff --git a/nx-X11/programs/Xserver/dix/atom.c b/nx-X11/programs/Xserver/dix/atom.c
index 583f2dafc..29e60be03 100644
--- a/nx-X11/programs/Xserver/dix/atom.c
+++ b/nx-X11/programs/Xserver/dix/atom.c
@@ -75,7 +75,7 @@ static NodePtr *nodeTable;
 void FreeAtom(NodePtr patom);
 
 Atom 
-MakeAtom(char *string, unsigned len, Bool makeit)
+MakeAtom(const char *string, unsigned len, Bool makeit)
 {
     register    NodePtr * np;
     unsigned i;
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index b6010e627..009e1ac08 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -1266,11 +1266,11 @@ ProcTranslateCoords(register ClientPtr client)
 		 * borderSize
 		 */
 		&& (!wBoundingShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen, 
+		    RegionContainsPoint(
 					&pWin->borderSize, x, y, &box))
 		
 		&& (!wInputShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen,
+		    RegionContainsPoint(
 				    wInputShape(pWin),
 				    x - pWin->drawable.x,
 				    y - pWin->drawable.y, &box))
@@ -1758,7 +1758,7 @@ ProcCopyArea(register ClientPtr client)
 	(*pDst->pScreen->SendGraphicsExpose)
  		(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
 	if (pRgn)
-	    REGION_DESTROY(pDst->pScreen, pRgn);
+	    RegionDestroy(pRgn);
     }
 
     return(client->noClientException);
@@ -1806,7 +1806,7 @@ ProcCopyPlane(register ClientPtr client)
 	(*pdstDraw->pScreen->SendGraphicsExpose)
  		(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
 	if (pRgn)
-	    REGION_DESTROY(pdstDraw->pScreen, pRgn);
+	    RegionDestroy(pRgn);
     }
     return(client->noClientException);
 }
@@ -2228,7 +2228,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
 	if (pVisibleRegion)
 	{
-	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion, -pDraw->x, -pDraw->y);
+	    RegionTranslate(pVisibleRegion, -pDraw->x, -pDraw->y);
 	}
     }
 #endif
@@ -2322,7 +2322,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
     }
 #ifdef XCSECURITY
     if (pVisibleRegion)
-	REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
+	RegionDestroy(pVisibleRegion);
 #endif
     if (!im_return)
 	DEALLOCATE_LOCAL(pBuf);
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index 6e515300d..1f92ff824 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -144,6 +144,8 @@ _NXGetFontPathError:
 
 #define QUERYCHARINFO(pci, pr)  *(pr) = (pci)->metrics
 
+extern void register_fpe_functions(void);
+
 extern void * fosNaturalParams;
 extern FontPtr defaultFont;
 
diff --git a/nx-X11/programs/Xserver/dix/dixutils.c b/nx-X11/programs/Xserver/dix/dixutils.c
index 8bcfce619..e91303851 100644
--- a/nx-X11/programs/Xserver/dix/dixutils.c
+++ b/nx-X11/programs/Xserver/dix/dixutils.c
@@ -171,7 +171,7 @@ ISOLatin1ToLower (unsigned char source)
 
 
 void
-CopyISOLatin1Lowered(unsigned char *dest, unsigned char *source, int length)
+CopyISOLatin1Lowered(char *dest, const char *source, int length)
 {
     register int i;
 
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 1166bf84b..3163270f4 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -346,14 +346,14 @@ XineramaSetCursorPosition(
     x += panoramiXdataPtr[0].x;
     y += panoramiXdataPtr[0].y;
 
-    if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+    if(!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
 								x, y, &box)) 
     {
 	FOR_NSCREENS(i) 
 	{
 	    if(i == pScreen->myNum) 
 		continue;
-	    if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i], x, y, &box))
+	    if(RegionContainsPoint(&XineramaScreenRegions[i], x, y, &box))
 	    {
 		pScreen = screenInfo.screens[i];
 		break;
@@ -483,7 +483,7 @@ XineramaCheckVirtualMotion(
 
 	i = PanoramiXNumScreens - 1;
 	
-	REGION_COPY(sprite.screen, &sprite.Reg2, 
+	RegionCopy(&sprite.Reg2,
 					&sprite.windows[i]->borderSize); 
 	off_x = panoramiXdataPtr[i].x;
 	off_y = panoramiXdataPtr[i].y;
@@ -493,16 +493,16 @@ XineramaCheckVirtualMotion(
 	    y = off_y - panoramiXdataPtr[i].y;
 
 	    if(x || y)
-		REGION_TRANSLATE(sprite.screen, &sprite.Reg2, x, y);
+		RegionTranslate(&sprite.Reg2, x, y);
 		
-	    REGION_UNION(sprite.screen, &sprite.Reg2, &sprite.Reg2, 
+	    RegionUnion(&sprite.Reg2, &sprite.Reg2,
 					&sprite.windows[i]->borderSize);
 
 	    off_x = panoramiXdataPtr[i].x;
 	    off_y = panoramiXdataPtr[i].y;
 	}
 
-	lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2);
+	lims = *RegionExtents(&sprite.Reg2);
 
         if (sprite.hot.x < lims.x1)
 #ifdef XEVIE
@@ -525,7 +525,7 @@ XineramaCheckVirtualMotion(
 #endif
             sprite.hot.y = lims.y2 - 1;
 
-	if (REGION_NUM_RECTS(&sprite.Reg2) > 1) 
+	if (RegionNumRects(&sprite.Reg2) > 1) 
 	    ConfineToShape(&sprite.Reg2, &sprite.hot.x, &sprite.hot.y);
 
 	if (qe)
@@ -632,7 +632,7 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
 
 	i = PanoramiXNumScreens - 1;
 	
-	REGION_COPY(sprite.screen, &sprite.Reg1, 
+	RegionCopy(&sprite.Reg1,
 					&sprite.windows[i]->borderSize); 
 	off_x = panoramiXdataPtr[i].x;
 	off_y = panoramiXdataPtr[i].y;
@@ -642,18 +642,18 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
 	    y = off_y - panoramiXdataPtr[i].y;
 
 	    if(x || y)
-		REGION_TRANSLATE(sprite.screen, &sprite.Reg1, x, y);
+		RegionTranslate(&sprite.Reg1, x, y);
 		
-	    REGION_UNION(sprite.screen, &sprite.Reg1, &sprite.Reg1, 
+	    RegionUnion(&sprite.Reg1, &sprite.Reg1,
 					&sprite.windows[i]->borderSize);
 
 	    off_x = panoramiXdataPtr[i].x;
 	    off_y = panoramiXdataPtr[i].y;
 	}
 
-	sprite.hotLimits = *REGION_EXTENTS(sprite.screen, &sprite.Reg1);
+	sprite.hotLimits = *RegionExtents(&sprite.Reg1);
 
-	if(REGION_NUM_RECTS(&sprite.Reg1) > 1)
+	if(RegionNumRects(&sprite.Reg1) > 1)
 	   sprite.hotShape = &sprite.Reg1;
 	else
 	   sprite.hotShape = NullRegion;
@@ -732,9 +732,9 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
     int x = *px, y = *py;
     int incx = 1, incy = 1;
 
-    if (POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box))
+    if (RegionContainsPoint(shape, x, y, &box))
 	return;
-    box = *REGION_EXTENTS(sprite.hot.pScreen, shape);
+    box = *RegionExtents(shape);
     /* this is rather crude */
     do {
 	x += incx;
@@ -756,7 +756,7 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
 	    else if (y < box.y1)
 		return; /* should never get here! */
 	}
-    } while (!POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box));
+    } while (!RegionContainsPoint(shape, x, y, &box));
     *px = x;
     *py = y;
 }
@@ -844,7 +844,7 @@ CheckVirtualMotion(
 #endif
 	    sprite.hot.x = sprite.hot.y = 0;
 	}
-	lims = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin->borderSize);
+	lims = *RegionExtents(&pWin->borderSize);
 	if (sprite.hot.x < lims.x1)
 #ifdef XEVIE
 	    xeviehot.x =
@@ -898,7 +898,7 @@ ConfineCursorToWindow(WindowPtr pWin, Bool generateEvents, Bool confineToScreen)
     }
     else
     {
-	sprite.hotLimits = *REGION_EXTENTS( pScreen, &pWin->borderSize);
+	sprite.hotLimits = *RegionExtents(&pWin->borderSize);
 #ifdef SHAPE
 	sprite.hotShape = wBoundingShape(pWin) ? &pWin->borderSize
 					       : NullRegion;
@@ -1972,7 +1972,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
 {
     BoxRec box;
 
-    if(POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderSize, x, y, &box))
+    if(RegionContainsPoint(&pWin->borderSize, x, y, &box))
 	return TRUE;
 
 #ifdef PANORAMIX
@@ -1980,7 +1980,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
 	int i;
 
 	for(i = 1; i < PanoramiXNumScreens; i++) {
-	   if(POINT_IN_REGION(sprite.screen, 
+	   if(RegionContainsPoint(
 			&sprite.windows[i]->borderSize, 
 			x + panoramiXdataPtr[0].x - panoramiXdataPtr[i].x, 
 			y + panoramiXdataPtr[0].y - panoramiXdataPtr[i].y, 
@@ -2016,7 +2016,7 @@ XYToWindow(int x, int y)
 	     */
 	    && (!wBoundingShape(pWin) || PointInBorderSize(pWin, x, y))
 	    && (!wInputShape(pWin) ||
-		POINT_IN_REGION(pWin->drawable.pScreen,
+		RegionContainsPoint(
 				wInputShape(pWin),
 				x - pWin->drawable.x,
 				y - pWin->drawable.y, &box))
@@ -2156,10 +2156,10 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
     sprite.hotLimits.x2 -= xoff;
     sprite.hotLimits.y2 -= yoff;
 
-    if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg1))
-        REGION_TRANSLATE(sprite.screen, &sprite.Reg1,    xoff, yoff);
-    if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg2))
-        REGION_TRANSLATE(sprite.screen, &sprite.Reg2,    xoff, yoff);
+    if (RegionNotEmpty(&sprite.Reg1))
+        RegionTranslate(&sprite.Reg1,    xoff, yoff);
+    if (RegionNotEmpty(&sprite.Reg2))
+        RegionTranslate(&sprite.Reg2,    xoff, yoff);
 
     /* FIXME: if we call ConfineCursorToWindow, must we do anything else? */
     if ((grab = inputInfo.pointer->grab) && grab->confineTo) {
@@ -2211,8 +2211,8 @@ DefineInitialRootWindow(register WindowPtr win)
 #endif
 	sprite.screen = pScreen;
 	/* gotta UNINIT these someplace */
-	REGION_NULL(pScreen, &sprite.Reg1);
-	REGION_NULL(pScreen, &sprite.Reg2);
+	RegionNull(&sprite.Reg1);
+	RegionNull(&sprite.Reg2);
     }
 #endif
 }
@@ -2278,7 +2278,7 @@ XineramaPointInWindowIsVisible(
 
     if (!pWin->realized) return FALSE;
 
-    if (POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box))
+    if (RegionContainsPoint(&pWin->borderClip, x, y, &box))
         return TRUE;
     
     if(!XineramaSetWindowPntrs(pWin)) return FALSE;
@@ -2292,9 +2292,9 @@ XineramaPointInWindowIsVisible(
 	x = xoff - panoramiXdataPtr[i].x;
 	y = yoff - panoramiXdataPtr[i].y;
 
-	if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box)
+	if(RegionContainsPoint(&pWin->borderClip, x, y, &box)
 	   && (!wInputShape(pWin) ||
-	       POINT_IN_REGION(pWin->drawable.pScreen,
+	       RegionContainsPoint(
 			       wInputShape(pWin),
 			       x - pWin->drawable.x, 
 			       y - pWin->drawable.y, &box)))
@@ -2470,7 +2470,7 @@ ProcWarpPointer(ClientPtr client)
 static Bool 
 BorderSizeNotEmpty(WindowPtr pWin)
 {
-     if(REGION_NOTEMPTY(sprite.hotPhys.pScreen, &pWin->borderSize))
+     if(RegionNotEmpty(&pWin->borderSize))
 	return TRUE;
 
 #ifdef PANORAMIX
@@ -2478,7 +2478,7 @@ BorderSizeNotEmpty(WindowPtr pWin)
 	int i;
 
 	for(i = 1; i < PanoramiXNumScreens; i++) {
-	    if(REGION_NOTEMPTY(sprite.screen, &sprite.windows[i]->borderSize))
+	    if(RegionNotEmpty(&sprite.windows[i]->borderSize))
 		return TRUE;
 	}
      }
diff --git a/nx-X11/programs/Xserver/mi/miregion.c b/nx-X11/programs/Xserver/dix/region.c
index 1df0dcc46..e927b9fde 100644
--- a/nx-X11/programs/Xserver/mi/miregion.c
+++ b/nx-X11/programs/Xserver/dix/region.c
@@ -81,11 +81,11 @@ Equipment Corporation.
 #include <dix-config.h>
 #endif
 
+#include <pixman.h>
+
 #include "regionstr.h"
 #include <nx-X11/Xprotostr.h>
 #include "gc.h"
-#include "mi.h"
-#include "mispans.h"
 
 #if defined (__GNUC__) && !defined (NO_INLINES)
 #define INLINE	__inline
@@ -102,7 +102,7 @@ Equipment Corporation.
 #define assert(expr)
 #endif
 
-#define good(reg) assert(miValidRegion(reg))
+#define good(reg) assert(RegionIsValid(reg))
 
 /*
  * The functions in this file implement the Region abstraction used extensively
@@ -145,7 +145,7 @@ Equipment Corporation.
  *
  * Adam de Boor wrote most of the original region code.  Joel McCormack
  * substantially modified or rewrote most of the core arithmetic routines,
- * and added miRegionValidate in order to support several speed improvements
+ * and added RegionValidate in order to support several speed improvements
  * to miValidateTree.  Bob Scheifler changed the representation to be more
  * compact when empty or a single rectangle, and did a bunch of gratuitous
  * reformatting.
@@ -176,11 +176,11 @@ Equipment Corporation.
 
 #define RECTALLOC_BAIL(pReg,n,bail) \
 if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
-    if (!miRectAlloc(pReg, n)) { goto bail; }
+    if (!RegionRectAlloc(pReg, n)) { goto bail; }
 
 #define RECTALLOC(pReg,n) \
 if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
-    if (!miRectAlloc(pReg, n)) { return FALSE; }
+    if (!RegionRectAlloc(pReg, n)) { return FALSE; }
 
 #define ADDRECT(pNextRect,nx1,ny1,nx2,ny2)	\
 {						\
@@ -195,9 +195,9 @@ if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
 {									\
     if (!(pReg)->data || ((pReg)->data->numRects == (pReg)->data->size))\
     {									\
-	if (!miRectAlloc(pReg, 1))					\
+	if (!RegionRectAlloc(pReg, 1))					\
 	    return FALSE;						\
-	pNextRect = REGION_TOP(pReg);					\
+	pNextRect = RegionTop(pReg);					\
     }									\
     ADDRECT(pNextRect,nx1,ny1,nx2,ny2);					\
     pReg->data->numRects++;						\
@@ -208,7 +208,7 @@ if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
 #define DOWNSIZE(reg,numRects)						 \
 if (((numRects) < ((reg)->data->size >> 1)) && ((reg)->data->size > 50)) \
 {									 \
-    size_t NewSize = REGION_SZOF(numRects);				 \
+    size_t NewSize = RegionSizeof(numRects);				 \
     RegDataPtr NewData =						 \
 	(NewSize > 0) ? (RegDataPtr)xrealloc((reg)->data, NewSize) : NULL;	 \
     if (NewData)							 \
@@ -219,24 +219,24 @@ if (((numRects) < ((reg)->data->size >> 1)) && ((reg)->data->size > 50)) \
 }
 
 
-BoxRec miEmptyBox = {0, 0, 0, 0};
-RegDataRec miEmptyData = {0, 0};
+pixman_box16_t RegionEmptyBox = {0, 0, 0, 0};
+RegDataRec RegionEmptyData = {0, 0};
 
-RegDataRec  miBrokenData = {0, 0};
-RegionRec   miBrokenRegion = { { 0, 0, 0, 0 }, &miBrokenData };
+RegDataRec  RegionBrokenData = {0, 0};
+RegionRec   RegionBrokenRegion = { { 0, 0, 0, 0 }, &RegionBrokenData };
 
 #ifdef DEBUG
 int
-miPrintRegion(rgn)
+RegionPrint(rgn)
     RegionPtr rgn;
 {
     int num, size;
     register int i;
     BoxPtr rects;
 
-    num = REGION_NUM_RECTS(rgn);
-    size = REGION_SIZE(rgn);
-    rects = REGION_RECTS(rgn);
+    num = RegionNumRects(rgn);
+    size = RegionSize(rgn);
+    rects = RegionRects(rgn);
     ErrorF("num: %d size: %d\n", num, size);
     ErrorF("extents: %d %d %d %d\n",
 	   rgn->extents.x1, rgn->extents.y1, rgn->extents.x2, rgn->extents.y2);
@@ -248,36 +248,9 @@ miPrintRegion(rgn)
 }
 #endif /* DEBUG */
 
-Bool
-miRegionEqual(reg1, reg2)
-    RegionPtr reg1;
-    RegionPtr reg2;
-{
-    int i, num;
-    BoxPtr rects1, rects2;
-
-    if (reg1->extents.x1 != reg2->extents.x1) return FALSE;
-    if (reg1->extents.x2 != reg2->extents.x2) return FALSE;
-    if (reg1->extents.y1 != reg2->extents.y1) return FALSE;
-    if (reg1->extents.y2 != reg2->extents.y2) return FALSE;
-
-    num = REGION_NUM_RECTS(reg1);
-    if (num != REGION_NUM_RECTS(reg2)) return FALSE;
-    
-    rects1 = REGION_RECTS(reg1);
-    rects2 = REGION_RECTS(reg2);
-    for (i = 0; i != num; i++) {
-	if (rects1[i].x1 != rects2[i].x1) return FALSE;
-	if (rects1[i].x2 != rects2[i].x2) return FALSE;
-	if (rects1[i].y1 != rects2[i].y1) return FALSE;
-	if (rects1[i].y2 != rects2[i].y2) return FALSE;
-    }
-    return TRUE;
-}
-
 #ifdef DEBUG
 Bool
-miValidRegion(reg)
+RegionIsValid(reg)
     RegionPtr reg;
 {
     register int i, numRects;
@@ -285,11 +258,11 @@ miValidRegion(reg)
     if ((reg->extents.x1 > reg->extents.x2) ||
 	(reg->extents.y1 > reg->extents.y2))
 	return FALSE;
-    numRects = REGION_NUM_RECTS(reg);
+    numRects = RegionNumRects(reg);
     if (!numRects)
 	return ((reg->extents.x1 == reg->extents.x2) &&
 		(reg->extents.y1 == reg->extents.y2) &&
-		(reg->data->size || (reg->data == &miEmptyData)));
+		(reg->data->size || (reg->data == &RegionEmptyData)));
     else if (numRects == 1)
 	return (!reg->data);
     else
@@ -297,7 +270,7 @@ miValidRegion(reg)
 	register BoxPtr pboxP, pboxN;
 	BoxRec box;
 
-	pboxP = REGION_RECTS(reg);
+	pboxP = RegionRects(reg);
 	box = *pboxP;
 	box.y2 = pboxP[numRects-1].y2;
 	pboxN = pboxP + 1;
@@ -332,7 +305,7 @@ miValidRegion(reg)
  *****************************************************************/
 
 RegionPtr
-miRegionCreate(rect, size)
+RegionCreate(rect, size)
     BoxPtr rect;
     int size;
 {
@@ -340,7 +313,7 @@ miRegionCreate(rect, size)
     size_t newSize;
     pReg = (RegionPtr)xalloc(sizeof(RegionRec));
     if (!pReg)
-	return &miBrokenRegion;
+	return &RegionBrokenRegion;
     if (rect)
     {
 	pReg->extents = *rect;
@@ -348,8 +321,8 @@ miRegionCreate(rect, size)
     }
     else
     {
-	pReg->extents = miEmptyBox;
-	newSize = REGION_SZOF(size);
+	pReg->extents = RegionEmptyBox;
+	newSize = RegionSizeof(size);
 	if ((size > 1) && (newSize > 0) &&
 	    (pReg->data = xalloc(newSize)))
 	{
@@ -357,74 +330,33 @@ miRegionCreate(rect, size)
 	    pReg->data->numRects = 0;
 	}
 	else
-	    pReg->data = &miEmptyData;
+	    pReg->data = &RegionEmptyData;
     }
     return(pReg);
 }
 
-/*****************************************************************
- *   RegionInit(pReg, rect, size)
- *     Outer region rect is statically allocated.
- *****************************************************************/
-
-void
-miRegionInit(pReg, rect, size)
-    RegionPtr pReg;
-    BoxPtr rect;
-    int size;
-{
-    size_t newSize;
-
-    if (rect)
-    {
-	pReg->extents = *rect;
-	pReg->data = (RegDataPtr)NULL;
-    }
-    else
-    {
-	pReg->extents = miEmptyBox;
-	newSize = REGION_SZOF(size);
-	if ((size > 1) && (newSize > 0) &&
-	    (pReg->data = xalloc(newSize)))
-	{
-	    pReg->data->size = size;
-	    pReg->data->numRects = 0;
-	}
-	else
-	    pReg->data = &miEmptyData;
-    }
-}
-
 void
-miRegionDestroy(pReg)
+RegionDestroy(pReg)
     RegionPtr pReg;
 {
     good(pReg);
     xfreeData(pReg);
-    if (pReg != &miBrokenRegion)
+    if (pReg != &RegionBrokenRegion)
 	xfree(pReg);
 }
 
-void
-miRegionUninit(pReg)
-    RegionPtr pReg;
-{
-    good(pReg);
-    xfreeData(pReg);
-}
-
 Bool
-miRegionBreak (pReg)
+RegionBreak (pReg)
     RegionPtr pReg;
 {
     xfreeData (pReg);
-    pReg->extents = miEmptyBox;
-    pReg->data = &miBrokenData;
+    pReg->extents = RegionEmptyBox;
+    pReg->data = &RegionBrokenData;
     return FALSE;
 }
 
 Bool
-miRectAlloc(
+RegionRectAlloc(
     register RegionPtr pRgn,
     int n)
 {
@@ -434,19 +366,19 @@ miRectAlloc(
     if (!pRgn->data)
     {
 	n++;
-	rgnSize = REGION_SZOF(n);
+	rgnSize = RegionSizeof(n);
 	pRgn->data = (rgnSize > 0) ? xalloc(rgnSize) : NULL;
 	if (!pRgn->data)
-	    return miRegionBreak (pRgn);
+	    return RegionBreak (pRgn);
 	pRgn->data->numRects = 1;
-	*REGION_BOXPTR(pRgn) = pRgn->extents;
+	*RegionBoxptr(pRgn) = pRgn->extents;
     }
     else if (!pRgn->data->size)
     {
-	rgnSize = REGION_SZOF(n);
+	rgnSize = RegionSizeof(n);
 	pRgn->data = (rgnSize > 0) ? xalloc(rgnSize) : NULL;
 	if (!pRgn->data)
-	    return miRegionBreak (pRgn);
+	    return RegionBreak (pRgn);
 	pRgn->data->numRects = 0;
     }
     else
@@ -458,47 +390,16 @@ miRectAlloc(
 		n = 250;
 	}
 	n += pRgn->data->numRects;
-	rgnSize = REGION_SZOF(n);
+	rgnSize = RegionSizeof(n);
 	data = (rgnSize > 0) ? xrealloc(pRgn->data, rgnSize) : NULL;
 	if (!data)
-	    return miRegionBreak (pRgn);
+	    return RegionBreak (pRgn);
 	pRgn->data = data;
     }
     pRgn->data->size = n;
     return TRUE;
 }
 
-Bool
-miRegionCopy(dst, src)
-    register RegionPtr dst;
-    register RegionPtr src;
-{
-    good(dst);
-    good(src);
-    if (dst == src)
-	return TRUE;
-    dst->extents = src->extents;
-    if (!src->data || !src->data->size)
-    {
-	xfreeData(dst);
-	dst->data = src->data;
-	return TRUE;
-    }
-    if (!dst->data || (dst->data->size < src->data->numRects))
-    {
-	size_t newSize = REGION_SZOF(src->data->numRects);
-	xfreeData(dst);
-
-	dst->data = newSize > 0 ? xalloc(newSize) : NULL;
-	if (!dst->data)
-	    return miRegionBreak (dst);
-	dst->data->size = src->data->numRects;
-    }
-    dst->data->numRects = src->data->numRects;
-    memmove((char *)REGION_BOXPTR(dst),(char *)REGION_BOXPTR(src), 
-	  dst->data->numRects * sizeof(BoxRec));
-    return TRUE;
-}
 
 
 /*======================================================================
@@ -507,10 +408,10 @@ miRegionCopy(dst, src)
 
 /*-
  *-----------------------------------------------------------------------
- * miCoalesce --
+ * RegionCoalesce --
  *	Attempt to merge the boxes in the current band with those in the
  *	previous one.  We are guaranteed that the current band extends to
- *      the end of the rects array.  Used only by miRegionOp.
+ *      the end of the rects array.  Used only by RegionOp.
  *
  * Results:
  *	The new index for the previous band.
@@ -524,7 +425,7 @@ miRegionCopy(dst, src)
  *-----------------------------------------------------------------------
  */
 INLINE static int
-miCoalesce (
+RegionCoalesce (
     register RegionPtr	pReg,	    	/* Region to coalesce		     */
     int	    	  	prevStart,  	/* Index of start of previous band   */
     int	    	  	curStart)   	/* Index of start of current band    */
@@ -545,8 +446,8 @@ miCoalesce (
      * The bands may only be coalesced if the bottom of the previous
      * matches the top scanline of the current.
      */
-    pPrevBox = REGION_BOX(pReg, prevStart);
-    pCurBox = REGION_BOX(pReg, curStart);
+    pPrevBox = RegionBox(pReg, prevStart);
+    pCurBox = RegionBox(pReg, curStart);
     if (pPrevBox->y2 != pCurBox->y1) return curStart;
 
     /*
@@ -581,18 +482,18 @@ miCoalesce (
 }
 
 
-/* Quicky macro to avoid trivial reject procedure calls to miCoalesce */
+/* Quicky macro to avoid trivial reject procedure calls to RegionCoalesce */
 
 #define Coalesce(newReg, prevBand, curBand)				\
     if (curBand - prevBand == newReg->data->numRects - curBand) {	\
-	prevBand = miCoalesce(newReg, prevBand, curBand);		\
+	prevBand = RegionCoalesce(newReg, prevBand, curBand);		\
     } else {								\
 	prevBand = curBand;						\
     }
 
 /*-
  *-----------------------------------------------------------------------
- * miAppendNonO --
+ * RegionAppendNonO --
  *	Handle a non-overlapping band for the union and subtract operations.
  *      Just adds the (top/bottom-clipped) rectangles into the region.
  *      Doesn't have to check for subsumption or anything.
@@ -608,7 +509,7 @@ miCoalesce (
  */
 
 INLINE static Bool
-miAppendNonO (
+RegionAppendNonO (
     register RegionPtr	pReg,
     register BoxPtr	r,
     BoxPtr  	  	rEnd,
@@ -625,7 +526,7 @@ miAppendNonO (
 
     /* Make sure we have enough space for all rectangles to be added */
     RECTALLOC(pReg, newRects);
-    pNextRect = REGION_TOP(pReg);
+    pNextRect = RegionTop(pReg);
     pReg->data->numRects += newRects;
     do {
 	assert(r->x1 < r->x2);
@@ -650,7 +551,7 @@ miAppendNonO (
     int newRects;							\
     if ((newRects = rEnd - r)) {					\
 	RECTALLOC(newReg, newRects);					\
-	memmove((char *)REGION_TOP(newReg),(char *)r, 			\
+	memmove((char *)RegionTop(newReg),(char *)r, 			\
               newRects * sizeof(BoxRec));				\
 	newReg->data->numRects += newRects;				\
     }									\
@@ -658,9 +559,9 @@ miAppendNonO (
 
 /*-
  *-----------------------------------------------------------------------
- * miRegionOp --
- *	Apply an operation to two regions. Called by miUnion, miInverse,
- *	miSubtract, miIntersect....  Both regions MUST have at least one
+ * RegionOp --
+ *	Apply an operation to two regions. Called by RegionUnion, RegionInverse,
+ *	RegionSubtract, RegionIntersect....  Both regions MUST have at least one
  *      rectangle, and cannot be the same object.
  *
  * Results:
@@ -696,7 +597,7 @@ typedef Bool (*OverlapProcPtr)(
     Bool	*pOverlap);
 
 static Bool
-miRegionOp(
+RegionOp(
     RegionPtr       newReg,		    /* Place to store result	     */
     RegionPtr       reg1,		    /* First region in operation     */
     RegionPtr       reg2,		    /* 2d region in operation        */
@@ -731,8 +632,8 @@ miRegionOp(
     /*
      * Break any region computed from a broken region
      */
-    if (REGION_NAR (reg1) || REGION_NAR(reg2))
-	return miRegionBreak (newReg);
+    if (RegionNar (reg1) || RegionNar(reg2))
+	return RegionBreak (newReg);
     
     /*
      * Initialization:
@@ -742,11 +643,11 @@ miRegionOp(
      * another array of rectangles for it to use.
      */
 
-    r1 = REGION_RECTS(reg1);
-    newSize = REGION_NUM_RECTS(reg1);
+    r1 = RegionRects(reg1);
+    newSize = RegionNumRects(reg1);
     r1End = r1 + newSize;
-    numRects = REGION_NUM_RECTS(reg2);
-    r2 = REGION_RECTS(reg2);
+    numRects = RegionNumRects(reg2);
+    r2 = RegionRects(reg2);
     r2End = r2 + numRects;
     assert(r1 != r1End);
     assert(r2 != r2End);
@@ -756,18 +657,18 @@ miRegionOp(
 	((newReg == reg2) && (numRects > 1)))
     {
 	oldData = newReg->data;
-	newReg->data = &miEmptyData;
+	newReg->data = &RegionEmptyData;
     }
     /* guess at new size */
     if (numRects > newSize)
 	newSize = numRects;
     newSize <<= 1;
     if (!newReg->data)
-	newReg->data = &miEmptyData;
+	newReg->data = &RegionEmptyData;
     else if (newReg->data->size)
 	newReg->data->numRects = 0;
     if (newSize > newReg->data->size)
-	if (!miRectAlloc(newReg, newSize))
+	if (!RegionRectAlloc(newReg, newSize))
 	    return FALSE;
 
     /*
@@ -788,7 +689,7 @@ miRegionOp(
     
     /*
      * prevBand serves to mark the start of the previous band so rectangles
-     * can be coalesced into larger rectangles. qv. miCoalesce, above.
+     * can be coalesced into larger rectangles. qv. RegionCoalesce, above.
      * In the beginning, there is no previous band, so prevBand == curBand
      * (curBand is set later on, of course, but the first band will always
      * start at index 0). prevBand and curBand must be indices because of
@@ -825,7 +726,7 @@ miRegionOp(
 		bot = min(r1->y2, r2y1);
 		if (top != bot)	{
 		    curBand = newReg->data->numRects;
-		    miAppendNonO(newReg, r1, r1BandEnd, top, bot);
+		    RegionAppendNonO(newReg, r1, r1BandEnd, top, bot);
 		    Coalesce(newReg, prevBand, curBand);
 		}
 	    }
@@ -836,7 +737,7 @@ miRegionOp(
 		bot = min(r2->y2, r1y1);
 		if (top != bot) {
 		    curBand = newReg->data->numRects;
-		    miAppendNonO(newReg, r2, r2BandEnd, top, bot);
+		    RegionAppendNonO(newReg, r2, r2BandEnd, top, bot);
 		    Coalesce(newReg, prevBand, curBand);
 		}
 	    }
@@ -878,7 +779,7 @@ miRegionOp(
 	/* Do first nonOverlap1Func call, which may be able to coalesce */
 	FindBand(r1, r1BandEnd, r1End, r1y1);
 	curBand = newReg->data->numRects;
-	miAppendNonO(newReg, r1, r1BandEnd, max(r1y1, ybot), r1->y2);
+	RegionAppendNonO(newReg, r1, r1BandEnd, max(r1y1, ybot), r1->y2);
 	Coalesce(newReg, prevBand, curBand);
 	/* Just append the rest of the boxes  */
 	AppendRegions(newReg, r1BandEnd, r1End);
@@ -887,7 +788,7 @@ miRegionOp(
 	/* Do first nonOverlap2Func call, which may be able to coalesce */
 	FindBand(r2, r2BandEnd, r2End, r2y1);
 	curBand = newReg->data->numRects;
-	miAppendNonO(newReg, r2, r2BandEnd, max(r2y1, ybot), r2->y2);
+	RegionAppendNonO(newReg, r2, r2BandEnd, max(r2y1, ybot), r2->y2);
 	Coalesce(newReg, prevBand, curBand);
 	/* Append rest of boxes */
 	AppendRegions(newReg, r2BandEnd, r2End);
@@ -899,11 +800,11 @@ miRegionOp(
     if (!(numRects = newReg->data->numRects))
     {
 	xfreeData(newReg);
-	newReg->data = &miEmptyData;
+	newReg->data = &RegionEmptyData;
     }
     else if (numRects == 1)
     {
-	newReg->extents = *REGION_BOXPTR(newReg);
+	newReg->extents = *RegionBoxptr(newReg);
 	xfreeData(newReg);
 	newReg->data = (RegDataPtr)NULL;
     }
@@ -917,10 +818,10 @@ miRegionOp(
 
 /*-
  *-----------------------------------------------------------------------
- * miSetExtents --
+ * RegionSetExtents --
  *	Reset the extents of a region to what they should be. Called by
- *	miSubtract and miIntersect as they can't figure it out along the
- *	way or do so easily, as miUnion can.
+ *	RegionSubtract and RegionIntersect as they can't figure it out along the
+ *	way or do so easily, as RegionUnion can.
  *
  * Results:
  *	None.
@@ -931,7 +832,7 @@ miRegionOp(
  *-----------------------------------------------------------------------
  */
 void
-miSetExtents (pReg)
+RegionSetExtents (pReg)
     register RegionPtr pReg;
 {
     register BoxPtr pBox, pBoxEnd;
@@ -945,8 +846,8 @@ miSetExtents (pReg)
 	return;
     }
 
-    pBox = REGION_BOXPTR(pReg);
-    pBoxEnd = REGION_END(pReg);
+    pBox = RegionBoxptr(pReg);
+    pBoxEnd = RegionEnd(pReg);
 
     /*
      * Since pBox is the first rectangle in the region, it must have the
@@ -972,132 +873,6 @@ miSetExtents (pReg)
     assert(pReg->extents.x1 < pReg->extents.x2);
 }
 
-/*======================================================================
- *	    Region Intersection
- *====================================================================*/
-/*-
- *-----------------------------------------------------------------------
- * miIntersectO --
- *	Handle an overlapping band for miIntersect.
- *
- * Results:
- *	TRUE if successful.
- *
- * Side Effects:
- *	Rectangles may be added to the region.
- *
- *-----------------------------------------------------------------------
- */
-/*ARGSUSED*/
-static Bool
-miIntersectO (
-    register RegionPtr	pReg,
-    register BoxPtr	r1,
-    BoxPtr  	  	r1End,
-    register BoxPtr	r2,
-    BoxPtr  	  	r2End,
-    short    	  	y1,
-    short    	  	y2,
-    Bool		*pOverlap)
-{
-    register int  	x1;
-    register int  	x2;
-    register BoxPtr	pNextRect;
-
-    pNextRect = REGION_TOP(pReg);
-
-    assert(y1 < y2);
-    assert(r1 != r1End && r2 != r2End);
-
-    do {
-	x1 = max(r1->x1, r2->x1);
-	x2 = min(r1->x2, r2->x2);
-
-	/*
-	 * If there's any overlap between the two rectangles, add that
-	 * overlap to the new region.
-	 */
-	if (x1 < x2)
-	    NEWRECT(pReg, pNextRect, x1, y1, x2, y2);
-
-	/*
-	 * Advance the pointer(s) with the leftmost right side, since the next
-	 * rectangle on that list may still overlap the other region's
-	 * current rectangle.
-	 */
-	if (r1->x2 == x2) {
-	    r1++;
-	}
-	if (r2->x2 == x2) {
-	    r2++;
-	}
-    } while ((r1 != r1End) && (r2 != r2End));
-
-    return TRUE;
-}
-
-
-Bool
-miIntersect(newReg, reg1, reg2)
-    register RegionPtr 	newReg;     /* destination Region */
-    register RegionPtr 	reg1;
-    register RegionPtr	reg2;       /* source regions     */
-{
-    good(reg1);
-    good(reg2);
-    good(newReg);
-   /* check for trivial reject */
-    if (REGION_NIL(reg1)  || REGION_NIL(reg2) ||
-	!EXTENTCHECK(&reg1->extents, &reg2->extents))
-    {
-	/* Covers about 20% of all cases */
-	xfreeData(newReg);
-	newReg->extents.x2 = newReg->extents.x1;
-	newReg->extents.y2 = newReg->extents.y1;
-	if (REGION_NAR(reg1) || REGION_NAR(reg2))
-	{
-	    newReg->data = &miBrokenData;
-	    return FALSE;
-	}
-	else
-	    newReg->data = &miEmptyData;
-    }
-    else if (!reg1->data && !reg2->data)
-    {
-	/* Covers about 80% of cases that aren't trivially rejected */
-	newReg->extents.x1 = max(reg1->extents.x1, reg2->extents.x1);
-	newReg->extents.y1 = max(reg1->extents.y1, reg2->extents.y1);
-	newReg->extents.x2 = min(reg1->extents.x2, reg2->extents.x2);
-	newReg->extents.y2 = min(reg1->extents.y2, reg2->extents.y2);
-	xfreeData(newReg);
-	newReg->data = (RegDataPtr)NULL;
-    }
-    else if (!reg2->data && SUBSUMES(&reg2->extents, &reg1->extents))
-    {
-	return miRegionCopy(newReg, reg1);
-    }
-    else if (!reg1->data && SUBSUMES(&reg1->extents, &reg2->extents))
-    {
-	return miRegionCopy(newReg, reg2);
-    }
-    else if (reg1 == reg2)
-    {
-	return miRegionCopy(newReg, reg1);
-    }
-    else
-    {
-	/* General purpose intersection */
-	Bool overlap; /* result ignored */
-	if (!miRegionOp(newReg, reg1, reg2, miIntersectO, FALSE, FALSE,
-			&overlap))
-	    return FALSE;
-	miSetExtents(newReg);
-    }
-
-    good(newReg);
-    return(TRUE);
-}
-
 #define MERGERECT(r)						\
 {								\
     if (r->x1 <= x2) {						\
@@ -1119,7 +894,7 @@ miIntersect(newReg, reg1, reg2)
 
 /*-
  *-----------------------------------------------------------------------
- * miUnionO --
+ * RegionUnionO --
  *	Handle an overlapping band for the union operation. Picks the
  *	left-most rectangle each time and merges it into the region.
  *
@@ -1133,7 +908,7 @@ miIntersect(newReg, reg1, reg2)
  *-----------------------------------------------------------------------
  */
 static Bool
-miUnionO (
+RegionUnionO (
     register RegionPtr	pReg,
     register BoxPtr	r1,
 	     BoxPtr  	r1End,
@@ -1150,7 +925,7 @@ miUnionO (
     assert (y1 < y2);
     assert(r1 != r1End && r2 != r2End);
 
-    pNextRect = REGION_TOP(pReg);
+    pNextRect = RegionTop(pReg);
 
     /* Start off current rectangle */
     if (r1->x1 < r2->x1)
@@ -1192,97 +967,19 @@ miUnionO (
     return TRUE;
 }
 
-Bool 
-miUnion(newReg, reg1, reg2)
-    RegionPtr		newReg;                  /* destination Region */
-    register RegionPtr 	reg1;
-    register RegionPtr	reg2;             /* source regions     */
-{
-    Bool overlap; /* result ignored */
-
-    /* Return TRUE if some overlap between reg1, reg2 */
-    good(reg1);
-    good(reg2);
-    good(newReg);
-    /*  checks all the simple cases */
-
-    /*
-     * Region 1 and 2 are the same
-     */
-    if (reg1 == reg2)
-    {
-	return miRegionCopy(newReg, reg1);
-    }
-
-    /*
-     * Region 1 is empty
-     */
-    if (REGION_NIL(reg1))
-    {
-	if (REGION_NAR(reg1))
-	    return miRegionBreak (newReg);
-        if (newReg != reg2)
-	    return miRegionCopy(newReg, reg2);
-        return TRUE;
-    }
-
-    /*
-     * Region 2 is empty
-     */
-    if (REGION_NIL(reg2))
-    {
-	if (REGION_NAR(reg2))
-	    return miRegionBreak (newReg);
-        if (newReg != reg1)
-	    return miRegionCopy(newReg, reg1);
-        return TRUE;
-    }
-
-    /*
-     * Region 1 completely subsumes region 2
-     */
-    if (!reg1->data && SUBSUMES(&reg1->extents, &reg2->extents))
-    {
-        if (newReg != reg1)
-	    return miRegionCopy(newReg, reg1);
-        return TRUE;
-    }
-
-    /*
-     * Region 2 completely subsumes region 1
-     */
-    if (!reg2->data && SUBSUMES(&reg2->extents, &reg1->extents))
-    {
-        if (newReg != reg2)
-	    return miRegionCopy(newReg, reg2);
-        return TRUE;
-    }
-
-    if (!miRegionOp(newReg, reg1, reg2, miUnionO, TRUE, TRUE, &overlap))
-	return FALSE;
-
-    newReg->extents.x1 = min(reg1->extents.x1, reg2->extents.x1);
-    newReg->extents.y1 = min(reg1->extents.y1, reg2->extents.y1);
-    newReg->extents.x2 = max(reg1->extents.x2, reg2->extents.x2);
-    newReg->extents.y2 = max(reg1->extents.y2, reg2->extents.y2);
-    good(newReg);
-    return TRUE;
-}
-
-
 /*======================================================================
  *	    Batch Rectangle Union
  *====================================================================*/
 
 /*-
  *-----------------------------------------------------------------------
- * miRegionAppend --
+ * RegionAppend --
  * 
  *      "Append" the rgn rectangles onto the end of dstrgn, maintaining
  *      knowledge of YX-banding when it's easy.  Otherwise, dstrgn just
  *      becomes a non-y-x-banded random collection of rectangles, and not
  *      yet a true region.  After a sequence of appends, the caller must
- *      call miRegionValidate to ensure that a valid region is constructed.
+ *      call RegionValidate to ensure that a valid region is constructed.
  *
  * Results:
  *	TRUE if successful.
@@ -1292,7 +989,7 @@ miUnion(newReg, reg1, reg2)
  *
  */
 Bool
-miRegionAppend(dstrgn, rgn)
+RegionAppend(dstrgn, rgn)
     register RegionPtr dstrgn;
     register RegionPtr rgn;
 {
@@ -1300,26 +997,26 @@ miRegionAppend(dstrgn, rgn)
     BoxPtr new, old;
     Bool prepend;
 
-    if (REGION_NAR(rgn))
-	return miRegionBreak (dstrgn);
+    if (RegionNar(rgn))
+	return RegionBreak (dstrgn);
     
-    if (!rgn->data && (dstrgn->data == &miEmptyData))
+    if (!rgn->data && (dstrgn->data == &RegionEmptyData))
     {
 	dstrgn->extents = rgn->extents;
 	dstrgn->data = (RegDataPtr)NULL;
 	return TRUE;
     }
 
-    numRects = REGION_NUM_RECTS(rgn);
+    numRects = RegionNumRects(rgn);
     if (!numRects)
 	return TRUE;
     prepend = FALSE;
     size = numRects;
-    dnumRects = REGION_NUM_RECTS(dstrgn);
+    dnumRects = RegionNumRects(dstrgn);
     if (!dnumRects && (size < 200))
 	size = 200; /* XXX pick numbers out of a hat */
     RECTALLOC(dstrgn, size);
-    old = REGION_RECTS(rgn);
+    old = RegionRects(rgn);
     if (!dnumRects)
 	dstrgn->extents = rgn->extents;
     else if (dstrgn->extents.x2 > dstrgn->extents.x1)
@@ -1327,7 +1024,7 @@ miRegionAppend(dstrgn, rgn)
 	register BoxPtr first, last;
 
 	first = old;
-	last = REGION_BOXPTR(dstrgn) + (dnumRects - 1);
+	last = RegionBoxptr(dstrgn) + (dnumRects - 1);
 	if ((first->y1 > last->y2) ||
 	    ((first->y1 == last->y1) && (first->y2 == last->y2) &&
 	     (first->x1 > last->x2)))
@@ -1340,7 +1037,7 @@ miRegionAppend(dstrgn, rgn)
 	}
 	else
 	{
-	    first = REGION_BOXPTR(dstrgn);
+	    first = RegionBoxptr(dstrgn);
 	    last = old + (numRects - 1);
 	    if ((first->y1 > last->y2) ||
 		((first->y1 == last->y1) && (first->y2 == last->y2) &&
@@ -1359,16 +1056,16 @@ miRegionAppend(dstrgn, rgn)
     }
     if (prepend)
     {
-	new = REGION_BOX(dstrgn, numRects);
+	new = RegionBox(dstrgn, numRects);
 	if (dnumRects == 1)
-	    *new = *REGION_BOXPTR(dstrgn);
+	    *new = *RegionBoxptr(dstrgn);
 	else
-	    memmove((char *)new,(char *)REGION_BOXPTR(dstrgn), 
+	    memmove((char *)new,(char *)RegionBoxptr(dstrgn), 
 		  dnumRects * sizeof(BoxRec));
-	new = REGION_BOXPTR(dstrgn);
+	new = RegionBoxptr(dstrgn);
     }
     else
-	new = REGION_BOXPTR(dstrgn) + dnumRects;
+	new = RegionBoxptr(dstrgn) + dnumRects;
     if (numRects == 1)
 	*new = *old;
     else
@@ -1447,7 +1144,7 @@ QuickSortRects(
 
 /*-
  *-----------------------------------------------------------------------
- * miRegionValidate --
+ * RegionValidate --
  * 
  *      Take a ``region'' which is a non-y-x-banded random collection of
  *      rectangles, and compute a nice region which is the union of all the
@@ -1471,14 +1168,14 @@ QuickSortRects(
  *		or a coalescing into 1 box (ala Menus).
  *
  *	Step 3. Merge the separate regions down to a single region by calling
- *		miUnion.  Maximize the work each miUnion call does by using
+ *		RegionUnion.  Maximize the work each RegionUnion call does by using
  *		a binary merge.
  *
  *-----------------------------------------------------------------------
  */
 
 Bool
-miRegionValidate(badreg, pOverlap)
+RegionValidate(badreg, pOverlap)
     RegionPtr badreg;
     Bool *pOverlap;
 {
@@ -1511,7 +1208,7 @@ miRegionValidate(badreg, pOverlap)
     numRects = badreg->data->numRects;
     if (!numRects)
     {
-	if (REGION_NAR(badreg))
+	if (RegionNar(badreg))
 	    return FALSE;
 	good(badreg);
 	return TRUE;
@@ -1532,7 +1229,7 @@ miRegionValidate(badreg, pOverlap)
     }
 
     /* Step 1: Sort the rects array into ascending (y1, x1) order */
-    QuickSortRects(REGION_BOXPTR(badreg), numRects);
+    QuickSortRects(RegionBoxptr(badreg), numRects);
 
     /* Step 2: Scatter the sorted array into the minimum number of regions */
 
@@ -1540,13 +1237,13 @@ miRegionValidate(badreg, pOverlap)
     /* Note that step 2 code will never overflow the ri[0].reg rects array */
     ri = (RegionInfo *) xalloc(4 * sizeof(RegionInfo));
     if (!ri)
-	return miRegionBreak (badreg);
+	return RegionBreak (badreg);
     sizeRI = 4;
     numRI = 1;
     ri[0].prevBand = 0;
     ri[0].curBand = 0;
     ri[0].reg = *badreg;
-    box = REGION_BOXPTR(&ri[0].reg);
+    box = RegionBoxptr(&ri[0].reg);
     ri[0].reg.extents = *box;
     ri[0].reg.data->numRects = 1;
 
@@ -1563,7 +1260,7 @@ miRegionValidate(badreg, pOverlap)
 	for (j = numRI, rit = ri; --j >= 0; rit++)
 	{
 	    reg = &rit->reg;
-	    riBox = REGION_END(reg);
+	    riBox = RegionEnd(reg);
 
 	    if (box->y1 == riBox->y1 && box->y2 == riBox->y2)
 	    {
@@ -1577,7 +1274,7 @@ miRegionValidate(badreg, pOverlap)
 		else
 		{
 		    RECTALLOC_BAIL(reg, 1, bail);
-		    *REGION_TOP(reg) = *box;
+		    *RegionTop(reg) = *box;
 		    reg->data->numRects++;
 		}
 		goto NextRect;   /* So sue me */
@@ -1590,7 +1287,7 @@ miRegionValidate(badreg, pOverlap)
 		Coalesce(reg, rit->prevBand, rit->curBand);
 		rit->curBand = reg->data->numRects;
 		RECTALLOC_BAIL(reg, 1, bail);
-		*REGION_TOP(reg) = *box;
+		*RegionTop(reg) = *box;
 		reg->data->numRects++;
 		goto NextRect;
 	    }
@@ -1613,7 +1310,7 @@ miRegionValidate(badreg, pOverlap)
 	rit->curBand = 0;
 	rit->reg.extents = *box;
 	rit->reg.data = (RegDataPtr)NULL;
-	if (!miRectAlloc(&rit->reg, (i+numRI) / numRI)) /* MUST force allocation */
+	if (!RegionRectAlloc(&rit->reg, (i+numRI) / numRI)) /* MUST force allocation */
 	    goto bail;
 NextRect: ;
     } /* for i */
@@ -1624,7 +1321,7 @@ NextRect: ;
     for (j = numRI, rit = ri; --j >= 0; rit++)
     {
 	reg = &rit->reg;
-	riBox = REGION_END(reg);
+	riBox = RegionEnd(reg);
 	reg->extents.y2 = riBox->y2;
 	if (reg->extents.x2 < riBox->x2) reg->extents.x2 = riBox->x2;
 	Coalesce(reg, rit->prevBand, rit->curBand);
@@ -1643,7 +1340,7 @@ NextRect: ;
 	{
 	    reg = &ri[j].reg;
 	    hreg = &ri[j+half].reg;
-	    if (!miRegionOp(reg, reg, hreg, miUnionO, TRUE, TRUE, pOverlap))
+	    if (!RegionOp(reg, reg, hreg, RegionUnionO, TRUE, TRUE, pOverlap))
 		ret = FALSE;
 	    if (hreg->extents.x1 < reg->extents.x1)
 		reg->extents.x1 = hreg->extents.x1;
@@ -1665,11 +1362,11 @@ bail:
     for (i = 0; i < numRI; i++)
 	xfreeData(&ri[i].reg);
     xfree (ri);
-    return miRegionBreak (badreg);
+    return RegionBreak (badreg);
 }
 
 RegionPtr
-miRectsToRegion(nrects, prect, ctype)
+RegionFromRects(nrects, prect, ctype)
     int			nrects;
     register xRectangle	*prect;
     int			ctype;
@@ -1681,8 +1378,8 @@ miRectsToRegion(nrects, prect, ctype)
     int			x1, y1, x2, y2;
     size_t newSize;
 
-    pRgn = miRegionCreate(NullBox, 0);
-    if (REGION_NAR (pRgn))
+    pRgn = RegionCreate(NullBox, 0);
+    if (RegionNar (pRgn))
 	return pRgn;
     if (!nrects)
 	return pRgn;
@@ -1704,11 +1401,11 @@ miRectsToRegion(nrects, prect, ctype)
 	}
 	return pRgn;
     }
-    newSize = REGION_SZOF(nrects);
+    newSize = RegionSizeof(nrects);
     pData = newSize > 0 ? xalloc(newSize) : NULL;
     if (!pData)
     {
-	miRegionBreak (pRgn);
+	RegionBreak (pRgn);
 	return pRgn;
     }
     pBox = (BoxPtr) (pData + 1);
@@ -1738,10 +1435,10 @@ miRectsToRegion(nrects, prect, ctype)
     	{
 	    Bool overlap; /* result ignored */
 	    pRgn->extents.x1 = pRgn->extents.x2 = 0;
-	    miRegionValidate(pRgn, &overlap);
+	    RegionValidate(pRgn, &overlap);
     	}
     	else
-	    miSetExtents(pRgn);
+	    RegionSetExtents(pRgn);
     	good(pRgn);
     }
     else
@@ -1751,456 +1448,6 @@ miRectsToRegion(nrects, prect, ctype)
     return pRgn;
 }
 
-/*======================================================================
- * 	    	  Region Subtraction
- *====================================================================*/
-
-
-/*-
- *-----------------------------------------------------------------------
- * miSubtractO --
- *	Overlapping band subtraction. x1 is the left-most point not yet
- *	checked.
- *
- * Results:
- *	TRUE if successful.
- *
- * Side Effects:
- *	pReg may have rectangles added to it.
- *
- *-----------------------------------------------------------------------
- */
-/*ARGSUSED*/
-static Bool
-miSubtractO (
-    register RegionPtr	pReg,
-    register BoxPtr	r1,
-    BoxPtr  	  	r1End,
-    register BoxPtr	r2,
-    BoxPtr  	  	r2End,
-    register short  	y1,
-             short  	y2,
-    Bool		*pOverlap)
-{
-    register BoxPtr	pNextRect;
-    register int  	x1;
-
-    x1 = r1->x1;
-    
-    assert(y1<y2);
-    assert(r1 != r1End && r2 != r2End);
-
-    pNextRect = REGION_TOP(pReg);
-
-    do
-    {
-	if (r2->x2 <= x1)
-	{
-	    /*
-	     * Subtrahend entirely to left of minuend: go to next subtrahend.
-	     */
-	    r2++;
-	}
-	else if (r2->x1 <= x1)
-	{
-	    /*
-	     * Subtrahend preceeds minuend: nuke left edge of minuend.
-	     */
-	    x1 = r2->x2;
-	    if (x1 >= r1->x2)
-	    {
-		/*
-		 * Minuend completely covered: advance to next minuend and
-		 * reset left fence to edge of new minuend.
-		 */
-		r1++;
-		if (r1 != r1End)
-		    x1 = r1->x1;
-	    }
-	    else
-	    {
-		/*
-		 * Subtrahend now used up since it doesn't extend beyond
-		 * minuend
-		 */
-		r2++;
-	    }
-	}
-	else if (r2->x1 < r1->x2)
-	{
-	    /*
-	     * Left part of subtrahend covers part of minuend: add uncovered
-	     * part of minuend to region and skip to next subtrahend.
-	     */
-	    assert(x1<r2->x1);
-	    NEWRECT(pReg, pNextRect, x1, y1, r2->x1, y2);
-
-	    x1 = r2->x2;
-	    if (x1 >= r1->x2)
-	    {
-		/*
-		 * Minuend used up: advance to new...
-		 */
-		r1++;
-		if (r1 != r1End)
-		    x1 = r1->x1;
-	    }
-	    else
-	    {
-		/*
-		 * Subtrahend used up
-		 */
-		r2++;
-	    }
-	}
-	else
-	{
-	    /*
-	     * Minuend used up: add any remaining piece before advancing.
-	     */
-	    if (r1->x2 > x1)
-		NEWRECT(pReg, pNextRect, x1, y1, r1->x2, y2);
-	    r1++;
-	    if (r1 != r1End)
-		x1 = r1->x1;
-	}
-    } while ((r1 != r1End) && (r2 != r2End));
-
-
-    /*
-     * Add remaining minuend rectangles to region.
-     */
-    while (r1 != r1End)
-    {
-	assert(x1<r1->x2);
-	NEWRECT(pReg, pNextRect, x1, y1, r1->x2, y2);
-	r1++;
-	if (r1 != r1End)
-	    x1 = r1->x1;
-    }
-    return TRUE;
-}
-	
-/*-
- *-----------------------------------------------------------------------
- * miSubtract --
- *	Subtract regS from regM and leave the result in regD.
- *	S stands for subtrahend, M for minuend and D for difference.
- *
- * Results:
- *	TRUE if successful.
- *
- * Side Effects:
- *	regD is overwritten.
- *
- *-----------------------------------------------------------------------
- */
-Bool
-miSubtract(regD, regM, regS)
-    register RegionPtr	regD;               
-    register RegionPtr 	regM;
-    register RegionPtr	regS;          
-{
-    Bool overlap; /* result ignored */
-
-    good(regM);
-    good(regS);
-    good(regD);
-   /* check for trivial rejects */
-    if (REGION_NIL(regM) || REGION_NIL(regS) ||
-	!EXTENTCHECK(&regM->extents, &regS->extents))
-    {
-	if (REGION_NAR (regS))
-	    return miRegionBreak (regD);
-	return miRegionCopy(regD, regM);
-    }
-    else if (regM == regS)
-    {
-	xfreeData(regD);
-	regD->extents.x2 = regD->extents.x1;
-	regD->extents.y2 = regD->extents.y1;
-	regD->data = &miEmptyData;
-	return TRUE;
-    }
- 
-    /* Add those rectangles in region 1 that aren't in region 2,
-       do yucky substraction for overlaps, and
-       just throw away rectangles in region 2 that aren't in region 1 */
-    if (!miRegionOp(regD, regM, regS, miSubtractO, TRUE, FALSE, &overlap))
-	return FALSE;
-
-    /*
-     * Can't alter RegD's extents before we call miRegionOp because
-     * it might be one of the source regions and miRegionOp depends
-     * on the extents of those regions being unaltered. Besides, this
-     * way there's no checking against rectangles that will be nuked
-     * due to coalescing, so we have to examine fewer rectangles.
-     */
-    miSetExtents(regD);
-    good(regD);
-    return TRUE;
-}
-
-/*======================================================================
- *	    Region Inversion
- *====================================================================*/
-
-/*-
- *-----------------------------------------------------------------------
- * miInverse --
- *	Take a region and a box and return a region that is everything
- *	in the box but not in the region. The careful reader will note
- *	that this is the same as subtracting the region from the box...
- *
- * Results:
- *	TRUE.
- *
- * Side Effects:
- *	newReg is overwritten.
- *
- *-----------------------------------------------------------------------
- */
-Bool
-miInverse(newReg, reg1, invRect)
-    RegionPtr 	  newReg;       /* Destination region */
-    RegionPtr 	  reg1;         /* Region to invert */
-    BoxPtr     	  invRect; 	/* Bounding box for inversion */
-{
-    RegionRec	  invReg;   	/* Quick and dirty region made from the
-				 * bounding box */
-    Bool	  overlap;	/* result ignored */
-
-    good(reg1);
-    good(newReg);
-   /* check for trivial rejects */
-    if (REGION_NIL(reg1) || !EXTENTCHECK(invRect, &reg1->extents))
-    {
-	if (REGION_NAR(reg1))
-	    return miRegionBreak (newReg);
-	newReg->extents = *invRect;
-	xfreeData(newReg);
-	newReg->data = (RegDataPtr)NULL;
-        return TRUE;
-    }
-
-    /* Add those rectangles in region 1 that aren't in region 2,
-       do yucky substraction for overlaps, and
-       just throw away rectangles in region 2 that aren't in region 1 */
-    invReg.extents = *invRect;
-    invReg.data = (RegDataPtr)NULL;
-    if (!miRegionOp(newReg, &invReg, reg1, miSubtractO, TRUE, FALSE, &overlap))
-	return FALSE;
-
-    /*
-     * Can't alter newReg's extents before we call miRegionOp because
-     * it might be one of the source regions and miRegionOp depends
-     * on the extents of those regions being unaltered. Besides, this
-     * way there's no checking against rectangles that will be nuked
-     * due to coalescing, so we have to examine fewer rectangles.
-     */
-    miSetExtents(newReg);
-    good(newReg);
-    return TRUE;
-}
-
-/*
- *   RectIn(region, rect)
- *   This routine takes a pointer to a region and a pointer to a box
- *   and determines if the box is outside/inside/partly inside the region.
- *
- *   The idea is to travel through the list of rectangles trying to cover the
- *   passed box with them. Anytime a piece of the rectangle isn't covered
- *   by a band of rectangles, partOut is set TRUE. Any time a rectangle in
- *   the region covers part of the box, partIn is set TRUE. The process ends
- *   when either the box has been completely covered (we reached a band that
- *   doesn't overlap the box, partIn is TRUE and partOut is false), the
- *   box has been partially covered (partIn == partOut == TRUE -- because of
- *   the banding, the first time this is true we know the box is only
- *   partially in the region) or is outside the region (we reached a band
- *   that doesn't overlap the box at all and partIn is false)
- */
-
-int
-miRectIn(region, prect)
-    register RegionPtr  region;
-    register BoxPtr     prect;
-{
-    register int	x;
-    register int	y;
-    register BoxPtr     pbox;
-    register BoxPtr     pboxEnd;
-    int			partIn, partOut;
-    int			numRects;
-
-    good(region);
-    numRects = REGION_NUM_RECTS(region);
-    /* useful optimization */
-    if (!numRects || !EXTENTCHECK(&region->extents, prect))
-        return(rgnOUT);
-
-    if (numRects == 1)
-    {
-	/* We know that it must be rgnIN or rgnPART */
-	if (SUBSUMES(&region->extents, prect))
-	    return(rgnIN);
-	else
-	    return(rgnPART);
-    }
-
-    partOut = FALSE;
-    partIn = FALSE;
-
-    /* (x,y) starts at upper left of rect, moving to the right and down */
-    x = prect->x1;
-    y = prect->y1;
-
-    /* can stop when both partOut and partIn are TRUE, or we reach prect->y2 */
-    for (pbox = REGION_BOXPTR(region), pboxEnd = pbox + numRects;
-         pbox != pboxEnd;
-         pbox++)
-    {
-
-        if (pbox->y2 <= y)
-           continue;    /* getting up to speed or skipping remainder of band */
-
-        if (pbox->y1 > y)
-        {
-           partOut = TRUE;      /* missed part of rectangle above */
-           if (partIn || (pbox->y1 >= prect->y2))
-              break;
-           y = pbox->y1;        /* x guaranteed to be == prect->x1 */
-        }
-
-        if (pbox->x2 <= x)
-           continue;            /* not far enough over yet */
-
-        if (pbox->x1 > x)
-        {
-           partOut = TRUE;      /* missed part of rectangle to left */
-           if (partIn)
-              break;
-        }
-
-        if (pbox->x1 < prect->x2)
-        {
-            partIn = TRUE;      /* definitely overlap */
-            if (partOut)
-               break;
-        }
-
-        if (pbox->x2 >= prect->x2)
-        {
-           y = pbox->y2;        /* finished with this band */
-           if (y >= prect->y2)
-              break;
-           x = prect->x1;       /* reset x out to left again */
-        }
-	else
-	{
-	    /*
-	     * Because boxes in a band are maximal width, if the first box
-	     * to overlap the rectangle doesn't completely cover it in that
-	     * band, the rectangle must be partially out, since some of it
-	     * will be uncovered in that band. partIn will have been set true
-	     * by now...
-	     */
-	    partOut = TRUE;
-	    break;
-	}
-    }
-
-    return(partIn ? ((y < prect->y2) ? rgnPART : rgnIN) : rgnOUT);
-}
-
-/* TranslateRegion(pReg, x, y)
-   translates in place
-*/
-
-void
-miTranslateRegion(pReg, x, y)
-    register RegionPtr pReg;
-    register int x;
-    register int y;
-{
-    int x1, x2, y1, y2;
-    register int nbox;
-    register BoxPtr pbox;
-
-    good(pReg);
-    pReg->extents.x1 = x1 = pReg->extents.x1 + x;
-    pReg->extents.y1 = y1 = pReg->extents.y1 + y;
-    pReg->extents.x2 = x2 = pReg->extents.x2 + x;
-    pReg->extents.y2 = y2 = pReg->extents.y2 + y;
-    if (((x1 - MINSHORT)|(y1 - MINSHORT)|(MAXSHORT - x2)|(MAXSHORT - y2)) >= 0)
-    {
-	if (pReg->data && (nbox = pReg->data->numRects))
-	{
-	    for (pbox = REGION_BOXPTR(pReg); nbox--; pbox++)
-	    {
-		pbox->x1 += x;
-		pbox->y1 += y;
-		pbox->x2 += x;
-		pbox->y2 += y;
-	    }
-	}
-	return;
-    }
-    if (((x2 - MINSHORT)|(y2 - MINSHORT)|(MAXSHORT - x1)|(MAXSHORT - y1)) <= 0)
-    {
-	pReg->extents.x2 = pReg->extents.x1;
-	pReg->extents.y2 = pReg->extents.y1;
-	xfreeData(pReg);
-	pReg->data = &miEmptyData;
-	return;
-    }
-    if (x1 < MINSHORT)
-	pReg->extents.x1 = MINSHORT;
-    else if (x2 > MAXSHORT)
-	pReg->extents.x2 = MAXSHORT;
-    if (y1 < MINSHORT)
-	pReg->extents.y1 = MINSHORT;
-    else if (y2 > MAXSHORT)
-	pReg->extents.y2 = MAXSHORT;
-    if (pReg->data && (nbox = pReg->data->numRects))
-    {
-	register BoxPtr pboxout;
-
-	for (pboxout = pbox = REGION_BOXPTR(pReg); nbox--; pbox++)
-	{
-	    pboxout->x1 = x1 = pbox->x1 + x;
-	    pboxout->y1 = y1 = pbox->y1 + y;
-	    pboxout->x2 = x2 = pbox->x2 + x;
-	    pboxout->y2 = y2 = pbox->y2 + y;
-	    if (((x2 - MINSHORT)|(y2 - MINSHORT)|
-		 (MAXSHORT - x1)|(MAXSHORT - y1)) <= 0)
-	    {
-		pReg->data->numRects--;
-		continue;
-	    }
-	    if (x1 < MINSHORT)
-		pboxout->x1 = MINSHORT;
-	    else if (x2 > MAXSHORT)
-		pboxout->x2 = MAXSHORT;
-	    if (y1 < MINSHORT)
-		pboxout->y1 = MINSHORT;
-	    else if (y2 > MAXSHORT)
-		pboxout->y2 = MAXSHORT;
-	    pboxout++;
-	}
-	if (pboxout != pbox)
-	{
-	    if (pReg->data->numRects == 1)
-	    {
-		pReg->extents = *REGION_BOXPTR(pReg);
-		xfreeData(pReg);
-		pReg->data = (RegDataPtr)NULL;
-	    }
-	    else
-		miSetExtents(pReg);
-	}
-    }
-}
-
 Bool
 miRegionDataCopy(
     register RegionPtr dst,
@@ -2220,98 +1467,17 @@ miRegionDataCopy(
     }
     if (!dst->data || (dst->data->size < src->data->numRects))
     {
-	size_t newSize = REGION_SZOF(src->data->numRects);
+	size_t newSize = RegionSizeof(src->data->numRects);
 	xfreeData(dst);
 	dst->data = newSize > 0 ? xalloc(newSize) : NULL;
 	if (!dst->data)
-	    return miRegionBreak (dst);
+	    return RegionBreak (dst);
     }
     dst->data->size = src->data->size;
     dst->data->numRects = src->data->numRects;
     return TRUE;
 }
 
-void
-miRegionReset(pReg, pBox)
-    RegionPtr pReg;
-    BoxPtr pBox;
-{
-    good(pReg);
-    assert(pBox->x1<=pBox->x2);
-    assert(pBox->y1<=pBox->y2);
-    pReg->extents = *pBox;
-    xfreeData(pReg);
-    pReg->data = (RegDataPtr)NULL;
-}
-
-Bool
-miPointInRegion(pReg, x, y, box)
-    register RegionPtr pReg;
-    register int x, y;
-    BoxPtr box;     /* "return" value */
-{
-    register BoxPtr pbox, pboxEnd;
-    int numRects;
-
-    good(pReg);
-    numRects = REGION_NUM_RECTS(pReg);
-    if (!numRects || !INBOX(&pReg->extents, x, y))
-        return(FALSE);
-    if (numRects == 1)
-    {
-	*box = pReg->extents;
-	return(TRUE);
-    }
-    for (pbox = REGION_BOXPTR(pReg), pboxEnd = pbox + numRects;
-	 pbox != pboxEnd;
-	 pbox++)
-    {
-        if (y >= pbox->y2)
-	   continue;		/* not there yet */
-	if ((y < pbox->y1) || (x < pbox->x1))
-	   break;		/* missed it */
-	if (x >= pbox->x2)
-	   continue;		/* not there yet */
-	*box = *pbox;
-	return(TRUE);
-    }
-    return(FALSE);
-}
-
-Bool
-miRegionNotEmpty(pReg)
-    RegionPtr pReg;
-{
-    good(pReg);
-    return(!REGION_NIL(pReg));
-}
-
-Bool
-miRegionBroken(RegionPtr pReg)
-{
-    good(pReg);
-    return (REGION_NAR(pReg));
-}
-
-void
-miRegionEmpty(pReg)
-    RegionPtr pReg;
-{
-    good(pReg);
-    xfreeData(pReg);
-    pReg->extents.x2 = pReg->extents.x1;
-    pReg->extents.y2 = pReg->extents.y1;
-    pReg->data = &miEmptyData;
-}
-
-BoxPtr
-miRegionExtents(pReg)
-    RegionPtr pReg;
-{
-    good(pReg);
-    return(&pReg->extents);
-}
-
 #define ExchangeSpans(a, b)				    \
 {							    \
     DDXPointRec     tpt;				    \
@@ -2431,7 +1597,7 @@ static void QuickSortSpans(
 */
 
 int
-miClipSpans(
+RegionClipSpans(
     RegionPtr		    prgnDst,
     register DDXPointPtr    ppt,
     register int	    *pwidth,
@@ -2497,7 +1663,7 @@ miClipSpans(
 	if ((! fSorted) && (nspans > 1))
 	    QuickSortSpans(ppt, pwidth, nspans);
 
-	pboxBandStart = REGION_BOXPTR(prgnDst);
+	pboxBandStart = RegionBoxptr(prgnDst);
 	pboxLast = pboxBandStart + numRects;
     
 	NextBand();
@@ -2558,8 +1724,8 @@ miFindMaxBand(prgn)
     short yThisBand;
 
     good(prgn);
-    nbox = REGION_NUM_RECTS(prgn);
-    pbox = REGION_RECTS(prgn);
+    nbox = RegionNumRects(prgn);
+    pbox = RegionRects(prgn);
 
     while(nbox > 0)
     {
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index 5854f2e95..916d7e276 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -180,7 +180,7 @@ PrintChildren(WindowPtr p1, int indent)
 	p2 = p1->firstChild;
 	for (i=0; i<indent; i++) ErrorF( " ");
 	ErrorF( "%x\n", p1->drawable.id);
-	miPrintRegion(&p1->clipList);
+	RegionPrint(&p1->clipList);
 	PrintChildren(p2, indent+4);
 	p1 = p1->nextSib;
     }
@@ -195,7 +195,7 @@ PrintWindowTree()
     {
 	ErrorF( "WINDOW %d\n", i);
 	pWin = WindowTable[i];
-	miPrintRegion(&pWin->clipList);
+	RegionPrint(&pWin->clipList);
 	p1 = pWin->firstChild;
 	PrintChildren(p1, 4);
     }
@@ -439,10 +439,10 @@ CreateRootWindow(ScreenPtr pScreen)
     box.y1 = 0;
     box.x2 = pScreen->width;
     box.y2 = pScreen->height;
-    REGION_INIT(pScreen, &pWin->clipList, &box, 1);
-    REGION_INIT(pScreen, &pWin->winSize, &box, 1);
-    REGION_INIT(pScreen, &pWin->borderSize, &box, 1);
-    REGION_INIT(pScreen, &pWin->borderClip, &box, 1);
+    RegionInit(&pWin->clipList, &box, 1);
+    RegionInit(&pWin->winSize, &box, 1);
+    RegionInit(&pWin->borderSize, &box, 1);
+    RegionInit(&pWin->borderClip, &box, 1);
 
     pWin->drawable.class = InputOutput;
     pWin->optional->visual = pScreen->rootVisual;
@@ -515,7 +515,7 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
     ScreenPtr pScreen = pWin->drawable.pScreen;
     BoxRec box;
 
-    box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
+    box = *(RegionExtents(&pWin->winSize));
     /* we do these calculations to avoid overflows */
     if (x > box.x1)
 	box.x1 = x;
@@ -531,8 +531,8 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
 	box.x2 = box.x1;
     if (box.y1 > box.y2)
 	box.y2 = box.y1;
-    REGION_RESET(pScreen, Rgn, &box);
-    REGION_INTERSECT(pScreen, Rgn, Rgn, &pWin->winSize);
+    RegionReset(Rgn, &box);
+    RegionIntersect(Rgn, Rgn, &pWin->winSize);
 }
 
 WindowPtr
@@ -713,10 +713,10 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
     pWin->drawable.y = pParent->drawable.y + y + (int)bw;
 
 	/* set up clip list correctly for unobscured WindowPtr */
-    REGION_NULL(pScreen, &pWin->clipList);
-    REGION_NULL(pScreen, &pWin->borderClip);
-    REGION_NULL(pScreen, &pWin->winSize);
-    REGION_NULL(pScreen, &pWin->borderSize);
+    RegionNull(&pWin->clipList);
+    RegionNull(&pWin->borderClip);
+    RegionNull(&pWin->winSize);
+    RegionNull(&pWin->borderSize);
 
     pHead = RealChildHead(pParent);
     if (pHead)
@@ -797,17 +797,17 @@ FreeWindowResources(register WindowPtr pWin)
     DeleteWindowFromAnySaveSet(pWin);
     DeleteWindowFromAnySelections(pWin);
     DeleteWindowFromAnyEvents(pWin, TRUE);
-    REGION_UNINIT(pScreen, &pWin->clipList);
-    REGION_UNINIT(pScreen, &pWin->winSize);
-    REGION_UNINIT(pScreen, &pWin->borderClip);
-    REGION_UNINIT(pScreen, &pWin->borderSize);
+    RegionUninit(&pWin->clipList);
+    RegionUninit(&pWin->winSize);
+    RegionUninit(&pWin->borderClip);
+    RegionUninit(&pWin->borderSize);
 #ifdef SHAPE
     if (wBoundingShape (pWin))
-	REGION_DESTROY(pScreen, wBoundingShape (pWin));
+	RegionDestroy(wBoundingShape (pWin));
     if (wClipShape (pWin))
-	REGION_DESTROY(pScreen, wClipShape (pWin));
+	RegionDestroy(wClipShape (pWin));
     if (wInputShape (pWin))
-	REGION_DESTROY(pScreen, wInputShape (pWin));
+	RegionDestroy(wInputShape (pWin));
 #endif
     if (pWin->borderIsPixel == FALSE)
 	(*pScreen->DestroyPixmap)(pWin->border.pixmap);
@@ -1467,10 +1467,10 @@ PatchUp:
     {
 	RegionRec exposed;
 
-	REGION_NULL(pScreen, &exposed);
-	REGION_SUBTRACT(pScreen, &exposed, &pWin->borderClip, &pWin->winSize);
+	RegionNull(&exposed);
+	RegionSubtract(&exposed, &pWin->borderClip, &pWin->winSize);
 	(*pWin->drawable.pScreen->PaintWindowBorder)(pWin, &exposed, PW_BORDER);
-	REGION_UNINIT(pScreen, &exposed);
+	RegionUninit(&exposed);
     }
     return error;
 }
@@ -1611,18 +1611,18 @@ CreateUnclippedWinSize (register WindowPtr pWin)
     box.y1 = pWin->drawable.y;
     box.x2 = pWin->drawable.x + (int) pWin->drawable.width;
     box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
-    pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
+    pRgn = RegionCreate(&box, 1);
 #ifdef SHAPE
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
 	ScreenPtr pScreen = pWin->drawable.pScreen;
 
-	REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
+	RegionTranslate(pRgn, - pWin->drawable.x,
 			 - pWin->drawable.y);
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
+	    RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wClipShape (pWin));
-	REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x, pWin->drawable.y);
+	    RegionIntersect(pRgn, pRgn, wClipShape (pWin));
+	RegionTranslate(pRgn, pWin->drawable.x, pWin->drawable.y);
     }
 #endif
     return pRgn;
@@ -1640,7 +1640,7 @@ SetWinSize (register WindowPtr pWin)
 	box.y1 = pWin->drawable.y;
 	box.x2 = pWin->drawable.x + pWin->drawable.width;
 	box.y2 = pWin->drawable.y + pWin->drawable.height;
-	REGION_RESET (pScreen, &pWin->winSize, &box);
+	RegionReset(&pWin->winSize, &box);
     }
     else
 #endif
@@ -1652,15 +1652,15 @@ SetWinSize (register WindowPtr pWin)
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
 	ScreenPtr pScreen = pWin->drawable.pScreen;
 
-	REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
+	RegionTranslate(&pWin->winSize, - pWin->drawable.x,
 			 - pWin->drawable.y);
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+	    RegionIntersect(&pWin->winSize, &pWin->winSize,
 			     wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+	    RegionIntersect(&pWin->winSize, &pWin->winSize,
 			     wClipShape (pWin));
-	REGION_TRANSLATE(pScreen, &pWin->winSize, pWin->drawable.x,
+	RegionTranslate(&pWin->winSize, pWin->drawable.x,
 			 pWin->drawable.y);
     }
 #endif
@@ -1682,7 +1682,7 @@ SetBorderSize (register WindowPtr pWin)
 	    box.y1 = pWin->drawable.y - bw;
 	    box.x2 = pWin->drawable.x + pWin->drawable.width + bw;
 	    box.y2 = pWin->drawable.y + pWin->drawable.height + bw;
-	    REGION_RESET (pScreen, &pWin->borderSize, &box);
+	    RegionReset(&pWin->borderSize, &box);
 	}
 	else
 #endif
@@ -1694,18 +1694,18 @@ SetBorderSize (register WindowPtr pWin)
 	if (wBoundingShape (pWin)) {
 	    ScreenPtr pScreen = pWin->drawable.pScreen;
 
-	    REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
+	    RegionTranslate(&pWin->borderSize, - pWin->drawable.x,
 			     - pWin->drawable.y);
-	    REGION_INTERSECT(pScreen, &pWin->borderSize, &pWin->borderSize,
+	    RegionIntersect(&pWin->borderSize, &pWin->borderSize,
 			     wBoundingShape (pWin));
-	    REGION_TRANSLATE(pScreen, &pWin->borderSize, pWin->drawable.x,
+	    RegionTranslate(&pWin->borderSize, pWin->drawable.x,
 			     pWin->drawable.y);
-	    REGION_UNION(pScreen, &pWin->borderSize, &pWin->borderSize,
+	    RegionUnion(&pWin->borderSize, &pWin->borderSize,
 			 &pWin->winSize);
 	}
 #endif
     } else {
-	REGION_COPY(pWin->drawable.pScreen, &pWin->borderSize,
+	RegionCopy(&pWin->borderSize,
 					       &pWin->winSize);
     }
 }
@@ -1905,12 +1905,12 @@ MakeBoundingRegion (
     RegionPtr	pRgn;
     ScreenPtr   pScreen = pWin->drawable.pScreen;
 
-    pRgn = REGION_CREATE(pScreen, pBox, 1);
+    pRgn = RegionCreate(pBox, 1);
     if (wBoundingShape (pWin)) {
-	    REGION_TRANSLATE(pScreen, pRgn, -pWin->origin.x,
+	    RegionTranslate(pRgn, -pWin->origin.x,
 						  -pWin->origin.y);
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
-	    REGION_TRANSLATE(pScreen, pRgn, pWin->origin.x,
+	    RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
+	    RegionTranslate(pRgn, pWin->origin.x,
 						  pWin->origin.y);
     }
     return pRgn;
@@ -1932,10 +1932,10 @@ ShapeOverlap (
     pScreen = pWin->drawable.pScreen;
     pWinRgn = MakeBoundingRegion (pWin, pWinBox);
     pSibRgn = MakeBoundingRegion (pSib, pSibBox);
-    REGION_INTERSECT(pScreen, pWinRgn, pWinRgn, pSibRgn);
-    ret = REGION_NOTEMPTY(pScreen, pWinRgn);
-    REGION_DESTROY(pScreen, pWinRgn);
-    REGION_DESTROY(pScreen, pSibRgn);
+    RegionIntersect(pWinRgn, pWinRgn, pSibRgn);
+    ret = RegionNotEmpty(pWinRgn);
+    RegionDestroy(pWinRgn);
+    RegionDestroy(pSibRgn);
     return ret;
 }
 #endif
@@ -2066,7 +2066,7 @@ WhereDoIGoInTheStack(
 	else if (pSib)
 	{
 	    if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
-		(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+		(RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
 		return(pFirst);
 	    else
 		return(pWin->nextSib);
@@ -2081,7 +2081,7 @@ WhereDoIGoInTheStack(
 	else if (pSib)
 	{
 	    if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
-		(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+		(RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
 		return NullWindow;
 	    else
 		return(pWin->nextSib);
@@ -2095,7 +2095,7 @@ WhereDoIGoInTheStack(
 	    return(pWin->nextSib);
 	else if (pSib)
 	{
-	    if (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT)
+	    if (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)
 	    {
 		if (IsSiblingAboveMe(pWin, pSib) == Above)
 		    return(pFirst);
@@ -2785,10 +2785,10 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	    (*pScreen->ClipNotify) (pWin, 0, 0);
 	if (pScreen->PostValidateTree)
 	    (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
-	REGION_NULL(pScreen, &temp);
-	REGION_COPY(pScreen, &temp, &pWin->clipList);
+	RegionNull(&temp);
+	RegionCopy(&temp, &pWin->clipList);
 	(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
-	REGION_UNINIT(pScreen, &temp);
+	RegionUninit(&temp);
     }
 
     return(Success);
@@ -3184,7 +3184,7 @@ VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
 {
     if (!pWin->realized)
 	return (FALSE);
-    if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
+    if (RegionContainsPoint(&pWin->clipList, x, y, box))
 	return(TRUE);
     return(FALSE);
 }
@@ -3200,10 +3200,10 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
 
     if (!pWin->realized)
 	return (FALSE);
-    if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderClip,
+    if (RegionContainsPoint(&pWin->borderClip,
 						  x, y, &box)
 	&& (!wInputShape(pWin) ||
-	    POINT_IN_REGION(pWin->drawable.pScreen,
+	    RegionContainsPoint(
 			    wInputShape(pWin),
 			    x - pWin->drawable.x, 
 			    y - pWin->drawable.y, &box)))
@@ -3219,12 +3219,12 @@ NotClippedByChildren(register WindowPtr pWin)
     RegionPtr pReg;
 
     pScreen = pWin->drawable.pScreen;
-    pReg = REGION_CREATE(pScreen, NullBox, 1);
+    pReg = RegionCreate(NullBox, 1);
     if (pWin->parent ||
 	screenIsSaved != SCREEN_SAVER_ON ||
 	!HasSaverWindow (pWin->drawable.pScreen->myNum))
     {
-	REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
+	RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize);
     }
     return(pReg);
 }
diff --git a/nx-X11/programs/Xserver/fb/Imakefile b/nx-X11/programs/Xserver/fb/Imakefile
index 489d6a201..662a70717 100644
--- a/nx-X11/programs/Xserver/fb/Imakefile
+++ b/nx-X11/programs/Xserver/fb/Imakefile
@@ -123,7 +123,8 @@ OBJS =	$(XFMODOBJ) \
    INCLUDES = -I$(SERVERSRC)/fb -I$(SERVERSRC)/mi -I$(SERVERSRC)/include \
 	      -I$(XINCLUDESRC) \
 	      -I$(XF86SRC)/common $(EXTRAINCLUDES) \
-	      -I$(SERVERSRC)/render -I$(EXTINCSRC) -I$(SERVERSRC)/Xext
+	      -I$(SERVERSRC)/render -I$(EXTINCSRC) -I$(SERVERSRC)/Xext \
+	      `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = $(SERVERSRC)/dix/llib-ldix.ln $(SERVERSRC)/os/llib-los.ln \
 	     $(SERVERSRC)/mi/llib-lmi.ln
 
diff --git a/nx-X11/programs/Xserver/fb/fb.h b/nx-X11/programs/Xserver/fb/fb.h
index b64f3a227..1da5d2470 100644
--- a/nx-X11/programs/Xserver/fb/fb.h
+++ b/nx-X11/programs/Xserver/fb/fb.h
@@ -703,7 +703,7 @@ typedef struct {
  */
 
 #define fbWindowEnabled(pWin) \
-    REGION_NOTEMPTY((pWin)->drawable.pScreen, \
+    RegionNotEmpty(\
 		    &WindowTable[(pWin)->drawable.pScreen->myNum]->borderClip)
 
 #define fbDrawableEnabled(pDrawable) \
diff --git a/nx-X11/programs/Xserver/fb/fb24_32.c b/nx-X11/programs/Xserver/fb/fb24_32.c
index 68e0ef84d..350055c14 100644
--- a/nx-X11/programs/Xserver/fb/fb24_32.c
+++ b/nx-X11/programs/Xserver/fb/fb24_32.c
@@ -338,8 +338,8 @@ fb24_32SetSpans (DrawablePtr	    pDrawable,
     {
 	d = dst + (ppt->y + dstYoff) * dstStride;
 	s = (CARD8 *) src;
-	n = REGION_NUM_RECTS(pClip);
-	pbox = REGION_RECTS (pClip);
+	n = RegionNumRects(pClip);
+	pbox = RegionRects (pClip);
 	while (n--)
 	{
 	    if (pbox->y1 > ppt->y)
@@ -400,8 +400,8 @@ fb24_32PutZImage (DrawablePtr	pDrawable,
     dstStride *= sizeof(FbBits);
     dst = (CARD8 *) dstBits;
 
-    for (nbox = REGION_NUM_RECTS (pClip),
-	 pbox = REGION_RECTS(pClip);
+    for (nbox = RegionNumRects (pClip),
+	 pbox = RegionRects(pClip);
 	 nbox--;
 	 pbox++)
     {
diff --git a/nx-X11/programs/Xserver/fb/fbarc.c b/nx-X11/programs/Xserver/fb/fbarc.c
index 315aa181c..0b386f70e 100644
--- a/nx-X11/programs/Xserver/fb/fbarc.c
+++ b/nx-X11/programs/Xserver/fb/fbarc.c
@@ -101,7 +101,7 @@ fbPolyArc (DrawablePtr	pDrawable,
 		    y2 = box.y1 + (int)parcs->height + 1;
 		    box.y2 = y2;
 		    if ( (x2 <= MAXSHORT) && (y2 <= MAXSHORT) &&
-			(RECT_IN_REGION(pDrawable->pScreen, cclip, &box) == rgnIN) )
+			(RegionContainsRect(cclip, &box) == rgnIN) )
 			(*arc) (dst, dstStride, dstBpp, 
 				parcs, pDrawable->x + dstXoff, pDrawable->y + dstYoff, 
 				pPriv->and, pPriv->xor);
diff --git a/nx-X11/programs/Xserver/fb/fbbits.h b/nx-X11/programs/Xserver/fb/fbbits.h
index 7dfff58b4..5cd7ae70f 100644
--- a/nx-X11/programs/Xserver/fb/fbbits.h
+++ b/nx-X11/programs/Xserver/fb/fbbits.h
@@ -668,7 +668,7 @@ POLYLINE (DrawablePtr	pDrawable,
     int		    xoff = pDrawable->x;
     int		    yoff = pDrawable->y;
     unsigned int    bias = miGetZeroLineBias(pDrawable->pScreen);
-    BoxPtr	    pBox = REGION_EXTENTS (pDrawable->pScreen, fbGetCompositeClip (pGC));
+    BoxPtr	    pBox = RegionExtents(fbGetCompositeClip (pGC));
     
     FbBits	    *dst;
     int		    dstStride;
@@ -800,7 +800,7 @@ POLYSEGMENT (DrawablePtr    pDrawable,
     int		    xoff = pDrawable->x;
     int		    yoff = pDrawable->y;
     unsigned int    bias = miGetZeroLineBias(pDrawable->pScreen);
-    BoxPtr	    pBox = REGION_EXTENTS (pDrawable->pScreen, fbGetCompositeClip (pGC));
+    BoxPtr	    pBox = RegionExtents(fbGetCompositeClip (pGC));
     
     FbBits	    *dst;
     int		    dstStride;
diff --git a/nx-X11/programs/Xserver/fb/fbbstore.c b/nx-X11/programs/Xserver/fb/fbbstore.c
index 01ec9b7e0..e9eedde5b 100644
--- a/nx-X11/programs/Xserver/fb/fbbstore.c
+++ b/nx-X11/programs/Xserver/fb/fbbstore.c
@@ -39,8 +39,8 @@ fbSaveAreas(PixmapPtr	pPixmap,
     fbCopyWindowProc (&pWin->drawable,
 		      &pPixmap->drawable,
 		      0,
-		      REGION_RECTS(prgnSave),
-		      REGION_NUM_RECTS(prgnSave),
+		      RegionRects(prgnSave),
+		      RegionNumRects(prgnSave),
 		      xorg, yorg,
 		      FALSE,
 		      FALSE,
@@ -57,8 +57,8 @@ fbRestoreAreas(PixmapPtr    pPixmap,
     fbCopyWindowProc (&pPixmap->drawable,
 		      &pWin->drawable,
 		      0,
-		      REGION_RECTS(prgnRestore),
-		      REGION_NUM_RECTS(prgnRestore),
+		      RegionRects(prgnRestore),
+		      RegionNumRects(prgnRestore),
 		      -xorg, -yorg,
 		      FALSE,
 		      FALSE,
diff --git a/nx-X11/programs/Xserver/fb/fbcompose.c b/nx-X11/programs/Xserver/fb/fbcompose.c
index f8169995f..07ae9490f 100644
--- a/nx-X11/programs/Xserver/fb/fbcompose.c
+++ b/nx-X11/programs/Xserver/fb/fbcompose.c
@@ -2896,7 +2896,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
     if (pict->filter == PictFilterNearest)
     {
         if (pict->repeatType == RepeatNormal) {
-            if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
+            if (RegionNumRects(pict->pCompositeClip) == 1) {
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
@@ -2927,7 +2927,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                             y = MOD(v.vector[1]>>16, pict->pDrawable->height);
                             x = MOD(v.vector[0]>>16, pict->pDrawable->width);
                         }
-                        if (POINT_IN_REGION (0, pict->pCompositeClip, x, y, &box))
+                        if (RegionContainsPoint(pict->pCompositeClip, x, y, &box))
                             buffer[i] = fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                         else
                             buffer[i] = 0;
@@ -2938,7 +2938,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                 }
             }
         } else {
-            if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
+            if (RegionNumRects(pict->pCompositeClip) == 1) {
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
@@ -2970,7 +2970,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                             y = v.vector[1]>>16;
                             x = v.vector[0]>>16;
                         }
-                        if (POINT_IN_REGION (0, pict->pCompositeClip, x, y, &box))
+                        if (RegionContainsPoint(pict->pCompositeClip, x, y, &box))
                             buffer[i] = fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                         else
                             buffer[i] = 0;
@@ -2983,7 +2983,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
         }
     } else if (pict->filter == PictFilterBilinear) {
         if (pict->repeatType == RepeatNormal) {
-            if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
+            if (RegionNumRects(pict->pCompositeClip) == 1) {
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
@@ -3082,14 +3082,14 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
 
                         b = bits + (y1 + pict->pDrawable->y)*stride;
 
-                        tl = POINT_IN_REGION(0, pict->pCompositeClip, x1, y1, &box)
+                        tl = RegionContainsPoint(pict->pCompositeClip, x1, y1, &box)
                              ? fetch(b, x1 + pict->pDrawable->x, indexed) : 0;
-                        tr = POINT_IN_REGION(0, pict->pCompositeClip, x2, y1, &box)
+                        tr = RegionContainsPoint(pict->pCompositeClip, x2, y1, &box)
                              ? fetch(b, x2 + pict->pDrawable->x, indexed) : 0;
                         b = bits + (y2 + pict->pDrawable->y)*stride;
-                        bl = POINT_IN_REGION(0, pict->pCompositeClip, x1, y2, &box)
+                        bl = RegionContainsPoint(pict->pCompositeClip, x1, y2, &box)
                              ? fetch(b, x1 + pict->pDrawable->x, indexed) : 0;
-                        br = POINT_IN_REGION(0, pict->pCompositeClip, x2, y2, &box)
+                        br = RegionContainsPoint(pict->pCompositeClip, x2, y2, &box)
                              ? fetch(b, x2 + pict->pDrawable->x, indexed) : 0;
 
                         ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
@@ -3112,7 +3112,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                 }
             }
         } else {
-            if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
+            if (RegionNumRects(pict->pCompositeClip) == 1) {
                 box = pict->pCompositeClip->extents;
                 for (i = 0; i < width; ++i) {
                     if (!v.vector[2]) {
@@ -3209,14 +3209,14 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                         b = bits + (y1 + pict->pDrawable->y)*stride;
                         x_off = x1 + pict->pDrawable->x;
 
-                        tl = POINT_IN_REGION(0, pict->pCompositeClip, x1, y1, &box)
+                        tl = RegionContainsPoint(pict->pCompositeClip, x1, y1, &box)
                              ? fetch(b, x_off, indexed) : 0;
-                        tr = POINT_IN_REGION(0, pict->pCompositeClip, x2, y1, &box)
+                        tr = RegionContainsPoint(pict->pCompositeClip, x2, y1, &box)
                              ? fetch(b, x_off + 1, indexed) : 0;
                         b += stride;
-                        bl = POINT_IN_REGION(0, pict->pCompositeClip, x1, y2, &box)
+                        bl = RegionContainsPoint(pict->pCompositeClip, x1, y2, &box)
                              ? fetch(b, x_off, indexed) : 0;
-                        br = POINT_IN_REGION(0, pict->pCompositeClip, x2, y2, &box)
+                        br = RegionContainsPoint(pict->pCompositeClip, x2, y2, &box)
                              ? fetch(b, x_off + 1, indexed) : 0;
 
                         ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
@@ -3274,7 +3274,7 @@ static void fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32
                     for (x = x1; x < x2; x++) {
                         if (*p) {
                             int tx = (pict->repeatType == RepeatNormal) ? MOD (x, pict->pDrawable->width) : x;
-                            if (POINT_IN_REGION (0, pict->pCompositeClip, tx, ty, &box)) {
+                            if (RegionContainsPoint(pict->pCompositeClip, tx, ty, &box)) {
                                 FbBits *b = bits + (ty + pict->pDrawable->y)*stride;
                                 CARD32 c = fetch(b, tx + pict->pDrawable->x, indexed);
 
@@ -3563,8 +3563,8 @@ fbCompositeGeneral (CARD8	op,
     if (width > SCANLINE_BUFFER_LENGTH)
         scanline_buffer = (CARD32 *) malloc(width * 3 * sizeof(CARD32));
 
-    n = REGION_NUM_RECTS (&region);
-    pbox = REGION_RECTS (&region);
+    n = RegionNumRects (&region);
+    pbox = RegionRects (&region);
     while (n--)
     {
 	h = pbox->y2 - pbox->y1;
@@ -3618,7 +3618,7 @@ fbCompositeGeneral (CARD8	op,
     }
 	pbox++;
     }
-    REGION_UNINIT (pDst->pDrawable->pScreen, &region);
+    RegionUninit(&region);
 
     if (scanline_buffer != _scanline_buffer)
         free(scanline_buffer);
diff --git a/nx-X11/programs/Xserver/fb/fbcopy.c b/nx-X11/programs/Xserver/fb/fbcopy.c
index 1e7b93435..f68811ebb 100644
--- a/nx-X11/programs/Xserver/fb/fbcopy.c
+++ b/nx-X11/programs/Xserver/fb/fbcopy.c
@@ -306,8 +306,8 @@ fbCopyRegion (DrawablePtr   pSrcDrawable,
     int		nbox;
     BoxPtr	pboxNew1, pboxNew2, pboxBase, pboxNext, pboxTmp;
     
-    pbox = REGION_RECTS(pDstRegion);
-    nbox = REGION_NUM_RECTS(pDstRegion);
+    pbox = RegionRects(pDstRegion);
+    nbox = RegionNumRects(pDstRegion);
     
     /* XXX we have to err on the side of safety when both are windows,
      * because we don't know if IncludeInferiors is being used.
@@ -466,7 +466,7 @@ fbDoCopy (DrawablePtr	pSrcDrawable,
 	     * VT is inactive, make sure the region isn't empty
 	     */
 	    if (!((WindowPtr) pSrcDrawable)->parent &&
-		REGION_NOTEMPTY (pSrcDrawable->pScreen,
+		RegionNotEmpty(
 				 &((WindowPtr) pSrcDrawable)->borderClip))
 	    {
 		/*
@@ -548,9 +548,9 @@ fbDoCopy (DrawablePtr	pSrcDrawable,
 	   blown region and call intersect */
 
 	cclip = fbGetCompositeClip(pGC);
-        if (REGION_NUM_RECTS(cclip) == 1)
+        if (RegionNumRects(cclip) == 1)
         {
-	    BoxPtr pBox = REGION_RECTS(cclip);
+	    BoxPtr pBox = RegionRects(cclip);
 
 	    if (box_x1 < pBox->x1) box_x1 = pBox->x1;
 	    if (box_x2 > pBox->x2) box_x2 = pBox->x2;
@@ -563,7 +563,7 @@ fbDoCopy (DrawablePtr	pSrcDrawable,
     /* Check to see if the region is empty */
     if (box_x1 >= box_x2 || box_y1 >= box_y2)
     {
-	REGION_NULL(pGC->pScreen, &rgnDst);
+	RegionNull(&rgnDst);
     }
     else
     {
@@ -572,25 +572,25 @@ fbDoCopy (DrawablePtr	pSrcDrawable,
 	box.y1 = box_y1;
 	box.x2 = box_x2;
 	box.y2 = box_y2;
-	REGION_INIT(pGC->pScreen, &rgnDst, &box, 1);
+	RegionInit(&rgnDst, &box, 1);
     }
     
     /* Clip against complex source if needed */
     if (!fastSrc)
     {
-	REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst, prgnSrcClip);
-	REGION_TRANSLATE(pGC->pScreen, &rgnDst, -dx, -dy);
+	RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);
+	RegionTranslate(&rgnDst, -dx, -dy);
     }
 
     /* Clip against complex dest if needed */
     if (!fastDst)
     {
-	REGION_INTERSECT(pGC->pScreen, &rgnDst, &rgnDst,
+	RegionIntersect(&rgnDst, &rgnDst,
 			 fbGetCompositeClip(pGC));
     }
 
     /* Do bit blitting */
-    numRects = REGION_NUM_RECTS(&rgnDst);
+    numRects = RegionNumRects(&rgnDst);
     if (numRects && widthSrc && heightSrc)
 	fbCopyRegion (pSrcDrawable, pDstDrawable, pGC,
 		      &rgnDst, dx, dy, copyProc, bitPlane, closure);
@@ -604,9 +604,9 @@ fbDoCopy (DrawablePtr	pSrcDrawable,
 					xOut - pDstDrawable->x,
 					yOut - pDstDrawable->y,
 					(unsigned long) bitPlane);
-    REGION_UNINIT(pGC->pScreen, &rgnDst);
+    RegionUninit(&rgnDst);
     if (freeSrcClip)
-	REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+	RegionDestroy(prgnSrcClip);
     fbValidateDrawable (pDstDrawable);
     return prgnExposed;
 }
diff --git a/nx-X11/programs/Xserver/fb/fbfill.c b/nx-X11/programs/Xserver/fb/fbfill.c
index c61ff3b4c..be6723c01 100644
--- a/nx-X11/programs/Xserver/fb/fbfill.c
+++ b/nx-X11/programs/Xserver/fb/fbfill.c
@@ -184,7 +184,7 @@ fbSolidBoxClipped (DrawablePtr	pDrawable,
 
     fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
     
-    for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); 
+    for (nbox = RegionNumRects(pClip), pbox = RegionRects(pClip); 
 	 nbox--; 
 	 pbox++)
     {
diff --git a/nx-X11/programs/Xserver/fb/fbfillrect.c b/nx-X11/programs/Xserver/fb/fbfillrect.c
index 2a60da165..37a7b20f7 100644
--- a/nx-X11/programs/Xserver/fb/fbfillrect.c
+++ b/nx-X11/programs/Xserver/fb/fbfillrect.c
@@ -47,7 +47,7 @@ fbPolyFillRect(DrawablePtr  pDrawable,
     xorg = pDrawable->x;
     yorg = pDrawable->y;
     
-    pextent = REGION_EXTENTS(pGC->pScreen, pClip);
+    pextent = RegionExtents(pClip);
     extentX1 = pextent->x1;
     extentY1 = pextent->y1;
     extentX2 = pextent->x2;
@@ -74,7 +74,7 @@ fbPolyFillRect(DrawablePtr  pDrawable,
 
 	if ((fullX1 >= fullX2) || (fullY1 >= fullY2))
 	    continue;
-	n = REGION_NUM_RECTS (pClip);
+	n = RegionNumRects (pClip);
 	if (n == 1)
 	{
 	    fbFill (pDrawable,
@@ -83,7 +83,7 @@ fbPolyFillRect(DrawablePtr  pDrawable,
 	}
 	else
 	{
-	    pbox = REGION_RECTS(pClip);
+	    pbox = RegionRects(pClip);
 	    /* 
 	     * clip the rectangle to each box in the clip region
 	     * this is logically equivalent to calling Intersect()
diff --git a/nx-X11/programs/Xserver/fb/fbfillsp.c b/nx-X11/programs/Xserver/fb/fbfillsp.c
index e2bb71e3a..5d465482f 100644
--- a/nx-X11/programs/Xserver/fb/fbfillsp.c
+++ b/nx-X11/programs/Xserver/fb/fbfillsp.c
@@ -44,7 +44,7 @@ fbFillSpans (DrawablePtr    pDrawable,
     int		    fullX1, fullX2, fullY1;
     int		    partX1, partX2;
     
-    pextent = REGION_EXTENTS(pGC->pScreen, pClip);
+    pextent = RegionExtents(pClip);
     extentX1 = pextent->x1;
     extentY1 = pextent->y1;
     extentX2 = pextent->x2;
@@ -69,7 +69,7 @@ fbFillSpans (DrawablePtr    pDrawable,
 	if (fullX1 >= fullX2)
 	    continue;
 	
-	nbox = REGION_NUM_RECTS (pClip);
+	nbox = RegionNumRects (pClip);
 	if (nbox == 1)
 	{
 	    fbFill (pDrawable,
@@ -78,7 +78,7 @@ fbFillSpans (DrawablePtr    pDrawable,
 	}
 	else
 	{
-	    pbox = REGION_RECTS(pClip);
+	    pbox = RegionRects(pClip);
 	    while(nbox--)
 	    {
 		if (pbox->y1 <= fullY1 && fullY1 < pbox->y2)
diff --git a/nx-X11/programs/Xserver/fb/fbgc.c b/nx-X11/programs/Xserver/fb/fbgc.c
index fdd7a319c..a980023ef 100644
--- a/nx-X11/programs/Xserver/fb/fbgc.c
+++ b/nx-X11/programs/Xserver/fb/fbgc.c
@@ -211,7 +211,7 @@ fbValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
 	)
     {
 	miComputeCompositeClip (pGC, pDrawable);
-	pPriv->oneRect = REGION_NUM_RECTS(fbGetCompositeClip(pGC)) == 1;
+	pPriv->oneRect = RegionNumRects(fbGetCompositeClip(pGC)) == 1;
     }
     
 #ifdef FB_24_32BIT    
diff --git a/nx-X11/programs/Xserver/fb/fbglyph.c b/nx-X11/programs/Xserver/fb/fbglyph.c
index bb0dda669..3c0913cf8 100644
--- a/nx-X11/programs/Xserver/fb/fbglyph.c
+++ b/nx-X11/programs/Xserver/fb/fbglyph.c
@@ -41,7 +41,7 @@ fbGlyphIn (RegionPtr	pRegion,
 	   int		height)
 {
     BoxRec  box;
-    BoxPtr  pExtents = REGION_EXTENTS (dummyScreen, pRegion);
+    BoxPtr  pExtents = RegionExtents(pRegion);
 
     /*
      * Check extents by hand to avoid 16 bit overflows
@@ -58,7 +58,7 @@ fbGlyphIn (RegionPtr	pRegion,
     box.x2 = x + width;
     box.y1 = y;
     box.y2 = y + height;
-    return RECT_IN_REGION (dummyScreen, pRegion, &box) == rgnIN;
+    return RegionContainsRect(pRegion, &box) == rgnIN;
 }
 
 #ifdef FB_24BIT
diff --git a/nx-X11/programs/Xserver/fb/fbimage.c b/nx-X11/programs/Xserver/fb/fbimage.c
index 96bd8cf95..06b501b41 100644
--- a/nx-X11/programs/Xserver/fb/fbimage.c
+++ b/nx-X11/programs/Xserver/fb/fbimage.c
@@ -140,8 +140,8 @@ fbPutZImage (DrawablePtr	pDrawable,
 
     fbGetStipDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
 
-    for (nbox = REGION_NUM_RECTS (pClip),
-	 pbox = REGION_RECTS(pClip);
+    for (nbox = RegionNumRects (pClip),
+	 pbox = RegionRects(pClip);
 	 nbox--;
 	 pbox++)
     {
@@ -228,8 +228,8 @@ fbPutXYImage (DrawablePtr	pDrawable,
 	}
     }
 
-    for (nbox = REGION_NUM_RECTS (pClip),
-	 pbox = REGION_RECTS(pClip);
+    for (nbox = RegionNumRects (pClip),
+	 pbox = RegionRects(pClip);
 	 nbox--;
 	 pbox++)
     {
diff --git a/nx-X11/programs/Xserver/fb/fbline.c b/nx-X11/programs/Xserver/fb/fbline.c
index 8e99dd99f..0a9954998 100644
--- a/nx-X11/programs/Xserver/fb/fbline.c
+++ b/nx-X11/programs/Xserver/fb/fbline.c
@@ -119,7 +119,7 @@ fbPolyLine (DrawablePtr	pDrawable,
 #ifndef FBNOPIXADDR
 	if (pGC->fillStyle == FillSolid &&
 	    pGC->lineStyle == LineSolid &&
-	    REGION_NUM_RECTS (fbGetCompositeClip(pGC)) == 1)
+	    RegionNumRects (fbGetCompositeClip(pGC)) == 1)
 	{
 	    switch (pDrawable->bitsPerPixel) {
 	    case 8:  line = fbPolyline8; break;
@@ -156,7 +156,7 @@ fbPolySegment (DrawablePtr  pDrawable,
 #ifndef FBNOPIXADDR
 	if (pGC->fillStyle == FillSolid &&
 	    pGC->lineStyle == LineSolid &&
-	    REGION_NUM_RECTS (fbGetCompositeClip(pGC)) == 1)
+	    RegionNumRects (fbGetCompositeClip(pGC)) == 1)
 	{
 	    switch (pDrawable->bitsPerPixel) {
 	    case 8:  seg = fbPolySegment8; break;
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.c b/nx-X11/programs/Xserver/fb/fboverlay.c
index 81c54316f..49623ba4f 100644
--- a/nx-X11/programs/Xserver/fb/fboverlay.c
+++ b/nx-X11/programs/Xserver/fb/fboverlay.c
@@ -74,7 +74,7 @@ fbOverlayCreateWindow(WindowPtr pWin)
 	     */
 	    if (!pWin->parent)
 	    {
-		REGION_EMPTY (pWin->drawable.pScreen,
+		RegionEmpty(
 			      &pScrPriv->layer[i].u.run.region);
 	    }
 	    return TRUE;
@@ -92,7 +92,7 @@ fbOverlayCloseScreen (int iScreen, ScreenPtr pScreen)
     for (i = 0; i < pScrPriv->nlayers; i++)
     {
 	(*pScreen->DestroyPixmap)(pScrPriv->layer[i].u.run.pixmap);
-	REGION_UNINIT (pScreen, &pScrPriv->layer[i].u.run.region);
+	RegionUninit(&pScrPriv->layer[i].u.run.region);
     }
     return TRUE;
 }
@@ -146,7 +146,7 @@ fbOverlayCreateScreenResources(ScreenPtr pScreen)
 					    pbits))
 	    return FALSE;
 	pScrPriv->layer[i].u.run.pixmap = pPixmap;
-	REGION_INIT(pScreen, &pScrPriv->layer[i].u.run.region, &box, 0);
+	RegionInit(&pScrPriv->layer[i].u.run.region, &box, 0);
     }
     pScreen->devPrivate = pScrPriv->layer[0].u.run.pixmap;
     return TRUE;
@@ -174,24 +174,24 @@ fbOverlayUpdateLayerRegion (ScreenPtr	pScreen,
     int			i;
     RegionRec		rgnNew;
     
-    if (!prgn || !REGION_NOTEMPTY(pScreen, prgn))
+    if (!prgn || !RegionNotEmpty(prgn))
 	return;
     for (i = 0; i < pScrPriv->nlayers; i++)
     {
 	if (i == layer)
 	{
 	    /* add new piece to this fb */
-	    REGION_UNION (pScreen,
+	    RegionUnion(
 			  &pScrPriv->layer[i].u.run.region,
 			  &pScrPriv->layer[i].u.run.region,
 			  prgn);
 	}
-	else if (REGION_NOTEMPTY (pScreen, 
+	else if (RegionNotEmpty(
 				  &pScrPriv->layer[i].u.run.region))
 	{
 	    /* paint new piece with chroma key */
-	    REGION_NULL (pScreen, &rgnNew);
-	    REGION_INTERSECT (pScreen,
+	    RegionNull(&rgnNew);
+	    RegionIntersect(
 			      &rgnNew, 
 			      prgn, 
 			      &pScrPriv->layer[i].u.run.region);
@@ -199,9 +199,9 @@ fbOverlayUpdateLayerRegion (ScreenPtr	pScreen,
 				   &rgnNew,
 				   pScrPriv->layer[i].key,
 				   i);
-	    REGION_UNINIT(pScreen, &rgnNew);
+	    RegionUninit(&rgnNew);
 	    /* remove piece from other fbs */
-	    REGION_SUBTRACT (pScreen,
+	    RegionSubtract(
 			     &pScrPriv->layer[i].u.run.region,
 			     &pScrPriv->layer[i].u.run.region,
 			     prgn);
@@ -231,21 +231,21 @@ fbOverlayCopyWindow(WindowPtr	pWin,
     /*
      * Clip to existing bits
      */
-    REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
-    REGION_NULL (pScreen, &rgnDst);
-    REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
-    REGION_TRANSLATE(pScreen, &rgnDst, dx, dy);
+    RegionTranslate(prgnSrc, -dx, -dy);
+    RegionNull(&rgnDst);
+    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
+    RegionTranslate(&rgnDst, dx, dy);
     /*
      * Compute the portion of each fb affected by this copy
      */
     for (i = 0; i < pScrPriv->nlayers; i++)
     {
-	REGION_NULL (pScreen, &layerRgn[i]);
-	REGION_INTERSECT(pScreen, &layerRgn[i], &rgnDst,
+	RegionNull(&layerRgn[i]);
+	RegionIntersect(&layerRgn[i], &rgnDst,
 			 &pScrPriv->layer[i].u.run.region);
-	if (REGION_NOTEMPTY (pScreen, &layerRgn[i]))
+	if (RegionNotEmpty(&layerRgn[i]))
 	{
-	    REGION_TRANSLATE(pScreen, &layerRgn[i], -dx, -dy);
+	    RegionTranslate(&layerRgn[i], -dx, -dy);
 	    pPixmap = pScrPriv->layer[i].u.run.pixmap;
 	    fbCopyRegion (&pPixmap->drawable, &pPixmap->drawable,
 			  0,
@@ -258,12 +258,12 @@ fbOverlayCopyWindow(WindowPtr	pWin,
      */
     for (i = 0; i < pScrPriv->nlayers; i++)
     {
-	if (REGION_NOTEMPTY (pScreen, &layerRgn[i]))
+	if (RegionNotEmpty(&layerRgn[i]))
 	    fbOverlayUpdateLayerRegion (pScreen, i, &layerRgn[i]);
 
-	REGION_UNINIT(pScreen, &layerRgn[i]);
+	RegionUninit(&layerRgn[i]);
     }
-    REGION_UNINIT(pScreen, &rgnDst);
+    RegionUninit(&rgnDst);
 }   
 
 void
diff --git a/nx-X11/programs/Xserver/fb/fbpict.c b/nx-X11/programs/Xserver/fb/fbpict.c
index 5ab3756b9..330c55de3 100644
--- a/nx-X11/programs/Xserver/fb/fbpict.c
+++ b/nx-X11/programs/Xserver/fb/fbpict.c
@@ -1248,8 +1248,8 @@ fbComposite (CARD8      op,
                                    height))
         return;
 
-    n = REGION_NUM_RECTS (&region);
-    pbox = REGION_RECTS (&region);
+    n = RegionNumRects (&region);
+    pbox = RegionRects (&region);
     while (n--)
     {
 	h = pbox->y2 - pbox->y1;
@@ -1309,7 +1309,7 @@ fbComposite (CARD8      op,
 	}
 	pbox++;
     }
-    REGION_UNINIT (pDst->pDrawable->pScreen, &region);
+    RegionUninit(&region);
 }
 
 #endif /* RENDER */
diff --git a/nx-X11/programs/Xserver/fb/fbpixmap.c b/nx-X11/programs/Xserver/fb/fbpixmap.c
index 7ea288cb1..99c03862b 100644
--- a/nx-X11/programs/Xserver/fb/fbpixmap.c
+++ b/nx-X11/programs/Xserver/fb/fbpixmap.c
@@ -118,8 +118,8 @@ if (((rx1) < (rx2)) && ((ry1) < (ry2)) &&			\
 {								\
     if ((reg)->data->numRects == (reg)->data->size)		\
     {								\
-	miRectAlloc(reg, 1);					\
-	fr = REGION_BOXPTR(reg);				\
+	RegionRectAlloc(reg, 1);					\
+	fr = RegionBoxptr(reg);				\
 	r = fr + (reg)->data->numRects;				\
     }								\
     r->x1 = (rx1);						\
@@ -156,10 +156,10 @@ fbPixmapToRegion(PixmapPtr pPix)
     FbBits		*pwLine;
     int			nWidth;
     
-    pReg = REGION_CREATE(pPix->drawable.pScreen, NULL, 1);
+    pReg = RegionCreate(NULL, 1);
     if(!pReg)
 	return NullRegion;
-    FirstRect = REGION_BOXPTR(pReg);
+    FirstRect = RegionBoxptr(pReg);
     rects = FirstRect;
 
     pwLine = (FbBits *) pPix->devPrivate.ptr;
@@ -305,8 +305,8 @@ fbPixmapToRegion(PixmapPtr pPix)
 	pReg->extents.x1 = pReg->extents.x2 = 0;
     else
     {
-	pReg->extents.y1 = REGION_BOXPTR(pReg)->y1;
-	pReg->extents.y2 = REGION_END(pReg)->y2;
+	pReg->extents.y1 = RegionBoxptr(pReg)->y1;
+	pReg->extents.y2 = RegionEnd(pReg)->y2;
 	if (pReg->data->numRects == 1)
 	{
 	    xfree(pReg->data);
@@ -314,7 +314,7 @@ fbPixmapToRegion(PixmapPtr pPix)
 	}
     }
 #ifdef DEBUG
-    if (!miValidRegion(pReg))
+    if (!RegionIsValid(pReg))
 	FatalError("Assertion failed file %s, line %d: expr\n", __FILE__, __LINE__);
 #endif
     return(pReg);
diff --git a/nx-X11/programs/Xserver/fb/fbpoint.c b/nx-X11/programs/Xserver/fb/fbpoint.c
index 5229d6970..06d8662ba 100644
--- a/nx-X11/programs/Xserver/fb/fbpoint.c
+++ b/nx-X11/programs/Xserver/fb/fbpoint.c
@@ -157,7 +157,7 @@ fbPolyPoint (DrawablePtr    pDrawable,
     case 32:    dots = fbDots32; break;
     }
 #endif
-    for (nBox = REGION_NUM_RECTS (pClip), pBox = REGION_RECTS (pClip);
+    for (nBox = RegionNumRects (pClip), pBox = RegionRects (pClip);
 	 nBox--; pBox++)
 	(*dots) (dst, dstStride, dstBpp, pBox, pptInit, nptInit, 
 		 pDrawable->x, pDrawable->y, dstXoff, dstYoff, and, xor);
diff --git a/nx-X11/programs/Xserver/fb/fbpseudocolor.c b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
index 469f3ea08..51f21ed21 100644
--- a/nx-X11/programs/Xserver/fb/fbpseudocolor.c
+++ b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
@@ -166,10 +166,10 @@ int xxGeneration;
 # define PRINT_RECTS(rec) {\
        int i;\
        BoxPtr box;\
-       ErrorF("RECTS: %i\n",REGION_NUM_RECTS(&rec));\
-       if (REGION_NUM_RECTS(&rec) > 1)  { \
-          for (i = 0; i < REGION_NUM_RECTS(&rec); i++ ) {\
-             box = REGION_BOX(&rec,i);\
+       ErrorF("RECTS: %i\n",RegionNumRects(&rec));\
+       if (RegionNumRects(&rec) > 1)  { \
+          for (i = 0; i < RegionNumRects(&rec); i++ ) {\
+             box = RegionBox(&rec,i);\
 	     ErrorF("x1: %hi x2: %hi y1: %hi y2: %hi\n", \
              box->x1,box->x2,box->y1,box->y2);\
           }\
@@ -308,8 +308,8 @@ xxCreateScreenResources(ScreenPtr pScreen)
     box.y1 = 0;
     box.x2 = pScreen->width;
     box.y2 = pScreen->height;
-    REGION_NULL(pScreen, &pScrPriv->region);
-    REGION_INIT(pScreen, &pScrPriv->bRegion, &box, 0);
+    RegionNull(&pScrPriv->region);
+    RegionInit(&pScrPriv->bRegion, &box, 0);
     
     return TRUE;
 }
@@ -323,7 +323,7 @@ xxCloseScreen (int iScreen, ScreenPtr pScreen)
     (*pScreen->DestroyPixmap)(pScrPriv->pPixmap);
     /* We don't need to free the baseColormap as FreeClientResourcess
        will have taken care of it. */
-    REGION_UNINIT (pScreen, &pScrPriv->region);
+    RegionUninit(&pScrPriv->region);
     
     unwrap (pScrPriv,pScreen, CloseScreen);
     ret = pScreen->CloseScreen(iScreen,pScreen);
@@ -678,7 +678,7 @@ xxCreateWindow(WindowPtr pWin)
     pWin->devPrivates[fbWinPrivateIndex].ptr = (void *) pScrPriv->pPixmap;
     PRINT_RECTS(pScrPriv->region);
 	if (!pWin->parent) {
-	REGION_EMPTY (pWin->drawable.pScreen, &pScrPriv->region);
+	RegionEmpty(&pScrPriv->region);
     }
     PRINT_RECTS(pScrPriv->region);
     
@@ -694,11 +694,11 @@ xxWalkChildren(WindowPtr pWin, RegionPtr pReg, PixmapPtr pPixmap)
     do {
 	if (fbGetWindowPixmap(pCurWin) == pPixmap) {
 	    DBG("WalkWindow Add\n");
-	    REGION_UNION(pWin->drawable.pScreen,pReg,pReg,
+	    RegionUnion(pReg,pReg,
 			 &pCurWin->borderClip);
 	} else {
 	    DBG("WalkWindow Sub\n");
-	    REGION_SUBTRACT(pWin->drawable.pScreen,pReg,pReg,
+	    RegionSubtract(pReg,pReg,
 			    &pCurWin->borderClip);
 	}
 	if (pCurWin->lastChild)
@@ -713,7 +713,7 @@ xxPickMyWindows(WindowPtr pWin, RegionPtr pRgn)
     xxScrPriv(pScreen);
 
     if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
-	REGION_UNION(pWin->drawable.pScreen,pRgn,pRgn,&pWin->borderClip);
+	RegionUnion(pRgn,pRgn,&pWin->borderClip);
     }
     if (pWin->lastChild)
 	xxWalkChildren(pWin->lastChild,pRgn,pScrPriv->pPixmap);
@@ -736,11 +736,11 @@ xxCopyWindow(WindowPtr	pWin,
     dx = ptOldOrg.x - pWin->drawable.x;
     dy = ptOldOrg.y - pWin->drawable.y;
 
-    REGION_NULL(pScreen, &rgn_new);
-    REGION_UNION(pScreen, &rgn_new,&rgn_new,prgnSrc);
-    REGION_TRANSLATE(pScreen,&rgn_new,-dx,-dy);
+    RegionNull(&rgn_new);
+    RegionUnion(&rgn_new,&rgn_new,prgnSrc);
+    RegionTranslate(&rgn_new,-dx,-dy);
 
-    REGION_NULL(pScreen, &rgn);
+    RegionNull(&rgn);
     xxPickMyWindows(pWin,&rgn);
 
     unwrap (pScrPriv, pScreen, CopyWindow);
@@ -749,19 +749,19 @@ xxCopyWindow(WindowPtr	pWin,
     pWin->devPrivates[fbWinPrivateIndex].ptr = pPixmap;
     wrap(pScrPriv, pScreen, CopyWindow, xxCopyWindow);
 
-    REGION_INTERSECT(pScreen,&rgn,&rgn,&rgn_new);
-    if (REGION_NOTEMPTY (pScreen,&rgn)) {
+    RegionIntersect(&rgn,&rgn,&rgn_new);
+    if (RegionNotEmpty(&rgn)) {
 	fbCopyRegion(&pScrPriv->pPixmap->drawable,&pScrPriv->pPixmap->drawable,
 		     0,&rgn,dx,dy,fbCopyWindowProc,0,(void*)0);
-	REGION_TRANSLATE(pScreen,&rgn,dx,dy);
-	REGION_INTERSECT(pScreen,&rgn_new,&pScrPriv->region,&rgn);
-	REGION_SUBTRACT(pScreen,&pScrPriv->region,&pScrPriv->region,&rgn);
-	REGION_TRANSLATE(pScreen,&rgn_new,-dx,-dy);
-	REGION_UNION(pScreen,&pScrPriv->region,&pScrPriv->region,&rgn_new);
+	RegionTranslate(&rgn,dx,dy);
+	RegionIntersect(&rgn_new,&pScrPriv->region,&rgn);
+	RegionSubtract(&pScrPriv->region,&pScrPriv->region,&rgn);
+	RegionTranslate(&rgn_new,-dx,-dy);
+	RegionUnion(&pScrPriv->region,&pScrPriv->region,&rgn_new);
     }
 #if 1
-    REGION_UNINIT(pScreen,&rgn_new);
-    REGION_UNINIT(pScreen,&rgn);
+    RegionUninit(&rgn_new);
+    RegionUninit(&rgn);
 #endif
 }
 
@@ -775,14 +775,14 @@ xxWindowExposures (WindowPtr	pWin,
     if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
 	DBG("WindowExposures\n");
 	PRINT_RECTS(pScrPriv->region);
-	REGION_UNION(pWin->drawable.pScreen,&pScrPriv->region,
+	RegionUnion(&pScrPriv->region,
 		     &pScrPriv->region,
 		     prgn);
 	PRINT_RECTS(pScrPriv->region);
     } else {
 	DBG("WindowExposures NonPseudo\n");
 	PRINT_RECTS(pScrPriv->region);
-	REGION_SUBTRACT(pWin->drawable.pScreen,&pScrPriv->region,
+	RegionSubtract(&pScrPriv->region,
 		     &pScrPriv->region,
 		     prgn);
 	PRINT_RECTS(pScrPriv->region);
@@ -800,23 +800,23 @@ xxPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
 
     DBG("xxPaintWindow\n");
 
-    REGION_NULL (pWin->drawable.pScreen, &rgni);
+    RegionNull(&rgni);
 #if 0
-    REGION_UNION (pWin->drawable.pScreen, &rgni, &rgni, &pWin->borderClip);
-    REGION_INTERSECT(pWin->drawable.pScreen, &rgni, &rgni, pRegion);
+    RegionUnion(&rgni, &rgni, &pWin->borderClip);
+    RegionIntersect(&rgni, &rgni, pRegion);
 #else
-    REGION_UNION (pWin->drawable.pScreen, &rgni, &rgni, pRegion);
+    RegionUnion(&rgni, &rgni, pRegion);
 #endif
     switch (what) {
     case PW_BORDER:
-	REGION_SUBTRACT (pWin->drawable.pScreen, &rgni, &rgni, &pWin->winSize);
+	RegionSubtract(&rgni, &rgni, &pWin->winSize);
 	if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
 	    DBG("PaintWindowBorder\n");
-	    REGION_UNION (pWin->drawable.pScreen, &pScrPriv->region,
+	    RegionUnion(&pScrPriv->region,
 			  &pScrPriv->region, &rgni);
 	} else {
 	    DBG("PaintWindowBorder NoOverlay\n");
-	    REGION_SUBTRACT (pWin->drawable.pScreen, &pScrPriv->region,
+	    RegionSubtract(&pScrPriv->region,
 			     &pScrPriv->region, &rgni);	
 	}
 	unwrap (pScrPriv, pWin->drawable.pScreen, PaintWindowBorder);
@@ -829,15 +829,15 @@ xxPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
 	case None:
 	    break;
 	default:
-	    REGION_INTERSECT (pWin->drawable.pScreen, &rgni,
+	    RegionIntersect(&rgni,
 			      &rgni,&pWin->winSize);
 	    if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
 		DBG("PaintWindowBackground\n");
-		REGION_UNION (pWin->drawable.pScreen, &pScrPriv->region,
+		RegionUnion(&pScrPriv->region,
 			      &pScrPriv->region, &rgni);
 	    } else {
 		DBG("PaintWindowBackground NoOverlay\n");
-		REGION_SUBTRACT (pWin->drawable.pScreen, &pScrPriv->region,
+		RegionSubtract(&pScrPriv->region,
 				 &pScrPriv->region, &rgni);	
 	    }
 	    break;
@@ -852,7 +852,7 @@ xxPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
     PRINT_RECTS(rgni);
     PRINT_RECTS(pScrPriv->region);
 #if 1
-    REGION_UNINIT(pWin->drawable.pScreen,&rgni);
+    RegionUninit(&rgni);
 #endif
 }
 
@@ -862,8 +862,8 @@ xxCopyPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
 {
     xxScrPriv(pScreen);
     CARD32		mask = (1 << pScrPriv->myDepth) - 1;
-    int			num = REGION_NUM_RECTS(pReg);
-    BoxPtr		pbox = REGION_RECTS(pReg);
+    int			num = RegionNumRects(pReg);
+    BoxPtr		pbox = RegionRects(pReg);
     int			width, height;
     CARD8		*src;
     CARD16		*dst, *dst_base;
@@ -905,8 +905,8 @@ xxUpdateCmapPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
 {
     xxScrPriv(pScreen);
     CARD32		mask = (1 << pScrPriv->myDepth) - 1;
-    int			num = REGION_NUM_RECTS(pReg);
-    BoxPtr		pbox = REGION_RECTS(pReg);
+    int			num = RegionNumRects(pReg);
+    BoxPtr		pbox = RegionRects(pReg);
     int			width, height;
     CARD8		*src;
     CARD16		*dst, *dst_base;
@@ -950,14 +950,14 @@ xxUpdateCmapPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
 static void
 xxGetWindowRegion(WindowPtr pWin,RegionPtr winreg)
 {
-    REGION_NULL(pWin->drawable.pScreen,winreg);
+    RegionNull(winreg);
     /* get visible part of the border ...Argh */
-    REGION_SUBTRACT(pWin->drawable.pScreen,winreg,&pWin->borderSize,
+    RegionSubtract(winreg,&pWin->borderSize,
 		    &pWin->winSize);
-    REGION_INTERSECT(pWin->drawable.pScreen,winreg,winreg,
+    RegionIntersect(winreg,winreg,
 		     &pWin->borderClip);
     /* add window interior excluding children */
-    REGION_UNION(pWin->drawable.pScreen,winreg,winreg,
+    RegionUnion(winreg,winreg,
 		 &pWin->clipList);
 }
 
@@ -985,18 +985,18 @@ xxUpdateRegion(WindowPtr pWin, void * unused)
 	    if (!pCmapPriv->dirty)
 		goto CONTINUE;
 
-	    REGION_NULL (pScreen, &rgni);
+	    RegionNull(&rgni);
 	    /* This will be taken care of when damaged regions are updated */
-	    REGION_SUBTRACT(pScreen, &rgni, &winreg, &pScrPriv->region);
-	    if (REGION_NOTEMPTY (pScreen,&rgni))
+	    RegionSubtract(&rgni, &winreg, &pScrPriv->region);
+	    if (RegionNotEmpty(&rgni))
 		xxUpdateCmapPseudocolorRegion(pScreen,&rgni, pCmapPriv);
 	}
     CONTINUE:
 
-	REGION_NULL (pScreen, &rgni);
-	REGION_INTERSECT (pScreen, &rgni, &winreg, &pScrPriv->region);
+	RegionNull(&rgni);
+	RegionIntersect(&rgni, &winreg, &pScrPriv->region);
 	
-	if (REGION_NOTEMPTY (pScreen,&rgni)) {
+	if (RegionNotEmpty(&rgni)) {
 	    if (pmap == (void *) -1) {
 		pmap =
 		    (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
@@ -1008,12 +1008,12 @@ xxUpdateRegion(WindowPtr pWin, void * unused)
 	    
 	    if (pCmapPriv != (void *)-1)
 		xxCopyPseudocolorRegion(pScreen,&rgni, pCmapPriv);
-	    REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
+	    RegionSubtract(&pScrPriv->region, &pScrPriv->region,
 			    &rgni);
 	}
 #if 1
-	REGION_UNINIT(pScreen,&rgni);
-	REGION_UNINIT(pScreen,&winreg);
+	RegionUninit(&rgni);
+	RegionUninit(&winreg);
 #endif
     }
     return WT_WALKCHILDREN;
@@ -1033,7 +1033,7 @@ xxUpdateFb(ScreenPtr pScreen)
     
     WalkTree(pScreen,xxUpdateRegion,NULL);
 #if 0
-    if (REGION_NOTEMPTY (pScreen,&pScrPriv->region)) {
+    if (RegionNotEmpty(&pScrPriv->region)) {
 	ColormapPtr pmap = (void *) -1;
 	xxCmapPrivPtr pCmapPriv;
 	
@@ -1042,7 +1042,7 @@ xxUpdateFb(ScreenPtr pScreen)
 	pCmapPriv = xxGetCmapPriv(pmap);
 	if (pCmapPriv != (void *)-1)
 	    xxCopyPseudocolorRegion(pScreen,&pScrPriv->region, pCmapPriv);
-	REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
+	RegionSubtract(&pScrPriv->region, &pScrPriv->region,
 			&pScrPriv->region);
     }
 #endif
@@ -1071,7 +1071,7 @@ xxBlockHandler (void *	data,
     ScreenPtr	pScreen = (ScreenPtr) data;
     xxScrPriv(pScreen);
 
-    if (REGION_NOTEMPTY (pScreen,&pScrPriv->region) || pScrPriv->colormapDirty)
+    if (RegionNotEmpty(&pScrPriv->region) || pScrPriv->colormapDirty)
 	xxUpdateFb (pScreen);
 }
 
@@ -1241,15 +1241,15 @@ GCOps xxGCOps = {
     if (BOX_NOT_EMPTY(box)) { \
        RegionRec region; \
        ScreenPtr pScreen = pGC->pScreen;\
-       REGION_INIT (pScreen, &region, &box, 1); \
-       REGION_INTERSECT(pScreen,&region,&region,\
+       RegionInit(&region, &box, 1); \
+       RegionIntersect(&region,&region,\
                                  (pGC)->pCompositeClip);\
-       if (REGION_NOTEMPTY(pScreen,&region)) { \
+       if (RegionNotEmpty(&region)) { \
            xxScrPriv(pScreen);\
 	   PRINT_RECTS(pScrPriv->region);\
-           REGION_UNION(pScreen,&pScrPriv->region,&pScrPriv->region,&region);\
+           RegionUnion(&pScrPriv->region,&pScrPriv->region,&region);\
 	   PRINT_RECTS(pScrPriv->region);\
-           REGION_UNINIT(pScreen,&region);\
+           RegionUninit(&region);\
        }\
    }\
 }
@@ -2234,11 +2234,11 @@ xxPushPixels(
        RegionRec region; \
        xxScrPriv(pScreen);\
        ScreenPtr pScreen = pScreen;\
-       REGION_INIT (pScreen, &region, &box, 1); \
+       RegionInit(&region, &box, 1); \
        PRINT_RECTS(pScrPriv->region);\
-       REGION_UNION(pScreen,&pScrPriv->region,&pScrPriv->region,&region);\
+       RegionUnion(&pScrPriv->region,&pScrPriv->region,&region);\
        PRINT_RECTS(pScrPriv->region);\
-       REGION_UNINIT(pScreen,&region);\
+       RegionUninit(&region);\
    }\
 }
 
diff --git a/nx-X11/programs/Xserver/fb/fbpush.c b/nx-X11/programs/Xserver/fb/fbpush.c
index 8f1336963..78d2e450d 100644
--- a/nx-X11/programs/Xserver/fb/fbpush.c
+++ b/nx-X11/programs/Xserver/fb/fbpush.c
@@ -192,8 +192,8 @@ fbPushImage (DrawablePtr    pDrawable,
     BoxPtr	pbox;
     int		x1, y1, x2, y2;
     
-    for (nbox = REGION_NUM_RECTS (pClip),
-	 pbox = REGION_RECTS(pClip);
+    for (nbox = RegionNumRects (pClip),
+	 pbox = RegionRects(pClip);
 	 nbox--;
 	 pbox++)
     {
diff --git a/nx-X11/programs/Xserver/fb/fbseg.c b/nx-X11/programs/Xserver/fb/fbseg.c
index 18a996e0c..2947992a6 100644
--- a/nx-X11/programs/Xserver/fb/fbseg.c
+++ b/nx-X11/programs/Xserver/fb/fbseg.c
@@ -615,8 +615,8 @@ fbSegment (DrawablePtr	pDrawable,
     unsigned int oc1;	/* outcode of point 1 */
     unsigned int oc2;	/* outcode of point 2 */
 
-    nBox = REGION_NUM_RECTS (pClip);
-    pBox = REGION_RECTS (pClip);
+    nBox = RegionNumRects (pClip);
+    pBox = RegionRects (pClip);
     
     bres = fbSelectBres (pDrawable, pGC);
     
diff --git a/nx-X11/programs/Xserver/fb/fbsetsp.c b/nx-X11/programs/Xserver/fb/fbsetsp.c
index eefc2da82..c7074f036 100644
--- a/nx-X11/programs/Xserver/fb/fbsetsp.c
+++ b/nx-X11/programs/Xserver/fb/fbsetsp.c
@@ -63,8 +63,8 @@ fbSetSpans (DrawablePtr	    pDrawable,
 	xoff = (int) (((long) src) & (FB_MASK >> 3));
 	s = (FbBits *) (src - xoff);
 	xoff <<= 3;
-	n = REGION_NUM_RECTS(pClip);
-	pbox = REGION_RECTS (pClip);
+	n = RegionNumRects(pClip);
+	pbox = RegionRects (pClip);
 	while (n--)
 	{
 	    if (pbox->y1 > ppt->y)
diff --git a/nx-X11/programs/Xserver/fb/fbwindow.c b/nx-X11/programs/Xserver/fb/fbwindow.c
index 1269902b9..5ce7ba729 100644
--- a/nx-X11/programs/Xserver/fb/fbwindow.c
+++ b/nx-X11/programs/Xserver/fb/fbwindow.c
@@ -132,15 +132,15 @@ fbCopyWindow(WindowPtr	    pWin,
 
     dx = ptOldOrg.x - pWin->drawable.x;
     dy = ptOldOrg.y - pWin->drawable.y;
-    REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
+    RegionTranslate(prgnSrc, -dx, -dy);
 
-    REGION_NULL (pWin->drawable.pScreen, &rgnDst);
+    RegionNull(&rgnDst);
     
-    REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
+    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
 
 #ifdef COMPOSITE
     if (pPixmap->screen_x || pPixmap->screen_y)
-	REGION_TRANSLATE (pWin->drawable.pScreen, &rgnDst, 
+	RegionTranslate(&rgnDst,
 			  -pPixmap->screen_x, -pPixmap->screen_y);
 #endif
 
@@ -148,7 +148,7 @@ fbCopyWindow(WindowPtr	    pWin,
 		  0,
 		  &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
     
-    REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
+    RegionUninit(&rgnDst);
     fbValidateDrawable (&pWin->drawable);
 }
 
@@ -215,8 +215,8 @@ fbFillRegionSolid (DrawablePtr	pDrawable,
     FbStride	dstStride;
     int		dstBpp;
     int		dstXoff, dstYoff;
-    int		n = REGION_NUM_RECTS(pRegion);
-    BoxPtr	pbox = REGION_RECTS(pRegion);
+    int		n = RegionNumRects(pRegion);
+    BoxPtr	pbox = RegionRects(pRegion);
 
     fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
     
@@ -253,8 +253,8 @@ fbFillRegionTiled (DrawablePtr	pDrawable,
     int		tileBpp;
     int		tileXoff, tileYoff; /* XXX assumed to be zero */
     int		tileWidth, tileHeight;
-    int		n = REGION_NUM_RECTS(pRegion);
-    BoxPtr	pbox = REGION_RECTS(pRegion);
+    int		n = RegionNumRects(pRegion);
+    BoxPtr	pbox = RegionRects(pRegion);
     int		xRot = pDrawable->x;
     int		yRot = pDrawable->y;
     
diff --git a/nx-X11/programs/Xserver/fix-miregion b/nx-X11/programs/Xserver/fix-miregion
new file mode 100755
index 000000000..fc502bbfd
--- /dev/null
+++ b/nx-X11/programs/Xserver/fix-miregion
@@ -0,0 +1,29 @@
+#!/bin/sh
+sed -i \
+-e 's/miRegionCreate\b/RegionCreate/g' \
+-e 's/miRegionInit\b/RegionInit/g' \
+-e 's/miRegionDestroy\b/RegionDestroy/g' \
+-e 's/miRegionUninit\b/RegionUninit/g' \
+-e 's/miRegionCopy\b/RegionCopy/g' \
+-e 's/miIntersect\b/RegionIntersect/g' \
+-e 's/miUnion\b/RegionUnion/g' \
+-e 's/miRegionAppend\b/RegionAppend/g' \
+-e 's/miRegionValidate\b/RegionValidate/g' \
+-e 's/miRectsToRegion\b/RegionFromRects/g' \
+-e 's/miSubtract\b/RegionSubtract/g' \
+-e 's/miInverse\b/RegionInverse/g' \
+-e 's/miRectIn\b/RegionContainsRect/g' \
+-e 's/miTranslateRegion\b/RegionTranslate/g' \
+-e 's/miRegionReset\b/RegionReset/g' \
+-e 's/miRegionBreak\b/RegionBreak/g' \
+-e 's/miPointInRegion\b/RegionContainsPoint/g' \
+-e 's/miRegionEqual\b/RegionEqual/g' \
+-e 's/miRegionNotEmpty\b/RegionNotEmpty/g' \
+-e 's/miRegionEmpty\b/RegionEmpty/g' \
+-e 's/miRegionExtents\b/RegionExtents/g' \
+-e 's/miPrintRegion\b/RegionPrint/g' \
+-e 's/miRectAlloc\b/RegionRectAlloc/g' \
+-e 's/miValidRegion\b/RegionIsValid/g' \
+-e 's/miRegionBroken\b/RegionBroken/g' \
+-e 's/miClipSpans\b/RegionClipSpans/g' \
+"$@"
diff --git a/nx-X11/programs/Xserver/fix-miregion-private b/nx-X11/programs/Xserver/fix-miregion-private
new file mode 100755
index 000000000..ebc24fac0
--- /dev/null
+++ b/nx-X11/programs/Xserver/fix-miregion-private
@@ -0,0 +1,14 @@
+#!/bin/sh
+sed -i \
+-e 's/miEmptyBox\b/RegionEmptyBox/g' \
+-e 's/miEmptyData\b/RegionEmptyData/g' \
+-e 's/miBrokenData\b/RegionBrokenData/g' \
+-e 's/miBrokenRegion\b/RegionBrokenRegion/g' \
+-e 's/miCoalesce\b/RegionCoalesce/g' \
+-e 's/miAppendNonO\b/RegionAppendNonO/g' \
+-e 's/miRegionOp\b/RegionOp/g' \
+-e 's/miSetExtents\b/RegionSetExtents/g' \
+-e 's/miIntersectO\b/RegionIntersectO/g' \
+-e 's/miUnionO\b/RegionUnionO/g' \
+-e 's/miSubtractO\b/RegionSubtractO/g' \
+"$@"
diff --git a/nx-X11/programs/Xserver/fix-region b/nx-X11/programs/Xserver/fix-region
new file mode 100755
index 000000000..61fe6e0fb
--- /dev/null
+++ b/nx-X11/programs/Xserver/fix-region
@@ -0,0 +1,40 @@
+#!/bin/sh
+sed -i \
+    -e 's/REGION_NIL\b/RegionNil/g' \
+    -e 's/REGION_NAR\b/RegionNar/g' \
+    -e 's/REGION_NUM_RECTS\b/RegionNumRects/g' \
+    -e 's/REGION_SIZE\b/RegionSize/g' \
+    -e 's/REGION_RECTS\b/RegionRects/g' \
+    -e 's/REGION_BOXPTR\b/RegionBoxptr/g' \
+    -e 's/REGION_BOX\b/RegionBox/g' \
+    -e 's/REGION_TOP\b/RegionTop/g' \
+    -e 's/REGION_END\b/RegionEnd/g' \
+    -e 's/REGION_SZOF\b/RegionSizeof/g' \
+    -e 's/REGION_CREATE *([^,]*, */RegionCreate(/g' \
+    -e 's/REGION_COPY *([^,]*, */RegionCopy(/g' \
+    -e 's/REGION_DESTROY *([^,]*, */RegionDestroy(/g' \
+    -e 's/REGION_INTERSECT *([^,]*, */RegionIntersect(/g' \
+    -e 's/REGION_UNION *([^,]*, */RegionUnion(/g' \
+    -e 's/REGION_SUBTRACT *([^,]*, */RegionSubtract(/g' \
+    -e 's/REGION_INVERSE *([^,]*, */RegionInverse(/g' \
+    -e 's/REGION_TRANSLATE *([^,]*, */RegionTranslate(/g' \
+    -e 's/RECT_IN_REGION *([^,]*, */RegionContainsRect(/g' \
+    -e 's/POINT_IN_REGION *([^,]*, */RegionContainsPoint(/g' \
+    -e 's/REGION_EQUAL *([^,]*, */RegionEqual(/g' \
+    -e 's/REGION_APPEND *([^,]*, */RegionAppend(/g' \
+    -e 's/REGION_VALIDATE *([^,]*, */RegionValidate(/g' \
+    -e 's/BITMAP_TO_REGION\b/BitmapToRegion/g' \
+    -e 's/RECTS_TO_REGION *([^,]*, */RegionFromRects(/g' \
+    -e 's/REGION_BREAK *([^,]*, */RegionBreak(/g' \
+    -e 's/REGION_INIT *([^,]*, */RegionInit(/g' \
+    -e 's/REGION_UNINIT *([^,]*, */RegionUninit(/g' \
+    -e 's/REGION_RESET *([^,]*, */RegionReset(/g' \
+    -e 's/REGION_NOTEMPTY *([^,]*, */RegionNotEmpty(/g' \
+    -e 's/REGION_BROKEN *([^,]*, */RegionBroken(/g' \
+    -e 's/REGION_EMPTY *([^,]*, */RegionEmpty(/g' \
+    -e 's/REGION_EXTENTS *([^,]*, */RegionExtents(/g' \
+    -e 's/REGION_NUM_RECTS *([^,]*, */RegionNumRects(/g' \
+    -e 's/REGION_RECTS *([^,]*, */RegionRects(/g' \
+    -e 's/REGION_NULL *([^,]*, */RegionNull(/g' \
+    -e 's/REGION_NULL$/RegionNull/g' \
+    "$@"
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
index 10606a24f..82a1ed77e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
@@ -269,7 +269,9 @@ void nxagentClearSelection(XEvent *X)
 
 void nxagentRequestSelection(XEvent *X)
 {
+  #ifdef DEBUG
   int result;
+  #endif
   int i = 0;
   XSelectionEvent eventSelection;
 
@@ -311,7 +313,7 @@ FIXME: Do we need this?
     if (X->xselectionrequest.target == serverTARGETS)
     {
       Atom xa_STRING = XA_STRING;
-      result = XChangeProperty (nxagentDisplay,
+      XChangeProperty (nxagentDisplay,
                                 X->xselectionrequest.requestor,
                                 X->xselectionrequest.property,
                                 XInternAtom(nxagentDisplay, "ATOM", 0),
@@ -329,7 +331,7 @@ FIXME: Do we need this?
 
       if (i < NumCurrentSelections)
       {
-        result = XChangeProperty(nxagentDisplay,
+        XChangeProperty(nxagentDisplay,
                                  X->xselectionrequest.requestor,
                                  X->xselectionrequest.property,
                                  X->xselectionrequest.target,
@@ -349,7 +351,10 @@ FIXME: Do we need this?
     eventSelection.target = X->xselectionrequest.target;
     eventSelection.time = X->xselectionrequest.time;
 
-    result = XSendEvent(nxagentDisplay,
+    #ifdef DEBUG
+    result =
+    #endif
+    XSendEvent(nxagentDisplay,
                         eventSelection.requestor,
                         False,
                         0L,
@@ -463,7 +468,10 @@ FIXME: Do we need this?
         eventSelection.property = None;
         eventSelection.time = X->xselectionrequest.time;
 
-        result = XSendEvent(nxagentDisplay,
+        #ifdef DEBUG
+        result =
+        #endif
+        XSendEvent(nxagentDisplay,
                             eventSelection.requestor,
                             False,
                             0L,
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
index 3a47e270e..fe3b6ce1d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
@@ -572,10 +572,8 @@ static void nxagentReconnectColormap(void * p0, XID x1, void * p2)
 
 Bool nxagentReconnectAllColormap(void *p0)
 {
-  int flexibility;
   int cid;
   Bool success = True;
-  flexibility = *(int*)p0;
 
   #if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_COLORMAP_DEBUG)
   fprintf(stderr, "nxagentReconnectAllColormap\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Display.c b/nx-X11/programs/Xserver/hw/nxagent/Display.c
index abc6a9380..628c4c495 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Display.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Display.c
@@ -62,7 +62,11 @@ is" without express or implied warranty.
 #include "Init.h"
 #include "Args.h"
 #include "Image.h"
+
+#define Pixmap XlibPixmap
 #include "Icons.h"
+#undef Pixmap
+
 #include "Render.h"
 #include "Font.h"
 #include "Reconnect.h"
@@ -1934,7 +1938,7 @@ Bool nxagentMakeIcon(Display *display, Pixmap *nxIcon, Pixmap *nxMask)
   XlibPixmap IconPixmap;
   XlibPixmap IconShape;
   char* agent_icon_name;
-  char* agentIconData;
+  char** agentIconData;
 
   /*
    * selecting x2go icon when running as X2Go agent
@@ -2446,7 +2450,6 @@ Bool nxagentReconnectDisplay(void *p0)
 {
   int i;
   int flexibility = *(int*)p0;
-  int packMethod, packQuality;
 
   #if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_DISPLAY_DEBUG)
   fprintf(stderr, "nxagentReconnectDisplay\n");
@@ -2464,9 +2467,6 @@ Bool nxagentReconnectDisplay(void *p0)
    * Reset the values to their defaults.
    */
 
-  packMethod  = nxagentPackMethod;
-  packQuality = nxagentPackQuality;
-
   nxagentPackMethod     = -1;
   nxagentPackQuality    = -1;
   nxagentSplitThreshold = -1;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
index 34781e816..51d41db23 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -47,7 +47,7 @@
 /*
  * The list of rectangles composing a region
  * s returned by nxagentGetOptimizedRegion-
- * Boxes() instead of REGION_RECTS().
+ * Boxes() instead of RegionRects().
  */
 
 #define USE_OPTIMIZED_BOXES
@@ -412,10 +412,10 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
   clipRegion = NullRegion;
 
   #ifdef COLLECTED_UPDATES
-  REGION_INIT(pDrawable -> pScreen, &collectedUpdates, NullBox, 1);
+  RegionInit(&collectedUpdates, NullBox, 1);
   #endif
 
-  REGION_INIT(pDrawable -> pScreen, &exposeRegion, NullBox, 1);
+  RegionInit(&exposeRegion, NullBox, 1);
 
   if (nxagentDrawableBitmap(pDrawable) != NullPixmap &&
           nxagentDrawableStatus((DrawablePtr) nxagentDrawableBitmap(pDrawable)) == Synchronized)
@@ -447,7 +447,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
                             nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.y1,
                                 nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.x2,
                                     nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)) -> extents.y2,
-                                        REGION_NUM_RECTS(nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable))));
+                                        RegionNumRects(nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable))));
     #endif
 
     clipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height);
@@ -458,7 +458,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
      * a previous loop.
      */
 
-    REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion,
+    RegionIntersect(clipRegion, clipRegion,
                          nxagentCorruptedRegion((DrawablePtr) nxagentDrawableBitmap(pDrawable)));
 
     /*
@@ -470,14 +470,14 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
      * ronization will fix the error.
      */
 
-    REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion,
+    RegionIntersect(clipRegion, clipRegion,
                          nxagentCorruptedRegion(pDrawable));
 
     /*
      * The bitmap to synchronize is clipped.
      */
 
-    if (REGION_NIL(clipRegion) == 1)
+    if (RegionNil(clipRegion) == 1)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentSynchronizeRegion: The bitmap region [%d,%d,%d,%d] is not viewable. "
@@ -499,7 +499,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
   }
   else
   {
-    if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+    if (pRegion != NullRegion && RegionNil(pRegion) == 1)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentSynchronizeRegion: Region [%d,%d,%d,%d] is nil. Skipping synchronization.\n",
@@ -531,9 +531,9 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
      * can skip the synchronization.
      */
 
-    REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion, nxagentCorruptedRegion(pDrawable));
+    RegionIntersect(clipRegion, clipRegion, nxagentCorruptedRegion(pDrawable));
 
-    if (REGION_NIL(clipRegion) == 1)
+    if (RegionNil(clipRegion) == 1)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentSynchronizeRegion: The corrupted region [%d,%d,%d,%d] is not viewable "
@@ -554,9 +554,9 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
     if (pRegion != NullRegion)
     {
-      REGION_INTERSECT(pDrawable -> pScreen, clipRegion, clipRegion, pRegion);
+      RegionIntersect(clipRegion, clipRegion, pRegion);
 
-      if (REGION_NIL(clipRegion) == 1)
+      if (RegionNil(clipRegion) == 1)
       {
         #ifdef TEST
         fprintf(stderr, "nxagentSynchronizeRegion: Region requested [%d,%d,%d,%d] already "
@@ -604,7 +604,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
   #ifdef TEST
   fprintf(stderr, "nxagentSynchronizeRegion: Going to synchronize [%ld] rects of [%s] at [%p].\n",
-              REGION_NUM_RECTS(clipRegion), nxagentDrawableType(pDrawable), (void *) pDrawable);
+              RegionNumRects(clipRegion), nxagentDrawableType(pDrawable), (void *) pDrawable);
 
   fprintf(stderr, "nxagentSynchronizeRegion: Extents geometry [%d,%d,%d,%d].\n",
           clipRegion -> extents.x1, clipRegion -> extents.y1, clipRegion -> extents.x2, clipRegion -> extents.y2);
@@ -647,8 +647,8 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
     if (length == 0)
     {
-      fprintf(stderr, "nxagentSynchronizeRegion: Drawable [%s] at [%p] with region geometry [%ld][%d,%d,%d,%d].\n",
-                  nxagentDrawableType(pDrawable), (void *) pDrawable, REGION_NUM_RECTS(clipRegion),
+      fprintf(stderr, "nxagentSynchronizeRegion: Drawable [%s] at [%p] with region geometry [%d][%d,%d,%d,%d].\n",
+                  nxagentDrawableType(pDrawable), (void *) pDrawable, RegionNumRects(clipRegion),
                       clipRegion -> extents.x1, clipRegion -> extents.y1,
                           clipRegion -> extents.x2, clipRegion -> extents.y2);
     }
@@ -660,7 +660,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
   #ifndef USE_OPTIMIZED_BOXES
 
-  pBox = REGION_RECTS(clipRegion);
+  pBox = RegionRects(clipRegion);
 
   #else
 
@@ -668,7 +668,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
   #endif /* USE_OPTIMIZED_BOXES */
 
-  nBox = REGION_NUM_RECTS(clipRegion);
+  nBox = RegionNumRects(clipRegion);
 
   now = GetTimeInMillis();
 
@@ -794,12 +794,12 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
          * region.
          */
 
-        REGION_INIT(pDrawable -> pScreen, &tileRegion, &tileBox, 1);
+        RegionInit(&tileRegion, &tileBox, 1);
 
-        REGION_UNION(pDrawable -> pScreen, &exposeRegion, &exposeRegion, &tileRegion);
+        RegionUnion(&exposeRegion, &exposeRegion, &tileRegion);
 
         #ifdef COLLECTED_UPDATES
-        REGION_APPEND(pDrawable -> pScreen, &collectedUpdates, &tileRegion);
+        RegionAppend(&collectedUpdates, &tileRegion);
         #endif
 
         if (useStoredBitmap != 0)
@@ -812,7 +812,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
            * associated to this pixmap.
            */
 
-          REGION_SUBTRACT(pDrawable -> pScreen, nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
+          RegionSubtract(nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
                               nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), &tileRegion); 
 
           /*
@@ -875,7 +875,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
                         (void *) nxagentDrawableBitmap(pDrawable));
             #endif
 
-            REGION_SUBTRACT(pDrawable -> pScreen, nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
+            RegionSubtract(nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)),
                                 nxagentPixmapCorruptedRegion(nxagentDrawableBitmap(pDrawable)), &tileRegion);
           }
         }
@@ -888,7 +888,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
         nxagentRealizeImage(pDrawable, pGC, pDrawable -> depth,
                                 x, y, w, h, leftPad, format, data);
 
-        REGION_UNINIT(pDrawable -> pScreen, &tileRegion);
+        RegionUninit(&tileRegion);
 
         #if !defined(COLLECTED_UPDATES)
 
@@ -990,7 +990,7 @@ nxagentSynchronizeRegionStop:
 
     if (pDrawable -> type == DRAWABLE_PIXMAP &&
             nxagentIsCorruptedBackground((PixmapPtr) pDrawable) == 1 &&
-                REGION_NIL(&exposeRegion) == 0)
+                RegionNil(&exposeRegion) == 0)
     {
       struct nxagentExposeBackground eb;
 
@@ -1016,14 +1016,14 @@ nxagentSynchronizeRegionStop:
     {
       int overlap = 0;
 
-      REGION_VALIDATE(pDrawable -> pScreen, &collectedUpdates, &overlap);
+      RegionValidate(&collectedUpdates, &overlap);
 
-      for (i = 0; i < REGION_NUM_RECTS(&collectedUpdates); i++)
+      for (i = 0; i < RegionNumRects(&collectedUpdates); i++)
       {
-        x = REGION_RECTS(&collectedUpdates)[i].x1;
-        y = REGION_RECTS(&collectedUpdates)[i].y1;
-        w = REGION_RECTS(&collectedUpdates)[i].x2 - REGION_RECTS(&collectedUpdates)[i].x1;
-        h = REGION_RECTS(&collectedUpdates)[i].y2 - REGION_RECTS(&collectedUpdates)[i].y1;
+        x = RegionRects(&collectedUpdates)[i].x1;
+        y = RegionRects(&collectedUpdates)[i].y1;
+        w = RegionRects(&collectedUpdates)[i].x2 - RegionRects(&collectedUpdates)[i].x1;
+        h = RegionRects(&collectedUpdates)[i].y2 - RegionRects(&collectedUpdates)[i].y1;
        
         if (nxagentOption(Shadow) == 1 &&
                 (nxagentOption(XRatio) != DONT_SCALE ||
@@ -1063,11 +1063,11 @@ nxagentSynchronizeRegionFree:
     xfree(data);
   }
 
-  REGION_UNINIT(pDrawable -> pScreen, &exposeRegion);
+  RegionUninit(&exposeRegion);
 
   #ifdef COLLECTED_UPDATES
 
-  REGION_UNINIT(pDrawable -> pScreen, &collectedUpdates);
+  RegionUninit(&collectedUpdates);
 
   #endif /* #ifdef COLLECTED_UPDATES */
 
@@ -1108,7 +1108,7 @@ void nxagentSynchronizeBox(DrawablePtr pDrawable, BoxPtr pBox, unsigned int brea
                                       pBox -> x2 - pBox -> x1, pBox -> y2 - pBox -> y1);
 
 
-    if (REGION_NIL(pRegion) == 1)
+    if (RegionNil(pRegion) == 1)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentSynchronizeBox: Resulting region [%d,%d,%d,%d] is nil. Skipping synchronization.\n",
@@ -1273,7 +1273,7 @@ FIXME: This condition sounds only as a
               "with [%ld] rects.\n", nxagentCorruptedRegion(pDrawable) -> extents.x1,
                   nxagentCorruptedRegion(pDrawable) -> extents.y1, nxagentCorruptedRegion(pDrawable) ->
                       extents.x2, nxagentCorruptedRegion(pDrawable) -> extents.y2,
-                          REGION_NUM_RECTS(nxagentCorruptedRegion(pDrawable)));
+                          RegionNumRects(nxagentCorruptedRegion(pDrawable)));
   #endif
 
   /*
@@ -1518,7 +1518,7 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
   box.x2 = x + width;
   box.y2 = y + height;
 
-  pRegion = REGION_CREATE(pDrawable -> pScreen, &box, 1);
+  pRegion = RegionCreate(&box, 1);
 
   /*
    * Clipping the region.
@@ -1543,11 +1543,11 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
       tmpBox.x2 = pDrawable -> width;
       tmpBox.y2 = pDrawable -> height;
 
-      REGION_INIT(pDrawable -> pScreen, &tmpRegion, &tmpBox, 1);
+      RegionInit(&tmpRegion, &tmpBox, 1);
 
-      REGION_INTERSECT(pDrawable -> pScreen, pRegion, &tmpRegion, pRegion);
+      RegionIntersect(pRegion, &tmpRegion, pRegion);
 
-      REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+      RegionUninit(&tmpRegion);
     }
   }
   else
@@ -1558,19 +1558,19 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
      * by its children.
      */
 
-    REGION_TRANSLATE(pDrawable -> pScreen, pRegion,
+    RegionTranslate(pRegion,
                          pDrawable -> x, pDrawable -> y);
 
     if (nxagentWindowPriv((WindowPtr) pDrawable) -> hasTransparentChildren == 1)
     {
-      REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &((WindowPtr) pDrawable) -> borderClip);
+      RegionIntersect(pRegion, pRegion, &((WindowPtr) pDrawable) -> borderClip);
     }
     else
     {
-      REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &((WindowPtr) pDrawable) -> clipList);
+      RegionIntersect(pRegion, pRegion, &((WindowPtr) pDrawable) -> clipList);
     }
 
-    REGION_TRANSLATE(pDrawable -> pScreen, pRegion,
+    RegionTranslate(pRegion,
                          -pDrawable -> x, -pDrawable -> y);
   }
 
@@ -1585,15 +1585,15 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
    * to intersect it with the GC's clipmask.
    */
 
-  if (REGION_NIL(pRegion) == 0 &&
+  if (RegionNil(pRegion) == 0 &&
           pGC != NULL && pGC -> clientClip != NULL &&
               pGC -> clientClipType == CT_REGION)
   {
     RegionRec clipRegion;
 
-    REGION_INIT(pDrawable -> pScreen, &clipRegion, NullBox, 1);
+    RegionInit(&clipRegion, NullBox, 1);
 
-    REGION_COPY(pDrawable -> pScreen, &clipRegion, (RegionPtr) pGC -> clientClip);
+    RegionCopy(&clipRegion, (RegionPtr) pGC -> clientClip);
 
     /*
      * The clip origin is relative to the origin of
@@ -1603,7 +1603,7 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
 
     if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
     {
-      REGION_TRANSLATE(pDrawable -> pScreen, &clipRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+      RegionTranslate(&clipRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
     }
 
     #ifdef TEST
@@ -1612,9 +1612,9 @@ RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
                     clipRegion.extents.x2, clipRegion.extents.y2);
     #endif
 
-    REGION_INTERSECT(pDrawable -> pScreen, pRegion, pRegion, &clipRegion);
+    RegionIntersect(pRegion, pRegion, &clipRegion);
 
-    REGION_UNINIT(pDrawable -> pScreen, &clipRegion);
+    RegionUninit(&clipRegion);
   }
 
   return pRegion;
@@ -1627,7 +1627,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
   int width;
   int height;
 
-  if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+  if (pRegion != NullRegion && RegionNil(pRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentMarkCorruptedRegion: Region [%d,%d,%d,%d] is nil. Skipping operation.\n",
@@ -1672,7 +1672,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 
     nxagentValidateSplit(pDrawable, pRegion);
 
-    REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+    RegionUnion(nxagentCorruptedRegion(pDrawable),
                      nxagentCorruptedRegion(pDrawable), pRegion);
 
     nxagentFreeRegion(pDrawable, pRegion);
@@ -1695,7 +1695,7 @@ void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 
     nxagentValidateSplit(pDrawable, pRegion);
 
-    REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+    RegionUnion(nxagentCorruptedRegion(pDrawable),
                      nxagentCorruptedRegion(pDrawable), pRegion);
   }
 }
@@ -1704,7 +1704,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 {
   int oldStatus;
 
-  if (pRegion != NullRegion && REGION_NIL(pRegion) == 1)
+  if (pRegion != NullRegion && RegionNil(pRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentUnmarkCorruptedRegion: Region [%d,%d,%d,%d] is nil. Skipping operation.\n",
@@ -1735,7 +1735,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 
     nxagentValidateSplit(pDrawable, NULL);
 
-    REGION_EMPTY(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable));
+    RegionEmpty(nxagentCorruptedRegion(pDrawable));
   }
   else
   {
@@ -1749,7 +1749,7 @@ void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 
     nxagentValidateSplit(pDrawable, pRegion);
 
-    REGION_SUBTRACT(pDrawable -> pScreen, nxagentCorruptedRegion(pDrawable),
+    RegionSubtract(nxagentCorruptedRegion(pDrawable),
                         nxagentCorruptedRegion(pDrawable), pRegion);
   }
 
@@ -1817,7 +1817,7 @@ void nxagentMoveCorruptedRegion(WindowPtr pWin, unsigned int mask)
                   nx, ny, (void *) pWin);
       #endif
 
-      REGION_TRANSLATE(pWin -> pScreen, nxagentCorruptedRegion((DrawablePtr) pWin),
+      RegionTranslate(nxagentCorruptedRegion((DrawablePtr) pWin),
                            nx, ny);
 
       /*
@@ -1886,9 +1886,9 @@ BoxPtr nxagentGetOptimizedRegionBoxes(RegionPtr pRegion)
   int nBoxOptim;
   #endif
 
-  pBox = REGION_RECTS(pRegion);
+  pBox = RegionRects(pRegion);
 
-  nBox = REGION_NUM_RECTS(pRegion);
+  nBox = RegionNumRects(pRegion);
 
   #ifdef TEST
   fprintf(stderr, "nxagentGetOptimizedRegionBoxes: Going to optimize region at [%p] with [%d] rects.\n",
@@ -2183,7 +2183,7 @@ unsigned long nxagentGetRegionColor(DrawablePtr pDrawable, RegionPtr pRegion)
 {
   int xPicker, yPicker;
 
-  if (REGION_NIL(pRegion) == 1)
+  if (RegionNil(pRegion) == 1)
   {
     return nxagentGetDrawableColor(pDrawable);
   }
@@ -2251,7 +2251,7 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion)
     return;
   }
 
-  if (pRegion == NullRegion || REGION_NIL(pRegion) == 1)
+  if (pRegion == NullRegion || RegionNil(pRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentClearRegion: The region is empty. Exiting.\n");
@@ -2306,7 +2306,7 @@ void nxagentClearRegion(DrawablePtr pDrawable, RegionPtr pRegion)
 
   pBox = nxagentGetOptimizedRegionBoxes(pRegion);
 
-  nBox = REGION_NUM_RECTS(pRegion);
+  nBox = RegionNumRects(pRegion);
 
   for (i = 0; i < nBox; i++)
   {
@@ -2348,14 +2348,14 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
   int        nrects;
   int        i;
 
-  if (REGION_NIL(pRegion) == 1)
+  if (RegionNil(pRegion) == 1)
   {
     return;
   }
 
   pGC = nxagentGetGraphicContext(pDrawable);
 
-  nrects = REGION_NUM_RECTS(pRegion);
+  nrects = RegionNumRects(pRegion);
 
   #ifdef TEST
   fprintf(stderr, "nxagentFillRemoteRegion: Going to fill remote region [%d,%d,%d,%d] rects [%d] with color [%lu].\n",
@@ -2372,7 +2372,7 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
   }
   else
   {
-    pBox = REGION_RECTS(pRegion);
+    pBox = RegionRects(pRegion);
 
     pRects = xalloc(nrects * sizeof(XRectangle));
 
@@ -2440,7 +2440,7 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode,
   np = nPoints;
   xp = pPoints;
 
-  pRegion = REGION_CREATE(pDrawable -> pScreen, NullBox, 1);
+  pRegion = RegionCreate(NullBox, 1);
 
   while (np--)
   {
@@ -2465,28 +2465,28 @@ void nxagentPointsToDirtyRegion(DrawablePtr pDrawable, int mode,
      * this loop could become less expensive.
      */
 
-    REGION_INIT(pDrawable -> pScreen, &tmpRegion, &box, 1);
+    RegionInit(&tmpRegion, &box, 1);
 
-    REGION_UNION(pDrawable -> pScreen, pRegion, pRegion, &tmpRegion);
+    RegionUnion(pRegion, pRegion, &tmpRegion);
 
-    REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+    RegionUninit(&tmpRegion);
 
     xp++;
   }
 
-  extents = *REGION_EXTENTS(pDrawable -> pScreen, pRegion);
+  extents = *RegionExtents(pRegion);
 
-  REGION_RESET(pDrawable -> pScreen, pRegion, &extents);
+  RegionReset(pRegion, &extents);
 
   #ifdef TEST
   fprintf(stderr, "nxagentPointsToDirtyRegion: The resulting dirty region has [%ld] rects and"
-              " extents (%d,%d,%d,%d).\n", REGION_NUM_RECTS(pRegion), extents.x1,
+              " extents (%d,%d,%d,%d).\n", RegionNumRects(pRegion), extents.x1,
                   extents.y1, extents.x2, extents.y2);
   #endif
 
   nxagentMarkCorruptedRegion(pDrawable, pRegion);
 
-  REGION_DESTROY(pDrawable -> pScreen, pRegion);
+  RegionDestroy(pRegion);
 }
 
 #ifdef DUMP
@@ -2533,20 +2533,20 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
   clipRegion = nxagentCreateRegion((DrawablePtr) pWin, NULL, 0, 0,
                                       pWin -> drawable.width, pWin -> drawable.height);
 
-  REGION_INIT(pWin -> drawable.pScreen, &visRegion, NullBox, 1);
+  RegionInit(&visRegion, NullBox, 1);
 
-  REGION_INTERSECT(pWin -> drawable.pScreen, &visRegion, clipRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
+  RegionIntersect(&visRegion, clipRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
 
   nxagentFreeRegion(pWin -> drawable.pScreen, clipRegion);
 
-  if (REGION_NIL(&visRegion) == 1)
+  if (RegionNil(&visRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentCorruptedRegionOnWindow: The corrupted region of window at [%p] is hidden.\n",
                 (void *) pWin);
     #endif
 
-    REGION_UNINIT(pWin -> drawable.pScreen, &visRegion);
+    RegionUninit(&visRegion);
 
     return;
   }
@@ -2569,7 +2569,7 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
 
   gc = XCreateGC(nxagentDisplay, nxagentWindow(pWin), GCForeground | GCSubwindowMode, &value);
 
-  nrectangles = REGION_NUM_RECTS(&visRegion);
+  nrectangles = RegionNumRects(&visRegion);
 
   #ifdef TEST
   fprintf(stderr, "nxagentCorruptedRegionOnWindow: Going to draw the region with extents [%d,%d,%d,%d] and [%d] rects.\n",
@@ -2594,7 +2594,7 @@ void nxagentCorruptedRegionOnWindow(void *p0, XID x, void *p2)
 
   XFreeGC(nxagentDisplay, gc);
 
-  REGION_UNINIT(pWin -> drawable.pScreen, &visRegion);
+  RegionUninit(&visRegion);
 }
 
 void nxagentRegionsOnScreen()
@@ -2673,9 +2673,9 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable)
 
   pClipRegion = nxagentCreateRegion(pDrawable, NULL, 0, 0, pDrawable -> width, pDrawable -> height);
 
-  REGION_INTERSECT(pDrawable -> pScreen, pClipRegion, pClipRegion, nxagentCorruptedRegion(pDrawable));
+  RegionIntersect(pClipRegion, pClipRegion, nxagentCorruptedRegion(pDrawable));
 
-  if (REGION_NIL(pClipRegion) == 1)
+  if (RegionNil(pClipRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentCreateDrawableBitmap: The corrupted region is not visible. Skipping bitmap creation.\n");
@@ -2716,7 +2716,7 @@ void nxagentCreateDrawableBitmap(DrawablePtr pDrawable)
 
   nxagentCopyArea(pDrawable, (DrawablePtr) pBitmap, pGC, x, y, w, h, x, y);
 
-  REGION_UNION(pDrawable -> pScreen, nxagentCorruptedRegion((DrawablePtr) pBitmap),
+  RegionUnion(nxagentCorruptedRegion((DrawablePtr) pBitmap),
                    nxagentCorruptedRegion((DrawablePtr) pBitmap), pClipRegion);
 
   if (pDrawable -> type == DRAWABLE_PIXMAP)
@@ -3002,19 +3002,19 @@ void nxagentUnmarkExposedRegion(WindowPtr pWin, RegionPtr pRegion, RegionPtr pOt
 {
   RegionRec clipRegion;
 
-  if (pRegion != NullRegion && REGION_NIL(pRegion) == 0 &&
+  if (pRegion != NullRegion && RegionNil(pRegion) == 0 &&
           nxagentDrawableStatus((DrawablePtr) pWin) == NotSynchronized)
   {
-    REGION_INIT(pWin -> drawable.pScreen, &clipRegion, NullBox, 1);
+    RegionInit(&clipRegion, NullBox, 1);
 
-    REGION_COPY(pWin -> drawable.pScreen, &clipRegion, pRegion);
+    RegionCopy(&clipRegion, pRegion);
     
-    if (pOther != NullRegion && REGION_NIL(pOther) == 0)
+    if (pOther != NullRegion && RegionNil(pOther) == 0)
     {
-      REGION_UNION(pWin -> drawable.pScreen, &clipRegion, &clipRegion, pOther);
+      RegionUnion(&clipRegion, &clipRegion, pOther);
     }
 
-    REGION_TRANSLATE(pWin -> drawable.pScreen, &clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
+    RegionTranslate(&clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
 
     #ifdef TEST
     fprintf(stderr, "nxagentUnmarkExposedRegion: Validating expose region [%d,%d,%d,%d] "
@@ -3024,7 +3024,7 @@ void nxagentUnmarkExposedRegion(WindowPtr pWin, RegionPtr pRegion, RegionPtr pOt
 
     nxagentUnmarkCorruptedRegion((DrawablePtr) pWin, &clipRegion);
 
-    REGION_UNINIT(pWin -> drawable.pScreen, &clipRegion);
+    RegionUninit(&clipRegion);
   }
 }
 
@@ -3061,7 +3061,7 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
   RegionRec expose;
   miBSWindowPtr pBackingStore;
 
-  REGION_INIT(pWin -> pScreen, &expose, NullBox, 1);
+  RegionInit(&expose, NullBox, 1);
 
   #ifdef DEBUG
   fprintf(stderr, "nxagentSendBackgroundExpose: Original expose region is [%d,%d,%d,%d].\n",
@@ -3084,25 +3084,25 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
                         pWin -> drawable.width, pWin -> drawable.height);
     #endif
 
-    REGION_COPY(pWin -> pScreen, &expose, &pWin -> winSize);
+    RegionCopy(&expose, &pWin -> winSize);
   }
   else
   {
-    REGION_COPY(pWin -> pScreen, &expose, pExpose);
+    RegionCopy(&expose, pExpose);
 
-    REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+    RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
   }
 
-  REGION_SUBTRACT(pWin -> pScreen, &expose, &expose, nxagentCorruptedRegion((DrawablePtr) pWin));
+  RegionSubtract(&expose, &expose, nxagentCorruptedRegion((DrawablePtr) pWin));
 
-  if (REGION_NIL(&pWin -> clipList) != 0)
+  if (RegionNil(&pWin -> clipList) != 0)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentSendBackgroundExpose: Exposures deferred because the window "
                 "is hidden.\n");
     #endif
 
-    REGION_UNION(pWin -> pScreen, nxagentDeferredBackgroundExposures,
+    RegionUnion(nxagentDeferredBackgroundExposures,
                      nxagentDeferredBackgroundExposures, &expose);
 
     nxagentWindowPriv(pWin) -> deferredBackgroundExpose = 1;
@@ -3121,32 +3121,32 @@ void nxagentSendBackgroundExpose(WindowPtr pWin, PixmapPtr pBackground, RegionPt
 
   pBackingStore = (miBSWindowPtr)pWin->backStorage;
 
-  if ((pBackingStore != NULL) && (REGION_NIL(&pBackingStore->SavedRegion) == 0))
+  if ((pBackingStore != NULL) && (RegionNil(&pBackingStore->SavedRegion) == 0))
   {
-    REGION_TRANSLATE(pWin -> pScreen, &expose, -pWin -> drawable.x, -pWin -> drawable.y);
+    RegionTranslate(&expose, -pWin -> drawable.x, -pWin -> drawable.y);
 
-    REGION_SUBTRACT(pWin -> pScreen, &expose, &expose, &pBackingStore -> SavedRegion);
+    RegionSubtract(&expose, &expose, &pBackingStore -> SavedRegion);
 
-    REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+    RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
   }
 
-  REGION_INTERSECT(pWin -> pScreen, &expose, &expose, &pWin -> clipList);
+  RegionIntersect(&expose, &expose, &pWin -> clipList);
 
   /*
    * Reduce the overall region to expose.
    */
   
-  REGION_TRANSLATE(pWin -> pScreen, &expose, -pWin -> drawable.x, -pWin -> drawable.y);
+  RegionTranslate(&expose, -pWin -> drawable.x, -pWin -> drawable.y);
   
-  REGION_SUBTRACT(pWin -> pScreen, pExpose, pExpose, &expose);
+  RegionSubtract(pExpose, pExpose, &expose);
   
-  REGION_TRANSLATE(pWin -> pScreen, &expose, pWin -> drawable.x, pWin -> drawable.y);
+  RegionTranslate(&expose, pWin -> drawable.x, pWin -> drawable.y);
 
   miWindowExposures(pWin, &expose, &expose);
 
 nxagentSendBackgroundExposeEnd:
 
-  REGION_UNINIT(pWin -> pScreen, &expose);
+  RegionUninit(&expose);
 }
 
 void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2)
@@ -3156,7 +3156,7 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2)
 
   struct nxagentExposeBackground *pPair = p2;
 
-  if (REGION_NIL(pPair -> pExpose) != 0)
+  if (RegionNil(pPair -> pExpose) != 0)
   {
     return;
   }
@@ -3217,21 +3217,21 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
 
   if (nxagentWindowPriv(pWin) -> deferredBackgroundExpose == 1)
   {
-    exposeRgn = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+    exposeRgn = RegionCreate(NULL, 1);
 
     #ifdef DEBUG
-    box = *REGION_EXTENTS(pWin->drawable.pScreen, remoteExposeRgn);
+    box = *RegionExtents(remoteExposeRgn);
 
     fprintf(stderr, "nxagentClipAndSendClearExpose: Background expose extents: [%d,%d,%d,%d].\n",
                 box.x1, box.y1, box.x2, box.y2);
 
-    box = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin -> clipList);
+    box = *RegionExtents(&pWin -> clipList);
 
     fprintf(stderr, "nxagentClipAndSendClearExpose: Clip list extents for window at [%p]: [%d,%d,%d,%d].\n",
                 (void *) pWin, box.x1, box.y1, box.x2, box.y2);
     #endif
 
-    REGION_INTERSECT(pWin -> drawable.pScreen, exposeRgn, remoteExposeRgn, &pWin -> clipList);
+    RegionIntersect(exposeRgn, remoteExposeRgn, &pWin -> clipList);
 
     /*
      * If the region will be synchronized,
@@ -3239,28 +3239,28 @@ int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
      * be ignored.
      */
 
-    REGION_SUBTRACT(pWin -> drawable.pScreen, exposeRgn, exposeRgn, nxagentCorruptedRegion((DrawablePtr) pWin));
+    RegionSubtract(exposeRgn, exposeRgn, nxagentCorruptedRegion((DrawablePtr) pWin));
 
-    if (REGION_NOTEMPTY(pWin -> drawable.pScreen, exposeRgn))
+    if (RegionNotEmpty(exposeRgn))
     {
       #ifdef DEBUG
-      box = *REGION_EXTENTS(pWin->drawable.pScreen, exposeRgn);
+      box = *RegionExtents(exposeRgn);
 
       fprintf(stderr, "nxagentClipAndSendClearExpose: Forwarding expose [%d,%d,%d,%d] to window at [%p] pWin.\n",
                   box.x1, box.y1, box.x2, box.y2, (void *) pWin);
       #endif
 
-      REGION_SUBTRACT(pWin -> drawable.pScreen, remoteExposeRgn, remoteExposeRgn, exposeRgn);
+      RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
 
       miWindowExposures(pWin, exposeRgn, exposeRgn);
     }
 
-    REGION_DESTROY(pWin -> drawable.pScreen, exposeRgn);
+    RegionDestroy(exposeRgn);
 
     nxagentWindowPriv(pWin) -> deferredBackgroundExpose = 0;
   }
 
-  if (REGION_NOTEMPTY(pWin -> drawable.pScreen, remoteExposeRgn))
+  if (RegionNotEmpty(remoteExposeRgn))
   {
     #ifdef DEBUG
     fprintf(stderr, "nxagentClipAndSendClearExpose: Region not empty. Walk children.\n");
@@ -3283,10 +3283,10 @@ void nxagentSendDeferredBackgroundExposures(void)
 {
   if (nxagentDeferredBackgroundExposures == NullRegion)
   {
-    nxagentDeferredBackgroundExposures = REGION_CREATE(WindowTable[0] -> drawable.pScreen, NullBox, 1);
+    nxagentDeferredBackgroundExposures = RegionCreate(NullBox, 1);
   }
 
-  if (REGION_NOTEMPTY(WindowTable[0] -> drawable.pScreen, nxagentDeferredBackgroundExposures) != 0)
+  if (RegionNotEmpty(nxagentDeferredBackgroundExposures) != 0)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentSendDeferredBackgroundExposures: Going to send deferred exposures to the root window.\n");
@@ -3294,7 +3294,7 @@ void nxagentSendDeferredBackgroundExposures(void)
 
     TraverseTree(WindowTable[0], nxagentClipAndSendClearExpose, (void *) nxagentDeferredBackgroundExposures);
 
-    REGION_EMPTY(WindowTable[0] -> drawable.pScreen, nxagentDeferredBackgroundExposures);
+    RegionEmpty(nxagentDeferredBackgroundExposures);
   }
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
index 4ebbc928e..d05eebf19 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
@@ -107,7 +107,7 @@ enum SynchronizationPredicate
             nxagentWindowCorruptedRegion((WindowPtr) pDrawable))
 
 #define nxagentDrawableStatus(pDrawable) \
-    (REGION_NIL(nxagentCorruptedRegion(pDrawable)) ? \
+    (RegionNil(nxagentCorruptedRegion(pDrawable)) ? \
         Synchronized : NotSynchronized)
 
 #define nxagentDrawableContainGlyphs(pDrawable) \
@@ -155,7 +155,7 @@ extern RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, in
                                   int width, int height);
 
 #define nxagentFreeRegion(pDrawable, pRegion) \
-    REGION_DESTROY((pDrawable) -> pScreen, pRegion);
+    RegionDestroy(pRegion);
 
 extern void nxagentMarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion);
 extern void nxagentUnmarkCorruptedRegion(DrawablePtr pDrawable, RegionPtr pRegion);
@@ -204,8 +204,8 @@ do \
     break; \
   } \
 \
-  numRects = REGION_NUM_RECTS(pRegion); \
-  pBox = REGION_RECTS(pRegion); \
+  numRects = RegionNumRects(pRegion); \
+  pBox = RegionRects(pRegion); \
 \
   fprintf(stderr, "printRegionBoxes:: Region " strRegion " at [%p] has [%d] boxes:\n", \
               (void *) (pRegion), numRects); \
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Events.c b/nx-X11/programs/Xserver/hw/nxagent/Events.c
index c04481c92..5ad81f781 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Events.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Events.c
@@ -1834,9 +1834,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
       {
         #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: Going to handle new Expose event.\n");
-        #endif
 
-        #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: WARNING! Received Expose event "
                     "for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n",
                         X.xexpose.window, X.xexpose.x, X.xexpose.y, X.xexpose.width,
@@ -1851,9 +1849,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
       {
         #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: Going to handle new GraphicsExpose event.\n");
-        #endif
 
-        #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: WARNING! Received GraphicsExpose event "
                     "for drawable [%lx] geometry [%d, %d, %d, %d] count [%d].\n",
                         X.xgraphicsexpose.drawable, X.xgraphicsexpose.x, X.xgraphicsexpose.y,
@@ -1869,9 +1865,7 @@ FIXME: Don't enqueue the KeyRelease event if the key was
       {
         #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: Going to handle new NoExpose event.\n");
-        #endif
 
-        #ifdef DEBUG
         fprintf(stderr, "nxagentDispatchEvents: WARNING! Received NoExpose event for "
                     "drawable [%lx].\n", X.xnoexpose.drawable);
         #endif
@@ -2401,9 +2395,7 @@ int nxagentHandleExposeEvent(XEvent *X)
 
   #ifdef DEBUG
   fprintf(stderr, "nxagentHandleExposeEvent: Checking remote expose events.\n");
-  #endif
 
-  #ifdef DEBUG
   fprintf(stderr, "nxagentHandleExposeEvent: Looking for window id [%ld].\n",
               X -> xexpose.window);
   #endif
@@ -2414,7 +2406,7 @@ int nxagentHandleExposeEvent(XEvent *X)
 
   if (pWin != NULL)
   {
-    REGION_INIT(pWin -> drawable.pScreen, &sum, (BoxRec *) NULL, 1);
+    RegionInit(&sum, (BoxRec *) NULL, 1);
 /*
 FIXME: This can be maybe optimized by consuming the
        events that do not match the predicate.
@@ -2445,11 +2437,11 @@ FIXME: This can be maybe optimized by consuming the
       box.x2 = box.x1 + X -> xexpose.width;
       box.y2 = box.y1 + X -> xexpose.height;
 
-      REGION_INIT(pWin -> drawable.pScreen, &add, &box, 1);
+      RegionInit(&add, &box, 1);
 
-      REGION_APPEND(pWin -> drawable.pScreen, &sum, &add);
+      RegionAppend(&sum, &add);
 
-      REGION_UNINIT(pWin -> drawable.pScreen, &add);
+      RegionUninit(&add);
 
       if (X -> xexpose.count == 0)
       {
@@ -2459,9 +2451,9 @@ FIXME: This can be maybe optimized by consuming the
     while (nxagentCheckEvents(nxagentDisplay, X, nxagentExposurePredicate,
                                   (XPointer) &window) == 1);
 
-    REGION_VALIDATE(pWin -> drawable.pScreen, &sum, &overlap);
+    RegionValidate(&sum, &overlap);
 
-    REGION_INTERSECT(pWin->drawable.pScreen, &sum, &sum,
+    RegionIntersect(&sum, &sum,
                          &WindowTable[pWin->drawable.pScreen->myNum]->winSize);
 
     #ifdef DEBUG
@@ -2482,14 +2474,14 @@ FIXME: This can be maybe optimized by consuming the
     }
     else
     {
-      REGION_TRANSLATE(pWin -> drawable.pScreen, &sum, -pWin -> drawable.x, -pWin -> drawable.y);
+      RegionTranslate(&sum, -pWin -> drawable.x, -pWin -> drawable.y);
 
       if (nxagentExposeQueue.exposures[index].remoteRegion == NullRegion)
       {
-        nxagentExposeQueue.exposures[index].remoteRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+        nxagentExposeQueue.exposures[index].remoteRegion = RegionCreate(NULL, 1);
       }
 
-      REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].remoteRegion,
+      RegionUnion(nxagentExposeQueue.exposures[index].remoteRegion,
                        nxagentExposeQueue.exposures[index].remoteRegion, &sum);
 
       #ifdef TEST
@@ -2521,7 +2513,7 @@ FIXME: This can be maybe optimized by consuming the
       }
     }
 
-    REGION_UNINIT(pWin -> drawable.pScreen, &sum);
+    RegionUninit(&sum);
   }
 
   return 1;
@@ -2538,7 +2530,6 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
   RegionPtr exposeRegion;
   BoxRec rect;
   WindowPtr pWin;
-  ScreenPtr pScreen;
   StoringPixmapPtr pStoringPixmapRec = NULL;
   miBSWindowPtr pBSwindow = NULL;
   int drawableType;
@@ -2581,8 +2572,6 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
     pWin = pStoringPixmapRec -> pSavedWindow;
   }
 
-  pScreen = pWin -> drawable.pScreen;
-
   /*
    * Rectangle affected by GraphicsExpose
    * event.
@@ -2593,7 +2582,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
   rect.x2 = rect.x1 + X -> xgraphicsexpose.width;
   rect.y2 = rect.y1 + X -> xgraphicsexpose.height;
 
-  exposeRegion = REGION_CREATE(pScreen, &rect, 0);
+  exposeRegion = RegionCreate(&rect, 0);
 
   if (drawableType == DRAWABLE_PIXMAP)
   {
@@ -2610,7 +2599,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
      * window.
      */
 
-    REGION_TRANSLATE(pScreen, exposeRegion, pStoringPixmapRec -> backingStoreX,
+    RegionTranslate(exposeRegion, pStoringPixmapRec -> backingStoreX,
                          pStoringPixmapRec -> backingStoreY);
 
     /*
@@ -2618,7 +2607,7 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
      * affected by the GraphicsExpose event.
      */
 
-    REGION_SUBTRACT(pScreen, &(pBSwindow -> SavedRegion), &(pBSwindow -> SavedRegion),
+    RegionSubtract(&(pBSwindow -> SavedRegion), &(pBSwindow -> SavedRegion),
                         exposeRegion);
   }
 
@@ -2628,18 +2617,17 @@ int nxagentHandleGraphicsExposeEvent(XEvent *X)
    * must be relative to the screen.
    */
 
-  REGION_TRANSLATE(pScreen, exposeRegion, pWin -> drawable.x, pWin -> drawable.y);
+  RegionTranslate(exposeRegion, pWin -> drawable.x, pWin -> drawable.y);
 
-  REGION_UNION(pScreen, nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion);
+  RegionUnion(nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, exposeRegion);
 
-  REGION_DESTROY(pScreen, exposeRegion);
+  RegionDestroy(exposeRegion);
 
   return 1;
 }
 
 int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
 {
-  ScreenPtr pScreen;
   WindowPtr pWin;
   xEvent x;
 
@@ -2691,7 +2679,9 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
 
     if (message_type == MakeAtom("WM_PROTOCOLS", strlen("WM_PROTOCOLS"), False))
     {
+      #ifdef TEST
       char *message_data;
+      #endif
 
       x.u.u.type = ClientMessage;
       x.u.u.detail = X -> xclient.format;
@@ -2710,12 +2700,12 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
 
         return 0;
       }
+      #ifdef TEST
       else
       {
         message_data = validateString(NameForAtom(x.u.clientMessage.u.l.longs0));
       }
 
-      #ifdef TEST
       fprintf(stderr, "nxagentHandleClientMessageEvent: Sent client message of type WM_PROTOCOLS "
                   "and value [%s].\n", message_data);
       #endif
@@ -2757,8 +2747,6 @@ int nxagentHandleClientMessageEvent(XEvent *X, enum HandleEventResult *result)
 
         if (X -> xclient.window == nxagentIconWindow)
         {
-          pScreen = nxagentScreen(X -> xmap.window);
-
           XMapRaised(nxagentDisplay, nxagentFullscreenWindow);
 
           XIconifyWindow(nxagentDisplay, nxagentIconWindow,
@@ -3125,28 +3113,6 @@ int nxagentCheckWindowConfiguration(XConfigureEvent* X)
   unsigned int nchildren_return = 0;
   Status result;
 
-  WindowPtr pWin;
-
-  pWin = nxagentWindowPtr(X -> window);
-
-  /*
-   * This optimization has some problems to
-   * work in rootless mode inside NXWin. To 
-   * verify this you can launch xterm and
-   * another application, f.e. firefox. By
-   * raising xterm above firefox, the stack
-   * order seems to become incoherent showing
-   * the underneath window content in the
-   * overlapping area when the mouse botton is
-   * pressed with the pointer inside of such area.
-   *
-   *  if ((pWin != NULL) && X -> override_redirect == 0)
-   *  {
-   *    return 1;
-   *  }
-   *
-   */
-
   if (win == X -> window)
   {
     if (x != X -> x ||
@@ -4091,30 +4057,30 @@ void nxagentSynchronizeExpose(void)
   {
     if ((nxagentExposeQueueHead.localRegion) != NullRegion)
     {
-      REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.localRegion),
+      RegionTranslate((nxagentExposeQueueHead.localRegion),
                            pWin -> drawable.x, pWin -> drawable.y);
     }
 
     if ((nxagentExposeQueueHead.remoteRegion) != NullRegion)
     {
-      REGION_TRANSLATE(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion),
+      RegionTranslate((nxagentExposeQueueHead.remoteRegion),
                            pWin -> drawable.x, pWin -> drawable.y);
     }
 
     if ((nxagentExposeQueueHead.localRegion) != NullRegion &&
              (nxagentExposeQueueHead.remoteRegion) != NullRegion)
     {
-      REGION_SUBTRACT(pWin -> drawable.pScreen, (nxagentExposeQueueHead.remoteRegion),
+      RegionSubtract((nxagentExposeQueueHead.remoteRegion),
                           (nxagentExposeQueueHead.remoteRegion),
                               (nxagentExposeQueueHead.localRegion));
 
-      if (REGION_NIL(nxagentExposeQueueHead.remoteRegion) == 0 &&
+      if (RegionNil(nxagentExposeQueueHead.remoteRegion) == 0 &&
              ((pWin -> eventMask|wOtherEventMasks(pWin)) & ExposureMask))
       {
         #ifdef TEST
         fprintf(stderr, "nxagentSynchronizeExpose: Going to call miWindowExposures"
                     " for window [%ld] - rects [%ld].\n", nxagentWindow(pWin),
-                        REGION_NUM_RECTS(nxagentExposeQueueHead.remoteRegion));
+                        RegionNumRects(nxagentExposeQueueHead.remoteRegion));
         #endif
 
         miWindowExposures(pWin, nxagentExposeQueueHead.remoteRegion, NullRegion);
@@ -4126,14 +4092,14 @@ void nxagentSynchronizeExpose(void)
 
   if (nxagentExposeQueueHead.localRegion != NullRegion)
   {
-    REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.localRegion);
+    RegionDestroy(nxagentExposeQueueHead.localRegion);
   }
 
   nxagentExposeQueueHead.localRegion = NullRegion;
 
   if (nxagentExposeQueueHead.remoteRegion != NullRegion)
   {
-    REGION_DESTROY(nxagentDefaultScreen, nxagentExposeQueueHead.remoteRegion);
+    RegionDestroy(nxagentExposeQueueHead.remoteRegion);
   }
 
   nxagentExposeQueueHead.remoteRegion = NullRegion;
@@ -4260,7 +4226,7 @@ void nxagentInitRemoteExposeRegion(void)
 {
   if (nxagentRemoteExposeRegion == NULL)
   {
-    nxagentRemoteExposeRegion = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+    nxagentRemoteExposeRegion = RegionCreate(NULL, 1);
 
     if (nxagentRemoteExposeRegion == NULL)
     {
@@ -4273,7 +4239,7 @@ void nxagentInitRemoteExposeRegion(void)
 
 void nxagentForwardRemoteExpose(void)
 {
-  if (REGION_NOTEMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion))
+  if (RegionNotEmpty(nxagentRemoteExposeRegion))
   {
     #ifdef DEBUG
     fprintf(stderr, "nxagentForwardRemoteExpose: Going to forward events.\n");
@@ -4285,7 +4251,7 @@ void nxagentForwardRemoteExpose(void)
      * Now this region should be empty.
      */
 
-    REGION_EMPTY(WindowTable[0] -> drawable.pScreen, nxagentRemoteExposeRegion);
+    RegionEmpty(nxagentRemoteExposeRegion);
   }
 }
 
@@ -4298,21 +4264,22 @@ void nxagentAddRectToRemoteExposeRegion(BoxPtr rect)
     return;
   }
 
-  REGION_INIT(nxagentDefaultScreen, &exposeRegion, rect, 1);
+  RegionInit(&exposeRegion, rect, 1);
 
-  REGION_UNION(nxagentDefaultScreen, nxagentRemoteExposeRegion,
+  RegionUnion(nxagentRemoteExposeRegion,
                    nxagentRemoteExposeRegion, &exposeRegion);
 
-  REGION_UNINIT(nxagentDefaultScreen, &exposeRegion);
+  RegionUninit(&exposeRegion);
 }
 
 int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
 {
   RegionPtr exposeRgn;
   RegionPtr remoteExposeRgn;
-  BoxRec box;
 
   #ifdef DEBUG
+  BoxRec box;
+
   fprintf(stderr, "nxagentClipAndSendExpose: Called.\n");
   #endif
 
@@ -4320,25 +4287,23 @@ int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
 
   if (pWin -> drawable.class != InputOnly)
   {
-    exposeRgn = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
-
-    box = *REGION_EXTENTS(pWin->drawable.pScreen, remoteExposeRgn);
+    exposeRgn = RegionCreate(NULL, 1);
 
     #ifdef DEBUG
+    box = *RegionExtents(remoteExposeRgn);
+
     fprintf(stderr, "nxagentClipAndSendExpose: Root expose extents: [%d] [%d] [%d] [%d].\n",
                 box.x1, box.y1, box.x2, box.y2);
-    #endif
 
-    box = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin -> clipList);
+    box = *RegionExtents(&pWin -> clipList);
 
-    #ifdef DEBUG
     fprintf(stderr, "nxagentClipAndSendExpose: Clip list extents for window at [%p]: [%d] [%d] [%d] [%d].\n",
                 pWin, box.x1, box.y1, box.x2, box.y2);
     #endif
 
-    REGION_INTERSECT(pWin -> drawable.pScreen, exposeRgn, remoteExposeRgn, &pWin -> clipList);
+    RegionIntersect(exposeRgn, remoteExposeRgn, &pWin -> clipList);
 
-    if (REGION_NOTEMPTY(pWin -> drawable.pScreen, exposeRgn))
+    if (RegionNotEmpty(exposeRgn))
     {
       #ifdef DEBUG
       fprintf(stderr, "nxagentClipAndSendExpose: Forwarding expose to window at [%p] pWin.\n",
@@ -4351,15 +4316,15 @@ int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
        * ration must be done before calling it.
        */
 
-      REGION_SUBTRACT(pWin -> drawable.pScreen, remoteExposeRgn, remoteExposeRgn, exposeRgn);
+      RegionSubtract(remoteExposeRgn, remoteExposeRgn, exposeRgn);
 
       miWindowExposures(pWin, exposeRgn, NullRegion);
     }
 
-    REGION_DESTROY(pWin -> drawable.pScreen, exposeRgn);
+    RegionDestroy(exposeRgn);
   }
 
-  if (REGION_NOTEMPTY(pWin -> drawable.pScreen, remoteExposeRgn))
+  if (RegionNotEmpty(remoteExposeRgn))
   {
     #ifdef DEBUG
     fprintf(stderr, "nxagentClipAndSendExpose: Region not empty. Walk children.\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Extensions.c b/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
index d77d27674..dfa511448 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Extensions.c
@@ -156,7 +156,6 @@ int nxagentRandRGetInfo(ScreenPtr pScreen, Rotation *pRotations)
 static int nxagentRandRInitSizes(ScreenPtr pScreen)
 {
   RRScreenSizePtr pSize;
-  rrScrPrivPtr pRandRScrPriv = rrGetScrPriv(pScreen);
 
   int width;
   int height;
@@ -260,7 +259,6 @@ int nxagentRandRSetConfig(ScreenPtr pScreen, Rotation rotation,
                               int rate, RRScreenSizePtr pSize)
 {
   int r;
-  rrScrPrivPtr pRandRScrPriv;
 
   UpdateCurrentTime();
 
@@ -319,7 +317,6 @@ int nxagentRandRScreenSetSize(ScreenPtr pScreen, CARD16 width, CARD16 height,
                                    CARD32 mmWidth, CARD32 mmHeight)
 {
   int result;
-  rrScrPrivPtr pRandRScrPriv;
 
   UpdateCurrentTime();
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GC.c b/nx-X11/programs/Xserver/hw/nxagent/GC.c
index 808220346..7450c1e6c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GC.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GC.c
@@ -633,11 +633,11 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
     case CT_YXSORTED:
     case CT_YXBANDED:
     {
-      RegionPtr pReg = RECTS_TO_REGION(pGC->pScreen, nRects, (xRectangle *)pValue, type);
+      RegionPtr pReg = RegionFromRects(nRects, (xRectangle *)pValue, type);
 
       clipsMatch = nxagentCompareRegions(pGC -> clientClip, pReg);
 
-      REGION_DESTROY(pGC->pScreen, pReg);
+      RegionDestroy(pReg);
 
       break;
     }
@@ -671,10 +671,10 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
     {
       if (clipsMatch == 0 && nxagentGCTrap == 0)
       {
-        nRects = REGION_NUM_RECTS((RegionPtr)pValue);
+        nRects = RegionNumRects((RegionPtr)pValue);
         size = nRects * sizeof(*pRects);
         pRects = (XRectangle *) xalloc(size);
-        pBox = REGION_RECTS((RegionPtr)pValue);
+        pBox = RegionRects((RegionPtr)pValue);
 
         for (i = nRects; i-- > 0;)
         {
@@ -768,7 +768,7 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
        * CT_REGION client clips.
        */
 
-      pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
+      pGC->clientClip = (void *) RegionFromRects(nRects,
                                                   (xRectangle *)pValue, type);
       xfree(pValue);
 
@@ -820,7 +820,7 @@ void nxagentDestroyClipHelper(GCPtr pGC)
     case CT_NONE:
       break;
     case CT_REGION:
-      REGION_DESTROY(pGC->pScreen, pGC->clientClip);
+      RegionDestroy(pGC->clientClip);
       break;
     case CT_PIXMAP:
       nxagentDestroyPixmap((PixmapPtr)pGC->clientClip);
@@ -848,8 +848,8 @@ void nxagentCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
     case CT_REGION:
       if (nxagentGCPriv(pGCSrc)->pPixmap == NULL)
       {
-        pRgn = REGION_CREATE(pGCDst->pScreen, NULL, 1);
-        REGION_COPY(pGCDst->pScreen, pRgn, pGCSrc->clientClip);
+        pRgn = RegionCreate(NULL, 1);
+        RegionCopy(pRgn, pGCSrc->clientClip);
         nxagentChangeClip(pGCDst, CT_REGION, pRgn, 0);
       }
       else
@@ -1151,12 +1151,9 @@ static void nxagentReconnectGC(void *param0, XID param1, void * param2)
 
 Bool nxagentReconnectAllGCs(void *p0)
 {
-  int flexibility;
   int cid;
   Bool GCSuccess = True;
 
-  flexibility = *(int*)p0;
-
   #ifdef DEBUG
   fprintf(stderr, "nxagentReconnectAllGCs\n");
   #endif
@@ -1281,10 +1278,10 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
     case CT_REGION:
       if (nxagentGCPriv(pGC)->pPixmap == NULL)
       {
-        nRects = REGION_NUM_RECTS((RegionPtr)pValue);
+        nRects = RegionNumRects((RegionPtr)pValue);
         size = nRects * sizeof(*pRects);
         pRects = (XRectangle *) xalloc(size);
-        pBox = REGION_RECTS((RegionPtr)pValue);
+        pBox = RegionRects((RegionPtr)pValue);
         for (i = nRects; i-- > 0;) {
           pRects[i].x = pBox[i].x1;
           pRects[i].y = pBox[i].y1;
@@ -1370,7 +1367,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
        * CT_PIXMAP and CT_REGION client clips.
        */
 
-      pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
+      pGC->clientClip = (void *) RegionFromRects(nRects,
                                                   (xRectangle *)pValue, type);
       xfree(pValue);
       pValue = pGC->clientClip;
@@ -1403,26 +1400,26 @@ static int nxagentCompareRegions(RegionPtr r1, RegionPtr r2)
     return 0;
   }
 
-  if (REGION_NUM_RECTS(r1) !=  REGION_NUM_RECTS(r2))
+  if (RegionNumRects(r1) !=  RegionNumRects(r2))
   {
     return 0;
   }
-  else if (REGION_NUM_RECTS(r1) == 0)
+  else if (RegionNumRects(r1) == 0)
   {
     return 1;
   }
-  else if ((*REGION_EXTENTS(pScreen, r1)).x1 !=  (*REGION_EXTENTS(pScreen, r2)).x1) return 0;
-  else if ((*REGION_EXTENTS(pScreen, r1)).x2 !=  (*REGION_EXTENTS(pScreen, r2)).x2) return 0;
-  else if ((*REGION_EXTENTS(pScreen, r1)).y1 !=  (*REGION_EXTENTS(pScreen, r2)).y1) return 0;
-  else if ((*REGION_EXTENTS(pScreen, r1)).y2 !=  (*REGION_EXTENTS(pScreen, r2)).y2) return 0;
+  else if ((*RegionExtents(r1)).x1 !=  (*RegionExtents(r2)).x1) return 0;
+  else if ((*RegionExtents(r1)).x2 !=  (*RegionExtents(r2)).x2) return 0;
+  else if ((*RegionExtents(r1)).y1 !=  (*RegionExtents(r2)).y1) return 0;
+  else if ((*RegionExtents(r1)).y2 !=  (*RegionExtents(r2)).y2) return 0;
   else
   {
-    for (i = 0; i < REGION_NUM_RECTS(r1); i++)
+    for (i = 0; i < RegionNumRects(r1); i++)
     {
-      if (REGION_RECTS(r1)[i].x1 !=  REGION_RECTS(r2)[i].x1) return 0;
-      else if (REGION_RECTS(r1)[i].x2 !=  REGION_RECTS(r2)[i].x2) return 0;
-      else if (REGION_RECTS(r1)[i].y1 !=  REGION_RECTS(r2)[i].y1) return 0;
-      else if (REGION_RECTS(r1)[i].y2 !=  REGION_RECTS(r2)[i].y2) return 0;
+      if (RegionRects(r1)[i].x1 !=  RegionRects(r2)[i].x1) return 0;
+      else if (RegionRects(r1)[i].x2 !=  RegionRects(r2)[i].x2) return 0;
+      else if (RegionRects(r1)[i].y1 !=  RegionRects(r2)[i].y1) return 0;
+      else if (RegionRects(r1)[i].y2 !=  RegionRects(r2)[i].y2) return 0;
     }
   }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
index 25f5fa6d7..5f753ffe4 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
@@ -306,12 +306,12 @@ FIXME: The popup could be synchronized with one
                     pSrcRegion -> extents.x2, pSrcRegion -> extents.y2);
     #endif
 
-    REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+    RegionInit(&corruptedRegion, NullBox, 1);
 
-    REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+    RegionIntersect(&corruptedRegion,
                          pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
 
-    if (REGION_NIL(&corruptedRegion) == 0)
+    if (RegionNil(&corruptedRegion) == 0)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentDeferCopyArea: Forcing the synchronization of source drawable at [%p].\n",
@@ -321,7 +321,7 @@ FIXME: The popup could be synchronized with one
       nxagentSynchronizeRegion(pSrcDrawable, &corruptedRegion, EVENT_BREAK, NULL);
     }
 
-    REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+    RegionUninit(&corruptedRegion);
 
     nxagentFreeRegion(pSrcDrawable, pSrcRegion);
 
@@ -361,7 +361,7 @@ FIXME: The popup could be synchronized with one
                     pClipRegion -> extents.x2, pClipRegion -> extents.y2);
     #endif
 
-    REGION_SUBTRACT(pSrcDrawable -> pScreen, pClipRegion, pClipRegion, nxagentCorruptedRegion(pSrcDrawable));
+    RegionSubtract(pClipRegion, pClipRegion, nxagentCorruptedRegion(pSrcDrawable));
 
     #ifdef DEBUG
     fprintf(stderr, "nxagentDeferCopyArea: Usable copy area source region is [%d,%d,%d,%d].\n",
@@ -381,11 +381,11 @@ FIXME: The popup could be synchronized with one
 
       #endif
 
-      REGION_TRANSLATE(pSrcDrawable -> pScreen, pClipRegion, dstx - srcx, dsty - srcy);
+      RegionTranslate(pClipRegion, dstx - srcx, dsty - srcy);
     }
     else
     {
-      REGION_INIT(pDstDrawable -> pScreen, &tmpRegion, NullBox, 1);
+      RegionInit(&tmpRegion, NullBox, 1);
 
       #ifdef DEBUG
       fprintf(stderr, "nxagentDeferCopyArea: Going to modify the original GC [%p] with clip mask "
@@ -396,18 +396,18 @@ FIXME: The popup could be synchronized with one
                       pGC -> clipOrg.x, pGC -> clipOrg.y);
       #endif
 
-      REGION_COPY(pDstDrawable -> pScreen, &tmpRegion, (RegionPtr) pGC -> clientClip);
+      RegionCopy(&tmpRegion, (RegionPtr) pGC -> clientClip);
 
       if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
       {
-        REGION_TRANSLATE(pDstDrawable -> pScreen, &tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+        RegionTranslate(&tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
       }
 
-      REGION_TRANSLATE(pSrcDrawable -> pScreen, pClipRegion, dstx - srcx, dsty - srcy);
+      RegionTranslate(pClipRegion, dstx - srcx, dsty - srcy);
 
-      REGION_INTERSECT(pSrcDrawable -> pScreen, pClipRegion, &tmpRegion, pClipRegion);
+      RegionIntersect(pClipRegion, &tmpRegion, pClipRegion);
 
-      REGION_UNINIT(pSrcDrawable -> pScreen, &tmpRegion);
+      RegionUninit(&tmpRegion);
     }
 
     /*
@@ -416,18 +416,18 @@ FIXME: The popup could be synchronized with one
      * destination that we are not going to copy.
      */
 
-    REGION_SUBTRACT(pSrcDrawable -> pScreen, pCorruptedRegion, pCorruptedRegion, pClipRegion);
+    RegionSubtract(pCorruptedRegion, pCorruptedRegion, pClipRegion);
 
     #ifdef DEBUG
     fprintf(stderr, "nxagentDeferCopyArea: Recomputed clip region is [%d,%d,%d,%d][%ld].\n",
                 pClipRegion -> extents.x1, pClipRegion -> extents.y1,
                     pClipRegion -> extents.x2, pClipRegion -> extents.y2,
-                        REGION_NUM_RECTS(pClipRegion));
+                        RegionNumRects(pClipRegion));
 
     fprintf(stderr, "nxagentDeferCopyArea: Inherited corrupted region is [%d,%d,%d,%d][%ld].\n",
                 pCorruptedRegion -> extents.x1, pCorruptedRegion -> extents.y1,
                     pCorruptedRegion -> extents.x2, pCorruptedRegion -> extents.y2,
-                        REGION_NUM_RECTS(pCorruptedRegion));
+                        RegionNumRects(pCorruptedRegion));
     #endif
 
     /*
@@ -435,17 +435,17 @@ FIXME: The popup could be synchronized with one
      * synchronized and the corrupted region.
      */
 
-    if (REGION_NIL(pClipRegion) == 0)
+    if (RegionNil(pClipRegion) == 0)
     {
       nxagentUnmarkCorruptedRegion(pDstDrawable, pClipRegion);
     }
 
-    if (REGION_NIL(pCorruptedRegion) == 0)
+    if (RegionNil(pCorruptedRegion) == 0)
     {
       nxagentMarkCorruptedRegion(pDstDrawable, pCorruptedRegion);
     }
 
-    if (REGION_NIL(pClipRegion) == 0)
+    if (RegionNil(pClipRegion) == 0)
     {
       GCPtr  targetGC;
 
@@ -468,7 +468,7 @@ FIXME: The popup could be synchronized with one
                  GCClipXOrigin | GCClipYOrigin | GCClipMask | GCForeground |
                      GCBackground | GCGraphicsExposures);
 
-      if (REGION_NUM_RECTS(pClipRegion) == 1)
+      if (RegionNumRects(pClipRegion) == 1)
       {
         /*
          * If the region to copy is formed by one
@@ -563,12 +563,12 @@ FIXME: The popup could be synchronized with one
                     pSrcRegion -> extents.x2, pSrcRegion -> extents.y2);
     #endif
 
-    REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+    RegionInit(&corruptedRegion, NullBox, 1);
 
-    REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+    RegionIntersect(&corruptedRegion,
                          pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
 
-    if (REGION_NIL(&corruptedRegion) == 0)
+    if (RegionNil(&corruptedRegion) == 0)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentDeferCopyArea: Forcing the synchronization of source drawable at [%p].\n",
@@ -578,7 +578,7 @@ FIXME: The popup could be synchronized with one
       nxagentSynchronizeRegion(pSrcDrawable, &corruptedRegion /*pSrcRegion*/, NEVER_BREAK, NULL);
     }
 
-    REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+    RegionUninit(&corruptedRegion);
 
     nxagentFreeRegion(pSrcDrawable, pSrcRegion);
   }
@@ -594,8 +594,6 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
   unsigned int format;
   unsigned long planeMask = 0xffffffff;
 
-  int oldDstxyValue;
-
   RegionPtr pDstRegion;
 
   int skip = 0;
@@ -651,8 +649,6 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
     }
   }
 
-    oldDstxyValue = dsty;
-
   if (dsty + pDstDrawable->y + height > 32767)
   {
     #ifdef WARNING
@@ -1032,12 +1028,12 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
     {
       pSrcRegion = nxagentCreateRegion(pSrcDrawable, NULL, srcx, srcy, width, height);
 
-      REGION_INIT(pSrcDrawable -> pScreen, &corruptedRegion, NullBox, 1);
+      RegionInit(&corruptedRegion, NullBox, 1);
 
-      REGION_INTERSECT(pSrcDrawable -> pScreen, &corruptedRegion,
+      RegionIntersect(&corruptedRegion,
                            pSrcRegion, nxagentCorruptedRegion(pSrcDrawable));
 
-      if (REGION_NIL(&corruptedRegion) == 0)
+      if (RegionNil(&corruptedRegion) == 0)
       {
         #ifdef TEST
         fprintf(stderr, "nxagentCopyPlane: Forcing the synchronization of source drawable at [%p].\n",
@@ -1053,7 +1049,7 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
         nxagentFreeRegion(pDstDrawable, pDstRegion);
       }
 
-      REGION_UNINIT(pSrcDrawable -> pScreen, &corruptedRegion);
+      RegionUninit(&corruptedRegion);
 
       nxagentFreeRegion(pSrcDrawable, pSrcRegion);
     }
@@ -1615,24 +1611,24 @@ void nxagentPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
 
   if (inheritCorruptedRegion == 1 || nxagentDrawableStatus(pDrawable) == NotSynchronized)
   {
-    rectRegion = RECTS_TO_REGION(pDrawable -> pScreen, nRectangles, pRectangles, CT_REGION);
+    rectRegion = RegionFromRects(nRectangles, pRectangles, CT_REGION);
 
     if (pGC -> clientClip != NULL)
     {
       RegionRec tmpRegion;
 
-      REGION_INIT(pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+      RegionInit(&tmpRegion, NullBox, 1);
 
-      REGION_COPY(pDrawable -> pScreen, &tmpRegion, ((RegionPtr) pGC -> clientClip));
+      RegionCopy(&tmpRegion, ((RegionPtr) pGC -> clientClip));
 
       if (pGC -> clipOrg.x != 0 || pGC -> clipOrg.y != 0)
       {
-        REGION_TRANSLATE(pDrawable -> pScreen, &tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
+        RegionTranslate(&tmpRegion, pGC -> clipOrg.x, pGC -> clipOrg.y);
       }
 
-      REGION_INTERSECT(pDrawable -> pScreen, rectRegion, rectRegion, &tmpRegion);
+      RegionIntersect(rectRegion, rectRegion, &tmpRegion);
 
-      REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+      RegionUninit(&tmpRegion);
     }
 
     if (inheritCorruptedRegion == 1)
@@ -1672,7 +1668,7 @@ void nxagentPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
       }
     }
 
-    REGION_DESTROY(pDrawable -> pScreen, rectRegion);
+    RegionDestroy(rectRegion);
   }
 
   if ((pDrawable)->type == DRAWABLE_PIXMAP)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
index 0396a458e..aee983253 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
@@ -729,7 +729,6 @@ void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mas
 
   int changed;
   int suspended = 0;
-  int result;
   int width_, height_;
 
   #ifdef BLOCKS
@@ -796,7 +795,7 @@ void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mas
   nxagentShadowPoll(nxagentShadowPixmapPtr, nxagentShadowGCPtr, nxagentShadowDepth, nxagentShadowWidth,
                         nxagentShadowHeight, nxagentShadowBuffer, &changed, &suspended);
 
-  result = nxagentShadowSendUpdates(&suspended);
+  nxagentShadowSendUpdates(&suspended);
 
   if (nxagentBlocking == 0)
   {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Holder.c b/nx-X11/programs/Xserver/hw/nxagent/Holder.c
index 64ffb24a4..db43acafc 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Holder.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Holder.c
@@ -23,6 +23,7 @@
 #include "scrnintstr.h"
 #include "Agent.h"
 #define GC XlibGC
+#define Pixmap XlibPixmap
 #define PIXEL_ALREADY_TYPEDEFED
 
 #endif /* _XSERVER64 */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Image.c b/nx-X11/programs/Xserver/hw/nxagent/Image.c
index 1f0b735b0..c84d3b7ed 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Image.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Image.c
@@ -566,7 +566,7 @@ void nxagentPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
 
   pRegion = nxagentCreateRegion(pDrawable, pGC, dstX, dstY, dstWidth, dstHeight);
 
-  if (REGION_NIL(pRegion) == 1)
+  if (RegionNil(pRegion) == 1)
   {
     #ifdef TEST
     fprintf(stderr, "nxagentPutImage: WARNING! Prevented operation on fully clipped "
@@ -1036,7 +1036,7 @@ void nxagentRealizeImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
       clipRegion = nxagentCreateRegion(pDrawable, pGC, x, y, w, h);
     }
 
-    if (clipRegion == NullRegion || REGION_NIL(clipRegion) == 0)
+    if (clipRegion == NullRegion || RegionNil(clipRegion) == 0)
     {
       nxagentPutSubImage(pDrawable, pGC, depth, x, y, w, h,
                              leftPad, format, data, pVisual);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Imakefile b/nx-X11/programs/Xserver/hw/nxagent/Imakefile
index 160d01e60..b0aff4b07 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Imakefile
+++ b/nx-X11/programs/Xserver/hw/nxagent/Imakefile
@@ -141,7 +141,8 @@ INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../
 	   -I../../GL/glx -I../../GL/include -I../../../../lib/GL/include -I../../Xext \
            -I$(EXTINCSRC) -I$(XINCLUDESRC) \
 	   $(VFBINCLUDES) \
-           `pkg-config --cflags-only-I libxml-2.0`
+           `pkg-config --cflags-only-I libxml-2.0` \
+           `pkg-config --cflags-only-I pixman-1`
 #ifdef SunArchitecture
 INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../../nxcompshad \
            -I../../../../extras/Mesa/include \
@@ -153,6 +154,7 @@ INCLUDES = -I. -I../../../../../nxcomp -I../../../../../nxcompext -I../../../../
            -I$(EXTINCSRC) -I$(XINCLUDESRC) \
 	   $(VFBINCLUDES) \
            `pkg-config --cflags-only-I libxml-2.0`
+           `pkg-config --cflags-only-I pixman-1`
 #else
 #ifdef cygwinArchitecture
 INCLUDES = -I. -I$(XBUILDINCDIR) \
@@ -164,6 +166,7 @@ INCLUDES = -I. -I$(XBUILDINCDIR) \
            -I$(EXTINCSRC) -I$(XINCLUDESRC) \
 	   $(VFBINCLUDES) \
            `pkg-config --cflags-only-I libxml-2.0`
+           `pkg-config --cflags-only-I pixman-1`
 #endif
 #endif
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index 9ead48de1..8d1fbd4c1 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -685,7 +685,9 @@ int nxagentKeyboardProc(DeviceIntPtr pDev, int onoff)
   int free_model = 0, free_layout = 0;
   XkbDescPtr xkb = NULL;
 
+  #ifdef TEST
   int ret;
+  #endif
 
   switch (onoff)
   {
@@ -842,7 +844,10 @@ XkbError:
       memmove((char *) defaultKeyboardControl.autoRepeats,
              (char *) values.auto_repeats, sizeof(values.auto_repeats));
 
-      ret = InitKeyboardDeviceStruct((DevicePtr) pDev, &keySyms, modmap,
+      #ifdef TEST
+      ret =
+      #endif
+      InitKeyboardDeviceStruct((DevicePtr) pDev, &keySyms, modmap,
                                nxagentBell, nxagentChangeKeyboardControl);
 
       #ifdef TEST
@@ -1208,11 +1213,9 @@ void nxagentNotifyKeyboardChanges(int oldMinKeycode, int oldMaxKeycode)
   if (!noXkbExtension)
   {
     DeviceIntPtr dev;
-    XkbDescPtr xkb;
     xkbNewKeyboardNotify nkn;
 
     dev = inputInfo.keyboard;
-    xkb = dev -> key -> xkbInfo -> desc;
 
     memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
     nkn.deviceID = nkn.oldDeviceID = dev -> id;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c b/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
index 404ed035d..212fcd93c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keystroke.c
@@ -168,7 +168,7 @@ static int read_binding_from_xmlnode(xmlNode *node, struct nxagentSpecialKeystro
     /* ignore attributes without data (which should never happen anyways) */
     if (attr->children->content == NULL)
     {
-      char *aname = (attr->name)?(attr->name):"unknown";
+      char *aname = (attr->name)?((char *)attr->name):"unknown";
       fprintf(stderr, "attribute %s with NULL value", aname);
       continue;
     }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
index d18840dad..278e0727c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
@@ -154,7 +154,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 #endif
 
     /* short circuit for empty regions */
-    if (!REGION_NOTEMPTY(pScreen, pRegion))
+    if (!RegionNotEmpty(pRegion))
 	return;
     
 #ifdef COMPOSITE
@@ -169,7 +169,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y;
     }
     if (screen_x || screen_y)
-        REGION_TRANSLATE (pScreen, pRegion, screen_x, screen_y);
+        RegionTranslate(pRegion, screen_x, screen_y);
 #endif
 	
     if (pDrawable->type == DRAWABLE_WINDOW &&
@@ -177,22 +177,22 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
     {
 	if (subWindowMode == ClipByChildren)
 	{
-	    REGION_INTERSECT(pScreen, pRegion, pRegion,
+	    RegionIntersect(pRegion, pRegion,
 			     &((WindowPtr)(pDrawable))->clipList);
 	}
 	else if (subWindowMode == IncludeInferiors)
 	{
 	    RegionPtr pTempRegion =
 		NotClippedByChildren((WindowPtr)(pDrawable));
-	    REGION_INTERSECT(pScreen, pRegion, pRegion, pTempRegion);
-	    REGION_DESTROY(pScreen, pTempRegion);
+	    RegionIntersect(pRegion, pRegion, pTempRegion);
+	    RegionDestroy(pTempRegion);
 	}
 	/* If subWindowMode is set to an invalid value, don't perform
 	 * any drawable-based clipping. */
     }
         
 
-    REGION_NULL (pScreen, &clippedRec);
+    RegionNull(&clippedRec);
     for (; pDamage; pDamage = pNext)
     {
 	pNext = pDamage->pNext;
@@ -240,7 +240,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	{
 	    pDamageRegion = &clippedRec;
 	    if (pDamage->pDrawable->type == DRAWABLE_WINDOW) {
-		REGION_INTERSECT (pScreen, pDamageRegion, pRegion,
+		RegionIntersect(pDamageRegion, pRegion,
 		    &((WindowPtr)(pDamage->pDrawable))->borderClip);
 	    } else {
 		BoxRec	box;
@@ -248,14 +248,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 		box.y1 = draw_y;
 		box.x2 = draw_x + pDamage->pDrawable->width;
 		box.y2 = draw_y + pDamage->pDrawable->height;
-		REGION_INIT(pScreen, &pixClip, &box, 1);
-		REGION_INTERSECT (pScreen, pDamageRegion, pRegion, &pixClip);
-		REGION_UNINIT(pScreen, &pixClip);
+		RegionInit(&pixClip, &box, 1);
+		RegionIntersect(pDamageRegion, pRegion, &pixClip);
+		RegionUninit(&pixClip);
 	    }
 	    /*
 	     * Short circuit empty results
 	     */
-	    if (!REGION_NOTEMPTY(pScreen, pDamageRegion))
+	    if (!RegionNotEmpty(pDamageRegion))
 		continue;
 	}
 	
@@ -270,39 +270,39 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	 * Move region to target coordinate space
 	 */
 	if (draw_x || draw_y)
-	    REGION_TRANSLATE (pScreen, pDamageRegion, -draw_x, -draw_y);
+	    RegionTranslate(pDamageRegion, -draw_x, -draw_y);
 	
 	switch (pDamage->damageLevel) {
 	case DamageReportRawRegion:
 	    (*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure);
 	    break;
 	case DamageReportDeltaRegion:
-	    REGION_NULL (pScreen, &tmpRegion);
-	    REGION_SUBTRACT (pScreen, &tmpRegion, pDamageRegion, &pDamage->damage);
-	    if (REGION_NOTEMPTY (pScreen, &tmpRegion))
+	    RegionNull(&tmpRegion);
+	    RegionSubtract(&tmpRegion, pDamageRegion, &pDamage->damage);
+	    if (RegionNotEmpty(&tmpRegion))
 	    {
-		REGION_UNION(pScreen, &pDamage->damage,
+		RegionUnion(&pDamage->damage,
 			     &pDamage->damage, pDamageRegion);
 		(*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure);
 	    }
-	    REGION_UNINIT(pScreen, &tmpRegion);
+	    RegionUninit(&tmpRegion);
 	    break;
 	case DamageReportBoundingBox:
-	    tmpBox = *REGION_EXTENTS (pScreen, &pDamage->damage);
-	    REGION_UNION(pScreen, &pDamage->damage,
+	    tmpBox = *RegionExtents(&pDamage->damage);
+	    RegionUnion(&pDamage->damage,
 			 &pDamage->damage, pDamageRegion);
-	    if (!BOX_SAME (&tmpBox, REGION_EXTENTS (pScreen, &pDamage->damage)))
+	    if (!BOX_SAME (&tmpBox, RegionExtents(&pDamage->damage)))
 		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
 	    break;
 	case DamageReportNonEmpty:
-	    was_empty = !REGION_NOTEMPTY(pScreen, &pDamage->damage);
-	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+	    was_empty = !RegionNotEmpty(&pDamage->damage);
+	    RegionUnion(&pDamage->damage, &pDamage->damage,
 			 pDamageRegion);
-	    if (was_empty && REGION_NOTEMPTY(pScreen, &pDamage->damage))
+	    if (was_empty && RegionNotEmpty(&pDamage->damage))
 		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
 	    break;
 	case DamageReportNone:
-	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+	    RegionUnion(&pDamage->damage, &pDamage->damage,
 			 pDamageRegion);
 	    break;
 	}
@@ -310,14 +310,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	 * translate original region back
 	 */
 	if (pDamageRegion == pRegion && (draw_x || draw_y))
-	    REGION_TRANSLATE (pScreen, pDamageRegion, draw_x, draw_y);
+	    RegionTranslate(pDamageRegion, draw_x, draw_y);
     }
 #ifdef COMPOSITE
     if (screen_x || screen_y)
-	REGION_TRANSLATE (pScreen, pRegion, -screen_x, -screen_y);
+	RegionTranslate(pRegion, -screen_x, -screen_y);
 #endif
     
-    REGION_UNINIT (pScreen, &clippedRec);
+    RegionUninit(&clippedRec);
 }
 
 #if DAMAGE_DEBUG_ENABLE
@@ -331,13 +331,13 @@ damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode)
 {
     RegionRec	region;
 
-    REGION_INIT (pDrawable->pScreen, &region, pBox, 1);
+    RegionInit(&region, pBox, 1);
 #if DAMAGE_DEBUG_ENABLE
     _damageDamageRegion (pDrawable, &region, TRUE, subWindowMode, where);
 #else
     damageDamageRegion (pDrawable, &region, TRUE, subWindowMode);
 #endif
-    REGION_UNINIT (pDrawable->pScreen, &region);
+    RegionUninit(&region);
 }
 
 static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
@@ -506,7 +506,7 @@ damageDestroyClip(GCPtr pGC)
 
 #define checkGCDamage(d,g)	(getDrawableDamage(d) && \
 				 (!g->pCompositeClip ||\
-				  REGION_NOTEMPTY(d->pScreen, \
+				  RegionNotEmpty(\
 						  g->pCompositeClip)))
 
 #ifdef RENDER
@@ -520,7 +520,7 @@ damageDestroyClip(GCPtr pGC)
     }
     
 #define checkPictureDamage(p)	(getDrawableDamage(p->pDrawable) && \
-				 REGION_NOTEMPTY(pScreen, p->pCompositeClip))
+				 RegionNotEmpty(p->pCompositeClip))
 
 static void
 damageComposite (CARD8      op,
@@ -1722,9 +1722,9 @@ damageCopyWindow(WindowPtr	pWindow,
 	 * The region comes in source relative, but the damage occurs
 	 * at the destination location.  Translate back and forth.
 	 */
-	REGION_TRANSLATE (pScreen, prgnSrc, dx, dy);
+	RegionTranslate(prgnSrc, dx, dy);
 	damageDamageRegion (&pWindow->drawable, prgnSrc, FALSE, -1);
-	REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
+	RegionTranslate(prgnSrc, -dx, -dy);
     }
     unwrap (pScrPriv, pScreen, CopyWindow);
     (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
@@ -1927,7 +1927,7 @@ DamageCreate (DamageReportFunc  damageReport,
 	return 0;
     pDamage->pNext = 0;
     pDamage->pNextWin = 0;
-    REGION_NULL(pScreen, &pDamage->damage);
+    RegionNull(&pDamage->damage);
     
     pDamage->damageLevel = damageLevel;
     pDamage->isInternal = isInternal;
@@ -2016,7 +2016,7 @@ DamageDestroy (DamagePtr    pDamage)
 {
     if (pDamage->damageDestroy)
 	(*pDamage->damageDestroy) (pDamage, pDamage->closure);
-    REGION_UNINIT (pDamage->pDrawable->pScreen, &pDamage->damage);
+    RegionUninit(&pDamage->damage);
     xfree (pDamage);
 }
 
@@ -2028,7 +2028,7 @@ DamageSubtract (DamagePtr	    pDamage,
     RegionRec	pixmapClip;
     DrawablePtr	pDrawable = pDamage->pDrawable;
     
-    REGION_SUBTRACT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pRegion);
+    RegionSubtract(&pDamage->damage, &pDamage->damage, pRegion);
     if (pDrawable)
     {
 	if (pDrawable->type == DRAWABLE_WINDOW)
@@ -2041,22 +2041,22 @@ DamageSubtract (DamagePtr	    pDamage,
 	    box.y1 = pDrawable->y;
 	    box.x2 = pDrawable->x + pDrawable->width;
 	    box.y2 = pDrawable->y + pDrawable->height;
-	    REGION_INIT (pDrawable->pScreen, &pixmapClip, &box, 1);
+	    RegionInit(&pixmapClip, &box, 1);
 	    pClip = &pixmapClip;
 	}
-	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, pDrawable->x, pDrawable->y);
-	REGION_INTERSECT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pClip);
-	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, -pDrawable->x, -pDrawable->y);
+	RegionTranslate(&pDamage->damage, pDrawable->x, pDrawable->y);
+	RegionIntersect(&pDamage->damage, &pDamage->damage, pClip);
+	RegionTranslate(&pDamage->damage, -pDrawable->x, -pDrawable->y);
 	if (pDrawable->type != DRAWABLE_WINDOW)
-	    REGION_UNINIT(pDrawable->pScreen, &pixmapClip);
+	    RegionUninit(&pixmapClip);
     }
-    return REGION_NOTEMPTY (pDrawable->pScreen, &pDamage->damage);
+    return RegionNotEmpty(&pDamage->damage);
 }
 
 void
 DamageEmpty (DamagePtr	    pDamage)
 {
-    REGION_EMPTY (pDamage->pDrawable->pScreen, &pDamage->damage);
+    RegionEmpty(&pDamage->damage);
 }
 
 RegionPtr
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index 704bfcc0d..6a1f2ac6a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -1669,11 +1669,11 @@ ProcTranslateCoords(register ClientPtr client)
 		 * borderSize
 		 */
 		&& (!wBoundingShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen, 
+		    RegionContainsPoint(
 					&pWin->borderSize, x, y, &box))
 		
 		&& (!wInputShape(pWin) ||
-		    POINT_IN_REGION(pWin->drawable.pScreen,
+		    RegionContainsPoint(
 				    wInputShape(pWin),
 				    x - pWin->drawable.x,
 				    y - pWin->drawable.y, &box))
@@ -2291,7 +2291,7 @@ ProcCopyArea(register ClientPtr client)
 	(*pDst->pScreen->SendGraphicsExpose)
  		(client, pRgn, stuff->dstDrawable, X_CopyArea, 0);
 	if (pRgn)
-	    REGION_DESTROY(pDst->pScreen, pRgn);
+	    RegionDestroy(pRgn);
     }
 
     return(client->noClientException);
@@ -2339,7 +2339,7 @@ ProcCopyPlane(register ClientPtr client)
 	(*pdstDraw->pScreen->SendGraphicsExpose)
  		(client, pRgn, stuff->dstDrawable, X_CopyPlane, 0);
 	if (pRgn)
-	    REGION_DESTROY(pdstDraw->pScreen, pRgn);
+	    RegionDestroy(pRgn);
     }
     return(client->noClientException);
 }
@@ -2777,7 +2777,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	pVisibleRegion = NotClippedByChildren((WindowPtr)pDraw);
 	if (pVisibleRegion)
 	{
-	    REGION_TRANSLATE(pDraw->pScreen, pVisibleRegion, -pDraw->x, -pDraw->y);
+	    RegionTranslate(pVisibleRegion, -pDraw->x, -pDraw->y);
 	}
     }
 #endif
@@ -2871,7 +2871,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
     }
 #ifdef XCSECURITY
     if (pVisibleRegion)
-	REGION_DESTROY(pDraw->pScreen, pVisibleRegion);
+	RegionDestroy(pVisibleRegion);
 #endif
     if (!im_return)
 	DEALLOCATE_LOCAL(pBuf);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index 2f3a75147..33b0ea93d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -73,7 +73,6 @@ Equipment Corporation.
 #include <dix-config.h>
 #endif
 
-#include <X11/fonts/fontstruct.h>
 #include <nx-X11/X.h>
 #include <nx-X11/Xmd.h>
 #include <nx-X11/Xproto.h>
@@ -177,6 +176,8 @@ _NXGetFontPathError:
 
 #define QUERYCHARINFO(pci, pr)  *(pr) = (pci)->metrics
 
+extern void register_fpe_functions(void);
+
 extern void * fosNaturalParams;
 extern FontPtr defaultFont;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
index 11ff62947..f871cad13 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
@@ -379,14 +379,14 @@ XineramaSetCursorPosition(
     x += panoramiXdataPtr[0].x;
     y += panoramiXdataPtr[0].y;
 
-    if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+    if(!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
 								x, y, &box)) 
     {
 	FOR_NSCREENS(i) 
 	{
 	    if(i == pScreen->myNum) 
 		continue;
-	    if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i], x, y, &box))
+	    if(RegionContainsPoint(&XineramaScreenRegions[i], x, y, &box))
 	    {
 		pScreen = screenInfo.screens[i];
 		break;
@@ -516,7 +516,7 @@ XineramaCheckVirtualMotion(
 
 	i = PanoramiXNumScreens - 1;
 	
-	REGION_COPY(sprite.screen, &sprite.Reg2, 
+	RegionCopy(&sprite.Reg2,
 					&sprite.windows[i]->borderSize); 
 	off_x = panoramiXdataPtr[i].x;
 	off_y = panoramiXdataPtr[i].y;
@@ -526,16 +526,16 @@ XineramaCheckVirtualMotion(
 	    y = off_y - panoramiXdataPtr[i].y;
 
 	    if(x || y)
-		REGION_TRANSLATE(sprite.screen, &sprite.Reg2, x, y);
+		RegionTranslate(&sprite.Reg2, x, y);
 		
-	    REGION_UNION(sprite.screen, &sprite.Reg2, &sprite.Reg2, 
+	    RegionUnion(&sprite.Reg2, &sprite.Reg2,
 					&sprite.windows[i]->borderSize);
 
 	    off_x = panoramiXdataPtr[i].x;
 	    off_y = panoramiXdataPtr[i].y;
 	}
 
-	lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2);
+	lims = *RegionExtents(&sprite.Reg2);
 
         if (sprite.hot.x < lims.x1)
 #ifdef XEVIE
@@ -558,7 +558,7 @@ XineramaCheckVirtualMotion(
 #endif
             sprite.hot.y = lims.y2 - 1;
 
-	if (REGION_NUM_RECTS(&sprite.Reg2) > 1) 
+	if (RegionNumRects(&sprite.Reg2) > 1) 
 	    ConfineToShape(&sprite.Reg2, &sprite.hot.x, &sprite.hot.y);
 
 	if (qe)
@@ -665,7 +665,7 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
 
 	i = PanoramiXNumScreens - 1;
 	
-	REGION_COPY(sprite.screen, &sprite.Reg1, 
+	RegionCopy(&sprite.Reg1,
 					&sprite.windows[i]->borderSize); 
 	off_x = panoramiXdataPtr[i].x;
 	off_y = panoramiXdataPtr[i].y;
@@ -675,18 +675,18 @@ XineramaConfineCursorToWindow(WindowPtr pWin, Bool generateEvents)
 	    y = off_y - panoramiXdataPtr[i].y;
 
 	    if(x || y)
-		REGION_TRANSLATE(sprite.screen, &sprite.Reg1, x, y);
+		RegionTranslate(&sprite.Reg1, x, y);
 		
-	    REGION_UNION(sprite.screen, &sprite.Reg1, &sprite.Reg1, 
+	    RegionUnion(&sprite.Reg1, &sprite.Reg1,
 					&sprite.windows[i]->borderSize);
 
 	    off_x = panoramiXdataPtr[i].x;
 	    off_y = panoramiXdataPtr[i].y;
 	}
 
-	sprite.hotLimits = *REGION_EXTENTS(sprite.screen, &sprite.Reg1);
+	sprite.hotLimits = *RegionExtents(&sprite.Reg1);
 
-	if(REGION_NUM_RECTS(&sprite.Reg1) > 1)
+	if(RegionNumRects(&sprite.Reg1) > 1)
 	   sprite.hotShape = &sprite.Reg1;
 	else
 	   sprite.hotShape = NullRegion;
@@ -765,9 +765,9 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
     int x = *px, y = *py;
     int incx = 1, incy = 1;
 
-    if (POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box))
+    if (RegionContainsPoint(shape, x, y, &box))
 	return;
-    box = *REGION_EXTENTS(sprite.hot.pScreen, shape);
+    box = *RegionExtents(shape);
     /* this is rather crude */
     do {
 	x += incx;
@@ -789,7 +789,7 @@ ConfineToShape(RegionPtr shape, int *px, int *py)
 	    else if (y < box.y1)
 		return; /* should never get here! */
 	}
-    } while (!POINT_IN_REGION(sprite.hot.pScreen, shape, x, y, &box));
+    } while (!RegionContainsPoint(shape, x, y, &box));
     *px = x;
     *py = y;
 }
@@ -877,7 +877,7 @@ CheckVirtualMotion(
 #endif
 	    sprite.hot.x = sprite.hot.y = 0;
 	}
-	lims = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin->borderSize);
+	lims = *RegionExtents(&pWin->borderSize);
 	if (sprite.hot.x < lims.x1)
 #ifdef XEVIE
 	    xeviehot.x =
@@ -931,7 +931,7 @@ ConfineCursorToWindow(WindowPtr pWin, Bool generateEvents, Bool confineToScreen)
     }
     else
     {
-	sprite.hotLimits = *REGION_EXTENTS( pScreen, &pWin->borderSize);
+	sprite.hotLimits = *RegionExtents(&pWin->borderSize);
 #ifdef SHAPE
 	sprite.hotShape = wBoundingShape(pWin) ? &pWin->borderSize
 					       : NullRegion;
@@ -2117,7 +2117,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
 {
     BoxRec box;
 
-    if(POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderSize, x, y, &box))
+    if(RegionContainsPoint(&pWin->borderSize, x, y, &box))
 	return TRUE;
 
 #ifdef PANORAMIX
@@ -2125,7 +2125,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
 	int i;
 
 	for(i = 1; i < PanoramiXNumScreens; i++) {
-	   if(POINT_IN_REGION(sprite.screen, 
+	   if(RegionContainsPoint(
 			&sprite.windows[i]->borderSize, 
 			x + panoramiXdataPtr[0].x - panoramiXdataPtr[i].x, 
 			y + panoramiXdataPtr[0].y - panoramiXdataPtr[i].y, 
@@ -2180,7 +2180,7 @@ XYToWindow(int x, int y)
 	     */
 	    && (!wBoundingShape(pWin) || PointInBorderSize(pWin, x, y))
 	    && (!wInputShape(pWin) ||
-		POINT_IN_REGION(pWin->drawable.pScreen,
+		RegionContainsPoint(
 				wInputShape(pWin),
 				x - pWin->drawable.x,
 				y - pWin->drawable.y, &box))
@@ -2313,7 +2313,6 @@ WindowsRestructured()
  * compute correctly. */
 void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
 {
-    ScreenPtr pScreen = win->drawable.pScreen;
     GrabPtr   grab;
 
     if (noPanoramiXExtension) return;
@@ -2329,10 +2328,10 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
     sprite.hotLimits.x2 -= xoff;
     sprite.hotLimits.y2 -= yoff;
 
-    if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg1))
-        REGION_TRANSLATE(sprite.screen, &sprite.Reg1,    xoff, yoff);
-    if (REGION_NOTEMPTY(sprite.screen, &sprite.Reg2))
-        REGION_TRANSLATE(sprite.screen, &sprite.Reg2,    xoff, yoff);
+    if (RegionNotEmpty(&sprite.Reg1))
+        RegionTranslate(&sprite.Reg1,    xoff, yoff);
+    if (RegionNotEmpty(&sprite.Reg2))
+        RegionTranslate(&sprite.Reg2,    xoff, yoff);
 
     /* FIXME: if we call ConfineCursorToWindow, must we do anything else? */
     if ((grab = inputInfo.pointer->grab) && grab->confineTo) {
@@ -2388,8 +2387,8 @@ DefineInitialRootWindow(register WindowPtr win)
 #endif
 	sprite.screen = pScreen;
 	/* gotta UNINIT these someplace */
-	REGION_NULL(pScreen, &sprite.Reg1);
-	REGION_NULL(pScreen, &sprite.Reg2);
+	RegionNull(&sprite.Reg1);
+	RegionNull(&sprite.Reg2);
     }
 #endif
 
@@ -2461,13 +2460,12 @@ XineramaPointInWindowIsVisible(
     int y
 )
 {
-    ScreenPtr pScreen = pWin->drawable.pScreen;
     BoxRec box;
     int i, xoff, yoff;
 
     if (!pWin->realized) return FALSE;
 
-    if (POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box))
+    if (RegionContainsPoint(&pWin->borderClip, x, y, &box))
         return TRUE;
     
     if(!XineramaSetWindowPntrs(pWin)) return FALSE;
@@ -2477,13 +2475,12 @@ XineramaPointInWindowIsVisible(
 
     for(i = 1; i < PanoramiXNumScreens; i++) {
 	pWin = sprite.windows[i];
-	pScreen = pWin->drawable.pScreen;
 	x = xoff - panoramiXdataPtr[i].x;
 	y = yoff - panoramiXdataPtr[i].y;
 
-	if(POINT_IN_REGION(pScreen, &pWin->borderClip, x, y, &box)
+	if(RegionContainsPoint(&pWin->borderClip, x, y, &box)
 	   && (!wInputShape(pWin) ||
-	       POINT_IN_REGION(pWin->drawable.pScreen,
+	       RegionContainsPoint(
 			       wInputShape(pWin),
 			       x - pWin->drawable.x, 
 			       y - pWin->drawable.y, &box)))
@@ -2659,7 +2656,7 @@ ProcWarpPointer(ClientPtr client)
 static Bool 
 BorderSizeNotEmpty(WindowPtr pWin)
 {
-     if(REGION_NOTEMPTY(sprite.hotPhys.pScreen, &pWin->borderSize))
+     if(RegionNotEmpty(&pWin->borderSize))
 	return TRUE;
 
 #ifdef PANORAMIX
@@ -2667,7 +2664,7 @@ BorderSizeNotEmpty(WindowPtr pWin)
 	int i;
 
 	for(i = 1; i < PanoramiXNumScreens; i++) {
-	    if(REGION_NOTEMPTY(sprite.screen, &sprite.windows[i]->borderSize))
+	    if(RegionNotEmpty(&sprite.windows[i]->borderSize))
 		return TRUE;
 	}
      }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
index 47db919ef..757ffff21 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
@@ -76,11 +76,7 @@
 
 #endif
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
 
 /*
  * From Knuth -- a good choice for hash/rehash values is p, p-2 where
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
index 7a1d813b3..1696ae51f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
@@ -106,7 +106,6 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
     PixmapPtr ppix;
     long nby;
     char *pbits;
-    ChangeGCVal gcval[3];
     unsigned char char2b[2];
 
     /* turn glyph index into a protocol-format char2b */
@@ -165,7 +164,6 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
     fbPolyFillRect((DrawablePtr)ppix, pGC, 1, &rect);
 
     /* draw the glyph */
-    gcval[0].val = 1;
     pGC->fgPixel = 1;
 
     pGC->stateChanges |= GCForeground;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
index aa3c606f8..ad75b43f8 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
@@ -222,21 +222,21 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	if (pGC->subWindowMode == IncludeInferiors)
  	{
 	    prgnSrcClip = NotClippedByChildren (pSrcWin);
-	    if ((RECT_IN_REGION(pscr, prgnSrcClip, &TsrcBox)) == rgnIN)
+	    if ((RegionContainsRect(prgnSrcClip, &TsrcBox)) == rgnIN)
 	    {
-		REGION_DESTROY(pscr, prgnSrcClip);
+		RegionDestroy(prgnSrcClip);
 		return NULL;
 	    }
 	}
  	else
  	{
-	    if ((RECT_IN_REGION(pscr, &pSrcWin->clipList, &TsrcBox)) == rgnIN)
+	    if ((RegionContainsRect(&pSrcWin->clipList, &TsrcBox)) == rgnIN)
 		return NULL;
 	    prgnSrcClip = &rgnSrcRec;
-	    REGION_NULL(pscr, prgnSrcClip);
-	    REGION_COPY(pscr, prgnSrcClip, &pSrcWin->clipList);
+	    RegionNull(prgnSrcClip);
+	    RegionCopy(prgnSrcClip, &pSrcWin->clipList);
 	}
-	REGION_TRANSLATE(pscr, prgnSrcClip,
+	RegionTranslate(prgnSrcClip,
 				-pSrcDrawable->x, -pSrcDrawable->y);
     }
     else
@@ -253,7 +253,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	box.x2 = pSrcDrawable->width;
 	box.y2 = pSrcDrawable->height;
 	prgnSrcClip = &rgnSrcRec;
-	REGION_INIT(pscr, prgnSrcClip, &box, 1);
+	RegionInit(prgnSrcClip, &box, 1);
 	pSrcWin = (WindowPtr)NULL;
     }
 
@@ -270,11 +270,11 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	else
 	{
 	    prgnDstClip = &rgnDstRec;
-	    REGION_NULL(pscr, prgnDstClip);
-	    REGION_COPY(pscr, prgnDstClip,
+	    RegionNull(prgnDstClip);
+	    RegionCopy(prgnDstClip,
 				&((WindowPtr)pDstDrawable)->clipList);
 	}
-	REGION_TRANSLATE(pscr, prgnDstClip,
+	RegionTranslate(prgnDstClip,
 				 -pDstDrawable->x, -pDstDrawable->y);
     }
     else
@@ -286,14 +286,14 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	box.x2 = pDstDrawable->width;
 	box.y2 = pDstDrawable->height;
 	prgnDstClip = &rgnDstRec;
-	REGION_INIT(pscr, prgnDstClip, &box, 1);
+	RegionInit(prgnDstClip, &box, 1);
     }
 
     /* drawable-relative source region */
-    REGION_INIT(pscr, &rgnExposed, &srcBox, 1);
+    RegionInit(&rgnExposed, &srcBox, 1);
 
     /* now get the hidden parts of the source box*/
-    REGION_SUBTRACT(pscr, &rgnExposed, &rgnExposed, prgnSrcClip);
+    RegionSubtract(&rgnExposed, &rgnExposed, prgnSrcClip);
 
     if (pSrcWin && pSrcWin->backStorage)
     {
@@ -311,10 +311,10 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
     }
     
     /* move them over the destination */
-    REGION_TRANSLATE(pscr, &rgnExposed, dstx-srcx, dsty-srcy);
+    RegionTranslate(&rgnExposed, dstx-srcx, dsty-srcy);
 
     /* intersect with visible areas of dest */
-    REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, prgnDstClip);
+    RegionIntersect(&rgnExposed, &rgnExposed, prgnDstClip);
 
     /*
      * If we have LOTS of rectangles, we decide to take the extents
@@ -324,7 +324,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
      * for windows.
      */
     extents = pGC->graphicsExposures &&
-	      (REGION_NUM_RECTS(&rgnExposed) > RECTLIMIT) &&
+	      (RegionNumRects(&rgnExposed) > RECTLIMIT) &&
 	      (pDstDrawable->type != DRAWABLE_PIXMAP);
 #ifdef SHAPE
     if (pSrcWin)
@@ -337,7 +337,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
      	 * exposed region will undo all our work!
      	 */
     	if (extents && pSrcWin && region &&
-    	    (RECT_IN_REGION(pscr, region, &srcBox) != rgnIN))
+	    (RegionContainsRect(region, &srcBox) != rgnIN))
 	    	extents = FALSE;
     }
 #endif
@@ -345,8 +345,8 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
     {
 	WindowPtr pWin = (WindowPtr)pDstDrawable;
 
-	expBox = *REGION_EXTENTS(pscr, &rgnExposed);
-	REGION_RESET(pscr, &rgnExposed, &expBox);
+	expBox = *RegionExtents(&rgnExposed);
+	RegionReset(&rgnExposed, &expBox);
 	/* need to clear out new areas of backing store */
 	if (pWin->backStorage)
 	    (void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -363,53 +363,53 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	WindowPtr pWin = (WindowPtr)pDstDrawable;
 
 	/* make the exposed area screen-relative */
-	REGION_TRANSLATE(pscr, &rgnExposed, 
+	RegionTranslate(&rgnExposed,
 				 pDstDrawable->x, pDstDrawable->y);
 
 	if (extents)
 	{
 	    /* PaintWindowBackground doesn't clip, so we have to */
-	    REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, &pWin->clipList);
+	    RegionIntersect(&rgnExposed, &rgnExposed, &pWin->clipList);
 	}
 	(*pWin->drawable.pScreen->PaintWindowBackground)(
 			(WindowPtr)pDstDrawable, &rgnExposed, PW_BACKGROUND);
 
 	if (extents)
 	{
-	    REGION_RESET(pscr, &rgnExposed, &expBox);
+	    RegionReset(&rgnExposed, &expBox);
 	}
 	else
-	    REGION_TRANSLATE(pscr, &rgnExposed,
+	    RegionTranslate(&rgnExposed,
 				     -pDstDrawable->x, -pDstDrawable->y);
     }
     if (prgnDstClip == &rgnDstRec)
     {
-	REGION_UNINIT(pscr, prgnDstClip);
+	RegionUninit(prgnDstClip);
     }
     else if (prgnDstClip != prgnSrcClip)
     {
-	REGION_DESTROY(pscr, prgnDstClip);
+	RegionDestroy(prgnDstClip);
     }
 
     if (prgnSrcClip == &rgnSrcRec)
     {
-	REGION_UNINIT(pscr, prgnSrcClip);
+	RegionUninit(prgnSrcClip);
     }
     else
     {
-	REGION_DESTROY(pscr, prgnSrcClip);
+	RegionDestroy(prgnSrcClip);
     }
 
     if (pGC->graphicsExposures)
     {
 	/* don't look */
-	RegionPtr exposed = REGION_CREATE(pscr, NullBox, 0);
+	RegionPtr exposed = RegionCreate(NullBox, 0);
 	*exposed = rgnExposed;
 	return exposed;
     }
     else
     {
-	REGION_UNINIT(pscr, &rgnExposed);
+	RegionUninit(&rgnExposed);
 	return NULL;
     }
 }
@@ -424,7 +424,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
     int	major;
     int	minor;
 {
-    if (pRgn && !REGION_NIL(pRgn))
+    if (pRgn && !RegionNil(pRgn))
     {
         xEvent *pEvent;
 	register xEvent *pe;
@@ -432,8 +432,8 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
 	register int i;
 	int numRects;
 
-	numRects = REGION_NUM_RECTS(pRgn);
-	pBox = REGION_RECTS(pRgn);
+	numRects = RegionNumRects(pRgn);
+	pBox = RegionRects(pRgn);
 	if(!(pEvent = (xEvent *)ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 		return;
 	pe = pEvent;
@@ -479,8 +479,8 @@ miSendExposures(pWin, pRgn, dx, dy)
     register xEvent *pEvent, *pe;
     register int i;
 
-    pBox = REGION_RECTS(pRgn);
-    numRects = REGION_NUM_RECTS(pRgn);
+    pBox = RegionRects(pRgn);
+    numRects = RegionNumRects(pRgn);
     if(!(pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 	return;
     memset(pEvent, 0, numRects * sizeof(xEvent));
@@ -554,8 +554,8 @@ miWindowExposures(pWin, prgn, other_exposed)
 	 * no areas will be repainted.
 	 */
 	exposures = (*pWin->drawable.pScreen->RestoreAreas)(pWin, prgn);
-    if ((prgn && !REGION_NIL(prgn)) || 
-	(exposures && !REGION_NIL(exposures)) || other_exposed)
+    if ((prgn && !RegionNil(prgn)) || 
+	(exposures && !RegionNil(exposures)) || other_exposed)
     {
 	RegionRec   expRec;
 	int	    clientInterested;
@@ -568,11 +568,11 @@ miWindowExposures(pWin, prgn, other_exposed)
 	{
 	    if (exposures)
 	    {
-		REGION_UNION(pWin->drawable.pScreen, other_exposed,
+		RegionUnion(other_exposed,
 						  exposures,
 					          other_exposed);
 		if (exposures != prgn)
-		    REGION_DESTROY(pWin->drawable.pScreen, exposures);
+		    RegionDestroy(exposures);
 	    }
 	    exposures = other_exposed;
 	}
@@ -583,12 +583,12 @@ miWindowExposures(pWin, prgn, other_exposed)
          * than 4, let the function decide.
          */
 
-        total = REGION_NUM_RECTS(exposures);
+        total = RegionNumRects(exposures);
 
         if (clientInterested && exposures && (total > RECTLIMIT ||
                 (total > 4 && nxagentExtentsPredicate(total) == 1)))
 #else
-	if (clientInterested && exposures && (REGION_NUM_RECTS(exposures) > RECTLIMIT))
+	if (clientInterested && exposures && (RegionNumRects(exposures) > RECTLIMIT))
 #endif
 	{
 	    /*
@@ -599,17 +599,17 @@ miWindowExposures(pWin, prgn, other_exposed)
 	     */
 	    BoxRec box;
 
-	    box = *REGION_EXTENTS( pWin->drawable.pScreen, exposures);
+	    box = *RegionExtents(exposures);
 	    if (exposures == prgn) {
 		exposures = &expRec;
-		REGION_INIT( pWin->drawable.pScreen, exposures, &box, 1);
-		REGION_RESET( pWin->drawable.pScreen, prgn, &box);
+		RegionInit(exposures, &box, 1);
+		RegionReset(prgn, &box);
 	    } else {
-		REGION_RESET( pWin->drawable.pScreen, exposures, &box);
-		REGION_UNION( pWin->drawable.pScreen, prgn, prgn, exposures);
+		RegionReset(exposures, &box);
+		RegionUnion(prgn, prgn, exposures);
 	    }
 	    /* PaintWindowBackground doesn't clip, so we have to */
-	    REGION_INTERSECT( pWin->drawable.pScreen, prgn, prgn, &pWin->clipList);
+	    RegionIntersect(prgn, prgn, &pWin->clipList);
 	    /* need to clear out new areas of backing store, too */
 	    if (pWin->backStorage)
 		(void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -620,22 +620,22 @@ miWindowExposures(pWin, prgn, other_exposed)
 					     box.y2 - box.y1,
 					     FALSE);
 	}
-	if (prgn && !REGION_NIL(prgn))
+	if (prgn && !RegionNil(prgn))
 	    (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, prgn, PW_BACKGROUND);
-	if (clientInterested && exposures && !REGION_NIL(exposures))
+	if (clientInterested && exposures && !RegionNil(exposures))
 	    miSendExposures(pWin, exposures,
 			    pWin->drawable.x, pWin->drawable.y);
 	if (exposures == &expRec)
 	{
-	    REGION_UNINIT( pWin->drawable.pScreen, exposures);
+	    RegionUninit(exposures);
 	}
 	else if (exposures && exposures != prgn && exposures != other_exposed)
-	    REGION_DESTROY( pWin->drawable.pScreen, exposures);
+	    RegionDestroy(exposures);
 	if (prgn)
-	    REGION_EMPTY( pWin->drawable.pScreen, prgn);
+	    RegionEmpty(prgn);
     }
     else if (exposures && exposures != prgn)
-	REGION_DESTROY( pWin->drawable.pScreen, exposures);
+	RegionDestroy(exposures);
 }
 
 
@@ -708,7 +708,7 @@ int what;
 #define COUNT_BITS	8
 
     ChangeGCVal gcval[7];
-    ChangeGCVal newValues [COUNT_BITS];
+    ChangeGCVal newValues [COUNT_BITS] = {{ 0 }};
 
     BITS32 gcmask, index, mask;
     RegionRec prgnWin;
@@ -779,7 +779,7 @@ int what;
 	}
     }
 
-    prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
+    prect = (xRectangle *)ALLOCATE_LOCAL(RegionNumRects(prgn) *
 					 sizeof(xRectangle));
     if (!prect)
 	return;
@@ -822,7 +822,7 @@ int what;
 	    box.y1 = 0;
 	    box.x2 = pScreen->width;
 	    box.y2 = pScreen->height;
-	    REGION_INIT(pScreen, &pWin->clipList, &box, 1);
+	    RegionInit(&pWin->clipList, &box, 1);
 	    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    newValues[ABSX].val = pBgWin->drawable.x;
 	    newValues[ABSY].val = pBgWin->drawable.y;
@@ -925,8 +925,8 @@ int what;
     if (pWin->drawable.serialNumber != pGC->serialNumber)
 	ValidateGC((DrawablePtr)pWin, pGC);
 
-    numRects = REGION_NUM_RECTS(prgn);
-    pbox = REGION_RECTS(prgn);
+    numRects = RegionNumRects(prgn);
+    pbox = RegionRects(prgn);
     for (i= numRects; --i >= 0; pbox++, prect++)
     {
 	prect->x = pbox->x1 - pWin->drawable.x;
@@ -945,7 +945,7 @@ int what;
     {
 	if (what == PW_BORDER)
 	{
-	    REGION_UNINIT(pScreen, &pWin->clipList);
+	    RegionUninit(&pWin->clipList);
 	    pWin->clipList = prgnWin;
 	    pWin->drawable.x = oldCorner.x;
 	    pWin->drawable.y = oldCorner.y;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
index a720cafbf..56237605e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
@@ -131,7 +131,7 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
     box.y2 = y2;
 
     pScreen = pWin->drawable.pScreen;
-    REGION_INIT(pScreen, &reg, &box, 1);
+    RegionInit(&reg, &box, 1);
     if (pWin->backStorage)
     {
 	/*
@@ -145,14 +145,14 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
 						 generateExposures);
     }
 
-    REGION_INTERSECT(pScreen, &reg, &reg, &pWin->clipList);
+    RegionIntersect(&reg, &reg, &pWin->clipList);
     if (generateExposures)
 	(*pScreen->WindowExposures)(pWin, &reg, pBSReg);
     else if (pWin->backgroundState != None)
         (*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
-    REGION_UNINIT(pScreen, &reg);
+    RegionUninit(&reg);
     if (pBSReg)
-	REGION_DESTROY(pScreen, pBSReg);
+	RegionDestroy(pBSReg);
 }
 
 /*
@@ -198,7 +198,7 @@ miCheckSubSaveUnder(
 
 	for (; pChild != pFirst; pChild = pChild->nextSib)
 	    if (pChild->viewable && pChild->saveUnder)
-		REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+		RegionUnion(pRegion, pRegion, &pChild->borderSize);
 	
 	/*
 	 * check region below and including first changed window
@@ -217,10 +217,10 @@ miCheckSubSaveUnder(
 		{
 		    if (!subInited)
 		    {
-			REGION_NULL(pScreen, &SubRegion);
+			RegionNull(&SubRegion);
 			subInited = TRUE;
 		    }
-		    REGION_COPY(pScreen, &SubRegion, pRegion);
+		    RegionCopy(&SubRegion, pRegion);
 		    res |= miCheckSubSaveUnder(pChild, pChild->firstChild,
 					     &SubRegion);
 		}
@@ -231,12 +231,12 @@ miCheckSubSaveUnder(
 		}
 
 		if (pChild->saveUnder)
-		    REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+		    RegionUnion(pRegion, pRegion, &pChild->borderSize);
 	    }
 	}
 
 	if (subInited)
-	    REGION_UNINIT(pScreen, &SubRegion);
+	    RegionUninit(&SubRegion);
     }
 
     /*
@@ -247,8 +247,8 @@ miCheckSubSaveUnder(
 
     if (pParent->viewable && 
 	((pParent->eventMask | wOtherEventMasks(pParent)) & ExposureMask) &&
-	REGION_NOTEMPTY(pScreen, &pParent->borderSize) &&
-	RECT_IN_REGION(pScreen, pRegion, REGION_EXTENTS(pScreen, 
+	RegionNotEmpty(&pParent->borderSize) &&
+	RegionContainsRect(pRegion, RegionExtents(
 					&pParent->borderSize)) != rgnOUT)
     {
 	if (!pParent->DIXsaveUnder)
@@ -292,19 +292,17 @@ miChangeSaveUnder(pWin, first)
 					 * Used when pWin was restacked */
 {
     RegionRec	rgn;	/* Area obscured by saveUnder windows */
-    register ScreenPtr pScreen;
     Bool	res;
 
     if (!deltaSaveUndersViewable && !numSaveUndersViewable)
 	return FALSE;
     numSaveUndersViewable += deltaSaveUndersViewable;
     deltaSaveUndersViewable = 0;
-    pScreen = pWin->drawable.pScreen;
-    REGION_NULL(pScreen, &rgn);
+    RegionNull(&rgn);
     res = miCheckSubSaveUnder (pWin->parent,
 			       pWin->saveUnder ? first : pWin->nextSib,
 			       &rgn);
-    REGION_UNINIT(pScreen, &rgn);
+    RegionUninit(&rgn);
     return res;
 }
 
@@ -385,9 +383,6 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
     register WindowPtr pChild, pLast;
     Bool anyMarked = FALSE;
     MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow;
-    ScreenPtr pScreen;
-
-    pScreen = pWin->drawable.pScreen;
 
     /* single layered systems are easy */
     if (ppLayerWin) *ppLayerWin = pWin;
@@ -403,9 +398,9 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
 	{
 	    if (pChild->viewable)
 	    {
-		if (REGION_BROKEN (pScreen, &pChild->winSize))
+		if (RegionBroken(&pChild->winSize))
 		    SetWinSize (pChild);
-		if (REGION_BROKEN (pScreen, &pChild->borderSize))
+		if (RegionBroken(&pChild->borderSize))
 		    SetBorderSize (pChild);
 		(* MarkWindow)(pChild);
 		if (pChild->firstChild)
@@ -425,17 +420,17 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
     }
     if ( (pChild = pFirst) )
     {
-	box = REGION_EXTENTS(pChild->drawable.pScreen, &pWin->borderSize);
+	box = RegionExtents(&pWin->borderSize);
 	pLast = pChild->parent->lastChild;
 	while (1)
 	{
 	    if (pChild->viewable)
 	    {
-		if (REGION_BROKEN (pScreen, &pChild->winSize))
+		if (RegionBroken(&pChild->winSize))
 		    SetWinSize (pChild);
-		if (REGION_BROKEN (pScreen, &pChild->borderSize))
+		if (RegionBroken(&pChild->borderSize))
 		    SetBorderSize (pChild);
-		if (RECT_IN_REGION(pScreen, &pChild->borderSize, box))
+		if (RegionContainsRect(&pChild->borderSize, box))
 		{
 		    (* MarkWindow)(pChild);
 		    anyMarked = TRUE;
@@ -470,24 +465,21 @@ miHandleValidateExposures(pWin)
 {
     register WindowPtr pChild;
     register ValidatePtr val;
-    ScreenPtr pScreen;
     WindowExposuresProcPtr WindowExposures;
 
-    pScreen = pWin->drawable.pScreen;
-
     pChild = pWin;
     WindowExposures = pChild->drawable.pScreen->WindowExposures;
     while (1)
     {
 	if ( (val = pChild->valdata) )
 	{
-	    if (REGION_NOTEMPTY(pScreen, &val->after.borderExposed))
+	    if (RegionNotEmpty(&val->after.borderExposed))
 		(*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
 						    &val->after.borderExposed,
 						    PW_BORDER);
-	    REGION_UNINIT(pScreen, &val->after.borderExposed);
+	    RegionUninit(&val->after.borderExposed);
 	    (*WindowExposures)(pChild, &val->after.exposed, NullRegion);
-	    REGION_UNINIT(pScreen, &val->after.exposed);
+	    RegionUninit(&val->after.exposed);
 	    xfree(val);
 	    pChild->valdata = (ValidatePtr)NULL;
 	    if (pChild->firstChild)
@@ -534,8 +526,8 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
     oldpt.y = pWin->drawable.y;
     if (WasViewable)
     {
-	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
-	REGION_COPY(pScreen, oldRegion, &pWin->borderClip);
+	oldRegion = RegionCreate(NullBox, 1);
+	RegionCopy(oldRegion, &pWin->borderClip);
 	anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin, &pLayerWin);
     }
     pWin->origin.x = x + (int)bw;
@@ -572,7 +564,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
 	{
 	    (*pScreen->ValidateTree)(pLayerWin->parent, NullWindow, kind);
 	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, oldRegion);
-	    REGION_DESTROY(pScreen, oldRegion);
+	    RegionDestroy(oldRegion);
 	    /* XXX need to retile border if ParentRelative origin */
 	    (*pScreen->HandleExposures)(pLayerWin->parent);
 	}
@@ -598,23 +590,21 @@ miRecomputeExposures (
     register WindowPtr	pWin,
     void *		value) /* must conform to VisitWindowProcPtr */
 {
-    register ScreenPtr	pScreen;
     RegionPtr	pValid = (RegionPtr)value;
 
     if (pWin->valdata)
     {
-	pScreen = pWin->drawable.pScreen;
 	/*
 	 * compute exposed regions of this window
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+	RegionSubtract(&pWin->valdata->after.exposed,
 			&pWin->clipList, pValid);
 	/*
 	 * compute exposed regions of the border
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->borderClip, &pWin->winSize);
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->valdata->after.borderExposed, pValid);
 	return WT_WALKCHILDREN;
     }
@@ -671,8 +661,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	/*
 	 * save the visible region of the window
 	 */
-	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
-	REGION_COPY(pScreen, oldRegion, &pWin->winSize);
+	oldRegion = RegionCreate(NullBox, 1);
+	RegionCopy(oldRegion, &pWin->winSize);
 
 	/*
 	 * categorize child windows into regions to be moved
@@ -685,8 +675,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    if (g != UnmapGravity)
 	    {
 		if (!gravitate[g])
-		    gravitate[g] = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_UNION(pScreen, gravitate[g],
+		    gravitate[g] = RegionCreate(NullBox, 1);
+		RegionUnion(gravitate[g],
 				   gravitate[g], &pChild->borderClip);
 	    }
 	    else
@@ -701,8 +691,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	oldWinClip = NULL;
 	if (pWin->bitGravity != ForgetGravity)
 	{
-	    oldWinClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, oldWinClip, &pWin->clipList);
+	    oldWinClip = RegionCreate(NullBox, 1);
+	    RegionCopy(oldWinClip, &pWin->clipList);
 	}
 	/*
 	 * if the window is changing size, borderExposed
@@ -717,16 +707,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	if ((pWin->drawable.height != h || pWin->drawable.width != w) &&
 	    HasBorder (pWin))
 	{
-	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+	    borderVisible = RegionCreate(NullBox, 1);
 	    /* for tiled borders, we punt and draw the whole thing */
 	    if (pWin->borderIsPixel || !moved)
 	    {
 		if (shrunk || moved)
-		    REGION_SUBTRACT(pScreen, borderVisible,
+		    RegionSubtract(borderVisible,
 					  &pWin->borderClip,
 					  &pWin->winSize);
 		else
-		    REGION_COPY(pScreen, borderVisible,
+		    RegionCopy(borderVisible,
 					    &pWin->borderClip);
 	    }
 	}
@@ -753,9 +743,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
     if (WasViewable)
     {
-	pRegion = REGION_CREATE(pScreen, NullBox, 1);
+	pRegion = RegionCreate(NullBox, 1);
 	if (pWin->backStorage)
-	    REGION_COPY(pScreen, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, &pWin->clipList);
 
 	if (pLayerWin == pWin)
 	    anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange,
@@ -783,7 +773,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	 * the entire window is trashed unless bitGravity
 	 * recovers portions of it
 	 */
-	REGION_COPY(pScreen, &pWin->valdata->after.exposed, &pWin->clipList);
+	RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList);
     }
 
     GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny);
@@ -827,16 +817,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		dy = (oldy - ny) - offy;
 		if (dx || dy)
 		{
-		    REGION_TRANSLATE(pScreen, &pWin->winSize, dx, dy);
+		    RegionTranslate(&pWin->winSize, dx, dy);
 		    offx += dx;
 		    offy += dy;
 		}
-		REGION_INTERSECT(pScreen, gravitate[g], gravitate[g],
+		RegionIntersect(gravitate[g], gravitate[g],
 				 &pWin->winSize);
 	    }
 	    /* get winSize back where it belongs */
 	    if (offx || offy)
-		REGION_TRANSLATE(pScreen, &pWin->winSize, -offx, -offy);
+		RegionTranslate(&pWin->winSize, -offx, -offy);
 	}
 	/*
 	 * add screen bits to the appropriate bucket
@@ -847,9 +837,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    /*
 	     * clip to new clipList
 	     */
-	    REGION_COPY(pScreen, pRegion, oldWinClip);
-	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
-	    REGION_INTERSECT(pScreen, oldWinClip, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, oldWinClip);
+	    RegionTranslate(pRegion, nx - oldx, ny - oldy);
+	    RegionIntersect(oldWinClip, pRegion, &pWin->clipList);
 	    /*
 	     * don't step on any gravity bits which will be copied after this
 	     * region.	Note -- this assumes that the regions will be copied
@@ -858,17 +848,17 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++)
 	    {
 		if (gravitate[g])
-		    REGION_SUBTRACT(pScreen, oldWinClip, oldWinClip,
+		    RegionSubtract(oldWinClip, oldWinClip,
 					gravitate[g]);
 	    }
-	    REGION_TRANSLATE(pScreen, oldWinClip, oldx - nx, oldy - ny);
+	    RegionTranslate(oldWinClip, oldx - nx, oldy - ny);
 	    g = pWin->bitGravity;
 	    if (!gravitate[g])
 		gravitate[g] = oldWinClip;
 	    else
 	    {
-		REGION_UNION(pScreen, gravitate[g], gravitate[g], oldWinClip);
-		REGION_DESTROY(pScreen, oldWinClip);
+		RegionUnion(gravitate[g], gravitate[g], oldWinClip);
+		RegionDestroy(oldWinClip);
 	    }
 	}
 
@@ -892,14 +882,14 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
 	    /* only copy the remaining useful bits */
 
-	    REGION_INTERSECT(pScreen, gravitate[g], gravitate[g], oldRegion);
+	    RegionIntersect(gravitate[g], gravitate[g], oldRegion);
 
 	    /* clip to not overwrite already copied areas */
 
 	    if (destClip) {
-		REGION_TRANSLATE(pScreen, destClip, oldpt.x - x, oldpt.y - y);
-		REGION_SUBTRACT(pScreen, gravitate[g], gravitate[g], destClip);
-		REGION_TRANSLATE(pScreen, destClip, x - oldpt.x, y - oldpt.y);
+		RegionTranslate(destClip, oldpt.x - x, oldpt.y - y);
+		RegionSubtract(gravitate[g], gravitate[g], destClip);
+		RegionTranslate(destClip, x - oldpt.x, y - oldpt.y);
 	    }
 
 	    /* and move those bits */
@@ -915,7 +905,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
 	    /* remove any overwritten bits from the remaining useful bits */
 
-	    REGION_SUBTRACT(pScreen, oldRegion, oldRegion, gravitate[g]);
+	    RegionSubtract(oldRegion, oldRegion, gravitate[g]);
 
 	    /*
 	     * recompute exposed regions of child windows
@@ -925,7 +915,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    {
 		if (pChild->winGravity != g)
 		    continue;
-		REGION_INTERSECT(pScreen, pRegion,
+		RegionIntersect(pRegion,
 				       &pChild->borderClip, gravitate[g]);
 		TraverseTree (pChild, miRecomputeExposures, (void *)pRegion);
 	    }
@@ -936,21 +926,21 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	     */
 
 	    if (g == pWin->bitGravity)
-		REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+		RegionSubtract(&pWin->valdata->after.exposed,
 				     &pWin->valdata->after.exposed, gravitate[g]);
 	    if (!destClip)
 		destClip = gravitate[g];
 	    else
 	    {
-		REGION_UNION(pScreen, destClip, destClip, gravitate[g]);
-		REGION_DESTROY(pScreen, gravitate[g]);
+		RegionUnion(destClip, destClip, gravitate[g]);
+		RegionDestroy(gravitate[g]);
 	    }
 	}
 
-	REGION_DESTROY(pScreen, oldRegion);
-	REGION_DESTROY(pScreen, pRegion);
+	RegionDestroy(oldRegion);
+	RegionDestroy(pRegion);
 	if (destClip)
-	    REGION_DESTROY(pScreen, destClip);
+	    RegionDestroy(destClip);
 	if (bsExposed)
 	{
 	    RegionPtr	valExposed = NullRegion;
@@ -959,8 +949,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
 	if (anyMarked)
 	    (*pScreen->HandleExposures)(pLayerWin->parent);
@@ -977,7 +967,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
     else if (bsExposed)
     {
 	(*pScreen->WindowExposures) (pWin, NullRegion, bsExposed);
-	REGION_DESTROY(pScreen, bsExposed);
+	RegionDestroy(bsExposed);
     }
     if (pWin->realized)
 	WindowsRestructured ();
@@ -1021,8 +1011,8 @@ miSetShape(pWin)
 	    {
 		RegionPtr	borderVisible;
 
-		borderVisible = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_SUBTRACT(pScreen, borderVisible,
+		borderVisible = RegionCreate(NullBox, 1);
+		RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 		pWin->valdata->before.borderVisible = borderVisible;
 	    }
@@ -1039,8 +1029,8 @@ miSetShape(pWin)
     {
 	if (pWin->backStorage)
 	{
-	    pOldClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+	    pOldClip = RegionCreate(NullBox, 1);
+	    RegionCopy(pOldClip, &pWin->clipList);
 	}
 
 	anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin,
@@ -1083,10 +1073,10 @@ miSetShape(pWin)
          */
 
         if (WasViewable && pOldClip)
-            REGION_DESTROY(pScreen, pOldClip);
+            RegionDestroy(pOldClip);
 #else
 	if (WasViewable)
-	    REGION_DESTROY(pScreen, pOldClip);
+	    RegionDestroy(pOldClip);
 #endif
 	if (bsExposed)
 	{
@@ -1096,8 +1086,8 @@ miSetShape(pWin)
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
     }
     if (WasViewable)
@@ -1158,8 +1148,8 @@ miChangeBorderWidth(pWin, width)
 	    if (pWin->valdata && HadBorder)
 	    {
 		RegionPtr   borderVisible;
-		borderVisible = REGION_CREATE(pScreen, NULL, 1);
-		REGION_SUBTRACT(pScreen, borderVisible,
+		borderVisible = RegionCreate(NULL, 1);
+		RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 		pWin->valdata->before.borderVisible = borderVisible;
 	    }
@@ -1196,25 +1186,22 @@ miMarkUnrealizedWindow(pChild, pWin, fromConfigure)
 {
     if ((pChild != pWin) || fromConfigure)
     {
-	REGION_EMPTY(pChild->drawable.pScreen, &pChild->clipList);
+	RegionEmpty(&pChild->clipList);
 	if (pChild->drawable.pScreen->ClipNotify)
 	    (* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0);
-	REGION_EMPTY(pChild->drawable.pScreen, &pChild->borderClip);
+	RegionEmpty(&pChild->borderClip);
     }
 }
 
 void
 miSegregateChildren(WindowPtr pWin, RegionPtr pReg, int depth)
 {
-    ScreenPtr pScreen;
     WindowPtr pChild;
 
-    pScreen = pWin->drawable.pScreen;
-
     for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib)
     {
 	if (pChild->drawable.depth == depth)
-	    REGION_UNION(pScreen, pReg, pReg, &pChild->borderClip);
+	    RegionUnion(pReg, pReg, &pChild->borderClip);
 
 	if (pChild->firstChild)
 	    miSegregateChildren(pChild, pReg, depth);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
index 9c438394a..67cd5d6ed 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
@@ -1537,7 +1537,7 @@ SetPictureClipRects (PicturePtr	pPicture,
     RegionPtr		clientClip;
     int			result;
 
-    clientClip = RECTS_TO_REGION(pScreen,
+    clientClip = RegionFromRects(
 				 nRect, rects, CT_UNSORTED);
     if (!clientClip)
 	return BadAlloc;
@@ -1568,14 +1568,14 @@ SetPictureClipRegion (PicturePtr    pPicture,
     if (pRegion)
     {
         type = CT_REGION;
-        clientClip = REGION_CREATE (pScreen,
-                                    REGION_EXTENTS(pScreen, pRegion),
-                                    REGION_NUM_RECTS(pRegion));
+        clientClip = RegionCreate(
+                                    RegionExtents(pRegion),
+                                    RegionNumRects(pRegion));
         if (!clientClip)
             return BadAlloc;
-        if (!REGION_COPY (pSCreen, clientClip, pRegion))
+        if (!RegionCopy(clientClip, pRegion))
         {
-            REGION_DESTROY (pScreen, clientClip);
+            RegionDestroy(clientClip);
             return BadAlloc;
         }
     }
@@ -1685,9 +1685,9 @@ CopyPicture (PicturePtr	pSrc,
 		    RegionPtr clientClip;
 		    RegionPtr srcClientClip = (RegionPtr)pSrc->clientClip;
 
-		    clientClip = REGION_CREATE(pSrc->pDrawable->pScreen,
-			REGION_EXTENTS(pSrc->pDrawable->pScreen, srcClientClip),
-			REGION_NUM_RECTS(srcClientClip));
+		    clientClip = RegionCreate(
+			RegionExtents(srcClientClip),
+			RegionNumRects(srcClientClip));
 		    (*ps->ChangePictureClip)(pDst, CT_REGION, clientClip, 0);
 		}
 		break;
@@ -2144,12 +2144,6 @@ Bool nxagentReconnectAllPictFormat(void *p)
 
 void nxagentReconnectPictFormat(void *p0, XID x1, void *p2)
 {
-  PictFormatPtr pFormat;
-  Bool *pBool;
-
-  pFormat = (PictFormatPtr)p0;
-  pBool = (Bool*)p2;
-
   #if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_PICTFORMAT_DEBUG)
   fprintf(stderr, "nxagentReconnectPictFormat.\n");
   #endif
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index dc1d2387e..1999c33b0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -3033,13 +3033,11 @@ static void swapStops(void *stuff, int num)
 {
     int i, n;
     CARD32 *stops;
-    CARD16 *colors;
     stops = (CARD32 *)(stuff);
     for (i = 0; i < num; ++i) {
         swapl(stops, n);
         ++stops;
     }
-    colors = (CARD16 *)(stops);
     for (i = 0; i < 4*num; ++i) {
         swaps(stops, n);
         ++stops;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index 4552ad563..b2da4e97c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -226,7 +226,7 @@ PrintChildren(WindowPtr p1, int indent)
 	p2 = p1->firstChild;
 	for (i=0; i<indent; i++) ErrorF( " ");
 	ErrorF( "%x\n", p1->drawable.id);
-	miPrintRegion(&p1->clipList);
+	RegionPrint(&p1->clipList);
 	PrintChildren(p2, indent+4);
 	p1 = p1->nextSib;
     }
@@ -241,7 +241,7 @@ PrintWindowTree()
     {
 	ErrorF( "WINDOW %d\n", i);
 	pWin = WindowTable[i];
-	miPrintRegion(&pWin->clipList);
+	RegionPrint(&pWin->clipList);
 	p1 = pWin->firstChild;
 	PrintChildren(p1, 4);
     }
@@ -339,12 +339,8 @@ SetWindowToDefaults(register WindowPtr pWin)
 
 void nxagentClearSplash(WindowPtr pW)
 {
-    int w, h;
     ScreenPtr pScreen;
 
-    w = pW->drawable.width;
-    h = pW->drawable.height;
-
     pScreen = pW->drawable.pScreen;
 
     if (pW->backgroundState == BackgroundPixmap)
@@ -513,10 +509,10 @@ CreateRootWindow(ScreenPtr pScreen)
     box.y1 = 0;
     box.x2 = pScreen->width;
     box.y2 = pScreen->height;
-    REGION_INIT(pScreen, &pWin->clipList, &box, 1);
-    REGION_INIT(pScreen, &pWin->winSize, &box, 1);
-    REGION_INIT(pScreen, &pWin->borderSize, &box, 1);
-    REGION_INIT(pScreen, &pWin->borderClip, &box, 1);
+    RegionInit(&pWin->clipList, &box, 1);
+    RegionInit(&pWin->winSize, &box, 1);
+    RegionInit(&pWin->borderSize, &box, 1);
+    RegionInit(&pWin->borderClip, &box, 1);
 
     pWin->drawable.class = InputOutput;
     pWin->optional->visual = pScreen->rootVisual;
@@ -701,7 +697,7 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
 #endif /* NXAGENT_SERVER */
     BoxRec box;
 
-    box = *(REGION_EXTENTS(pScreen, &pWin->winSize));
+    box = *(RegionExtents(&pWin->winSize));
     /* we do these calculations to avoid overflows */
     if (x > box.x1)
 	box.x1 = x;
@@ -717,8 +713,8 @@ ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
 	box.x2 = box.x1;
     if (box.y1 > box.y2)
 	box.y2 = box.y1;
-    REGION_RESET(pScreen, Rgn, &box);
-    REGION_INTERSECT(pScreen, Rgn, Rgn, &pWin->winSize);
+    RegionReset(Rgn, &box);
+    RegionIntersect(Rgn, Rgn, &pWin->winSize);
 }
 
 WindowPtr
@@ -899,10 +895,10 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
     pWin->drawable.y = pParent->drawable.y + y + (int)bw;
 
 	/* set up clip list correctly for unobscured WindowPtr */
-    REGION_NULL(pScreen, &pWin->clipList);
-    REGION_NULL(pScreen, &pWin->borderClip);
-    REGION_NULL(pScreen, &pWin->winSize);
-    REGION_NULL(pScreen, &pWin->borderSize);
+    RegionNull(&pWin->clipList);
+    RegionNull(&pWin->borderClip);
+    RegionNull(&pWin->winSize);
+    RegionNull(&pWin->borderSize);
 
     pHead = RealChildHead(pParent);
     if (pHead)
@@ -983,17 +979,17 @@ FreeWindowResources(register WindowPtr pWin)
     DeleteWindowFromAnySaveSet(pWin);
     DeleteWindowFromAnySelections(pWin);
     DeleteWindowFromAnyEvents(pWin, TRUE);
-    REGION_UNINIT(pScreen, &pWin->clipList);
-    REGION_UNINIT(pScreen, &pWin->winSize);
-    REGION_UNINIT(pScreen, &pWin->borderClip);
-    REGION_UNINIT(pScreen, &pWin->borderSize);
+    RegionUninit(&pWin->clipList);
+    RegionUninit(&pWin->winSize);
+    RegionUninit(&pWin->borderClip);
+    RegionUninit(&pWin->borderSize);
 #ifdef SHAPE
     if (wBoundingShape (pWin))
-	REGION_DESTROY(pScreen, wBoundingShape (pWin));
+	RegionDestroy(wBoundingShape (pWin));
     if (wClipShape (pWin))
-	REGION_DESTROY(pScreen, wClipShape (pWin));
+	RegionDestroy(wClipShape (pWin));
     if (wInputShape (pWin))
-	REGION_DESTROY(pScreen, wInputShape (pWin));
+	RegionDestroy(wInputShape (pWin));
 #endif
     if (pWin->borderIsPixel == FALSE)
 	(*pScreen->DestroyPixmap)(pWin->border.pixmap);
@@ -1683,10 +1679,10 @@ PatchUp:
     {
 	RegionRec exposed;
 
-	REGION_NULL(pScreen, &exposed);
-	REGION_SUBTRACT(pScreen, &exposed, &pWin->borderClip, &pWin->winSize);
+	RegionNull(&exposed);
+	RegionSubtract(&exposed, &pWin->borderClip, &pWin->winSize);
 	(*pWin->drawable.pScreen->PaintWindowBorder)(pWin, &exposed, PW_BORDER);
-	REGION_UNINIT(pScreen, &exposed);
+	RegionUninit(&exposed);
     }
     return error;
 }
@@ -1827,19 +1823,19 @@ CreateUnclippedWinSize (register WindowPtr pWin)
     box.y1 = pWin->drawable.y;
     box.x2 = pWin->drawable.x + (int) pWin->drawable.width;
     box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
-    pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
+    pRgn = RegionCreate(&box, 1);
 #ifdef SHAPE
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
 #ifndef NXAGENT_SERVER
 	ScreenPtr pScreen = pWin->drawable.pScreen;
 #endif /* NXAGENT_SERVER */
-	REGION_TRANSLATE(pScreen, pRgn, - pWin->drawable.x,
+	RegionTranslate(pRgn, - pWin->drawable.x,
 			 - pWin->drawable.y);
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
+	    RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wClipShape (pWin));
-	REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x, pWin->drawable.y);
+	    RegionIntersect(pRgn, pRgn, wClipShape (pWin));
+	RegionTranslate(pRgn, pWin->drawable.x, pWin->drawable.y);
     }
 #endif
     return pRgn;
@@ -1857,7 +1853,7 @@ SetWinSize (register WindowPtr pWin)
 	box.y1 = pWin->drawable.y;
 	box.x2 = pWin->drawable.x + pWin->drawable.width;
 	box.y2 = pWin->drawable.y + pWin->drawable.height;
-	REGION_RESET (pScreen, &pWin->winSize, &box);
+	RegionReset(&pWin->winSize, &box);
     }
     else
 #endif
@@ -1870,15 +1866,15 @@ SetWinSize (register WindowPtr pWin)
 #ifndef NXAGENT_SERVER
 	ScreenPtr pScreen = pWin->drawable.pScreen;
 #endif /* NXAGENT_SERVER */
-	REGION_TRANSLATE(pScreen, &pWin->winSize, - pWin->drawable.x,
+	RegionTranslate(&pWin->winSize, - pWin->drawable.x,
 			 - pWin->drawable.y);
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+	    RegionIntersect(&pWin->winSize, &pWin->winSize,
 			     wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, &pWin->winSize, &pWin->winSize,
+	    RegionIntersect(&pWin->winSize, &pWin->winSize,
 			     wClipShape (pWin));
-	REGION_TRANSLATE(pScreen, &pWin->winSize, pWin->drawable.x,
+	RegionTranslate(&pWin->winSize, pWin->drawable.x,
 			 pWin->drawable.y);
     }
 #endif
@@ -1900,7 +1896,7 @@ SetBorderSize (register WindowPtr pWin)
 	    box.y1 = pWin->drawable.y - bw;
 	    box.x2 = pWin->drawable.x + pWin->drawable.width + bw;
 	    box.y2 = pWin->drawable.y + pWin->drawable.height + bw;
-	    REGION_RESET (pScreen, &pWin->borderSize, &box);
+	    RegionReset(&pWin->borderSize, &box);
 	}
 	else
 #endif
@@ -1913,18 +1909,18 @@ SetBorderSize (register WindowPtr pWin)
 #ifndef NXAGENT_SERVER
 	    ScreenPtr pScreen = pWin->drawable.pScreen;
 #endif /* NXAGENT_SERVER */
-	    REGION_TRANSLATE(pScreen, &pWin->borderSize, - pWin->drawable.x,
+	    RegionTranslate(&pWin->borderSize, - pWin->drawable.x,
 			     - pWin->drawable.y);
-	    REGION_INTERSECT(pScreen, &pWin->borderSize, &pWin->borderSize,
+	    RegionIntersect(&pWin->borderSize, &pWin->borderSize,
 			     wBoundingShape (pWin));
-	    REGION_TRANSLATE(pScreen, &pWin->borderSize, pWin->drawable.x,
+	    RegionTranslate(&pWin->borderSize, pWin->drawable.x,
 			     pWin->drawable.y);
-	    REGION_UNION(pScreen, &pWin->borderSize, &pWin->borderSize,
+	    RegionUnion(&pWin->borderSize, &pWin->borderSize,
 			 &pWin->winSize);
 	}
 #endif
     } else {
-	REGION_COPY(pWin->drawable.pScreen, &pWin->borderSize,
+	RegionCopy(&pWin->borderSize,
 					       &pWin->winSize);
     }
 }
@@ -2139,12 +2135,12 @@ MakeBoundingRegion (
 #ifndef NXAGENT_SERVER
     ScreenPtr   pScreen = pWin->drawable.pScreen;
 #endif /* NXAGENT_SERVER */
-    pRgn = REGION_CREATE(pScreen, pBox, 1);
+    pRgn = RegionCreate(pBox, 1);
     if (wBoundingShape (pWin)) {
-	    REGION_TRANSLATE(pScreen, pRgn, -pWin->origin.x,
+	    RegionTranslate(pRgn, -pWin->origin.x,
 						  -pWin->origin.y);
-	    REGION_INTERSECT(pScreen, pRgn, pRgn, wBoundingShape (pWin));
-	    REGION_TRANSLATE(pScreen, pRgn, pWin->origin.x,
+	    RegionIntersect(pRgn, pRgn, wBoundingShape (pWin));
+	    RegionTranslate(pRgn, pWin->origin.x,
 						  pWin->origin.y);
     }
     return pRgn;
@@ -2158,18 +2154,16 @@ ShapeOverlap (
     BoxPtr	pSibBox)
 {
     RegionPtr	pWinRgn, pSibRgn;
-    register ScreenPtr	pScreen;
     Bool	ret;
 
     if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib))
 	return TRUE;
-    pScreen = pWin->drawable.pScreen;
     pWinRgn = MakeBoundingRegion (pWin, pWinBox);
     pSibRgn = MakeBoundingRegion (pSib, pSibBox);
-    REGION_INTERSECT(pScreen, pWinRgn, pWinRgn, pSibRgn);
-    ret = REGION_NOTEMPTY(pScreen, pWinRgn);
-    REGION_DESTROY(pScreen, pWinRgn);
-    REGION_DESTROY(pScreen, pSibRgn);
+    RegionIntersect(pWinRgn, pWinRgn, pSibRgn);
+    ret = RegionNotEmpty(pWinRgn);
+    RegionDestroy(pWinRgn);
+    RegionDestroy(pSibRgn);
     return ret;
 }
 #endif
@@ -2264,7 +2258,6 @@ WhereDoIGoInTheStack(
     int smode)
 {
     BoxRec box;
-    register ScreenPtr pScreen;
     WindowPtr pHead, pFirst;
 
     if ((pWin == pWin->parent->firstChild) &&
@@ -2272,7 +2265,6 @@ WhereDoIGoInTheStack(
 	return((WindowPtr ) NULL);
     pHead = RealChildHead(pWin->parent);
     pFirst = pHead ? pHead->nextSib : pWin->parent->firstChild;
-    pScreen = pWin->drawable.pScreen;
     box.x1 = x;
     box.y1 = y;
     box.x2 = x + (int)w;
@@ -2300,7 +2292,7 @@ WhereDoIGoInTheStack(
 	else if (pSib)
 	{
 	    if ((IsSiblingAboveMe(pWin, pSib) == Above) &&
-		(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+		(RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
 		return(pFirst);
 	    else
 		return(pWin->nextSib);
@@ -2315,7 +2307,7 @@ WhereDoIGoInTheStack(
 	else if (pSib)
 	{
 	    if ((IsSiblingAboveMe(pWin, pSib) == Below) &&
-		(RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT))
+		(RegionContainsRect(&pSib->borderSize, &box) != rgnOUT))
 		return NullWindow;
 	    else
 		return(pWin->nextSib);
@@ -2329,7 +2321,7 @@ WhereDoIGoInTheStack(
 	    return(pWin->nextSib);
 	else if (pSib)
 	{
-	    if (RECT_IN_REGION(pScreen, &pSib->borderSize, &box) != rgnOUT)
+	    if (RegionContainsRect(&pSib->borderSize, &box) != rgnOUT)
 	    {
 		if (IsSiblingAboveMe(pWin, pSib) == Above)
 		    return(pFirst);
@@ -3073,10 +3065,10 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	    (*pScreen->ClipNotify) (pWin, 0, 0);
 	if (pScreen->PostValidateTree)
 	    (*pScreen->PostValidateTree)(NullWindow, pWin, VTMap);
-	REGION_NULL(pScreen, &temp);
-	REGION_COPY(pScreen, &temp, &pWin->clipList);
+	RegionNull(&temp);
+	RegionCopy(&temp, &pWin->clipList);
 	(*pScreen->WindowExposures) (pWin, &temp, NullRegion);
-	REGION_UNINIT(pScreen, &temp);
+	RegionUninit(&temp);
     }
 
     nxagentFlushConfigureWindow();
@@ -3482,7 +3474,7 @@ VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
 {
     if (!pWin->realized)
 	return (FALSE);
-    if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
+    if (RegionContainsPoint(&pWin->clipList, x, y, box))
 	return(TRUE);
     return(FALSE);
 }
@@ -3498,10 +3490,10 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
 
     if (!pWin->realized)
 	return (FALSE);
-    if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->borderClip,
+    if (RegionContainsPoint(&pWin->borderClip,
 						  x, y, &box)
 	&& (!wInputShape(pWin) ||
-	    POINT_IN_REGION(pWin->drawable.pScreen,
+	    RegionContainsPoint(
 			    wInputShape(pWin),
 			    x - pWin->drawable.x, 
 			    y - pWin->drawable.y, &box)))
@@ -3513,16 +3505,14 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
 RegionPtr
 NotClippedByChildren(register WindowPtr pWin)
 {
-    register ScreenPtr pScreen;
     RegionPtr pReg;
 
-    pScreen = pWin->drawable.pScreen;
-    pReg = REGION_CREATE(pScreen, NullBox, 1);
+    pReg = RegionCreate(NullBox, 1);
     if (pWin->parent ||
 	screenIsSaved != SCREEN_SAVER_ON ||
 	!HasSaverWindow (pWin->drawable.pScreen->myNum))
     {
-	REGION_INTERSECT(pScreen, pReg, &pWin->borderClip, &pWin->winSize);
+	RegionIntersect(pReg, &pWin->borderClip, &pWin->winSize);
     }
     return(pReg);
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
index 1dbd059ac..67c514714 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
@@ -160,11 +160,11 @@ PixmapPtr nxagentCreatePixmap(ScreenPtr pScreen, int width,
     box.x2 = width;
     box.y2 = height;
 
-    pPixmapPriv -> corruptedRegion = REGION_CREATE(pPixmap -> drawable.pScreen, &box, 1);
+    pPixmapPriv -> corruptedRegion = RegionCreate(&box, 1);
   }
   else
   {
-    pPixmapPriv -> corruptedRegion = REGION_CREATE(pPixmap -> drawable.pScreen, (BoxRec *) NULL, 1);
+    pPixmapPriv -> corruptedRegion = RegionCreate((BoxRec *) NULL, 1);
   }
 
   pPixmapPriv -> corruptedBackground = 0;
@@ -269,7 +269,7 @@ PixmapPtr nxagentCreatePixmap(ScreenPtr pScreen, int width,
   pVirtualPriv -> isVirtual = True;
   pVirtualPriv -> isShared = nxagentShmPixmapTrap;
 
-  pVirtualPriv -> corruptedRegion = REGION_CREATE(pVirtual -> drawable.pScreen, (BoxRec *) NULL, 1);
+  pVirtualPriv -> corruptedRegion = RegionCreate((BoxRec *) NULL, 1);
 
   pVirtualPriv -> corruptedBackground = 0;
 
@@ -444,7 +444,7 @@ Bool nxagentDestroyPixmap(PixmapPtr pPixmap)
 
   if (pPixmapPriv -> corruptedRegion != NullRegion)
   {
-    REGION_DESTROY(pPixmap -> drawable.pScreen, pPixmapPriv -> corruptedRegion);
+    RegionDestroy(pPixmapPriv -> corruptedRegion);
 
     pPixmapPriv -> corruptedRegion = NullRegion;
   }
@@ -512,7 +512,7 @@ Bool nxagentDestroyVirtualPixmap(PixmapPtr pPixmap)
 
     if (pVirtualPriv -> corruptedRegion != NullRegion)
     {
-      REGION_DESTROY(pVirtual -> drawable.pScreen, pVirtualPriv -> corruptedRegion);
+      RegionDestroy(pVirtualPriv -> corruptedRegion);
 
       pVirtualPriv -> corruptedRegion = NullRegion;
     }
@@ -752,11 +752,11 @@ void nxagentDisconnectPixmap(void *p0, XID x1, void *p2)
 {
   PixmapPtr pPixmap = (PixmapPtr) p0;
 
+  #ifdef TEST
   Bool *pBool;
 
   pBool = (Bool*) p2;
 
-  #ifdef TEST
   fprintf(stderr, "nxagentDisconnectPixmap: Called with bool [%d] and pixmap at [%p].\n",
               *pBool, (void *) pPixmap);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.c b/nx-X11/programs/Xserver/hw/nxagent/Render.c
index 8bf1ac0bf..de1ad1207 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.c
@@ -1240,7 +1240,7 @@ void nxagentGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
     pRegion = nxagentCreateRegion(pDst -> pDrawable, NULL, glyphBox.x1, glyphBox.y1,
                                       glyphBox.x2 - glyphBox.x1, glyphBox.y2 - glyphBox.y1);
     
-    if (REGION_NIL(pRegion) == 1)
+    if (RegionNil(pRegion) == 1)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentGlyphs: WARNING! Glyphs prevented on hidden window at [%p].\n",
@@ -1602,24 +1602,24 @@ void nxagentCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color,
           (op == PictOpSrc ||
                (op == PictOpOver && color -> alpha == 0xffff)))
   {
-    rectRegion = RECTS_TO_REGION(pDst -> pDrawable -> pScreen, nRect, rects, CT_REGION);
+    rectRegion = RegionFromRects(nRect, rects, CT_REGION);
 
     if (pDst -> clientClipType != CT_NONE)
     {
       RegionRec tmpRegion;
 
-      REGION_INIT(pDst -> pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+      RegionInit(&tmpRegion, NullBox, 1);
 
-      REGION_COPY(pDst -> pDrawable -> pScreen, &tmpRegion, (RegionPtr) pDst -> clientClip);
+      RegionCopy(&tmpRegion, (RegionPtr) pDst -> clientClip);
 
       if (pDst -> clipOrigin.x != 0 || pDst -> clipOrigin.y != 0)
       {
-        REGION_TRANSLATE(pDst -> pDrawable -> pScreen, &tmpRegion, pDst -> clipOrigin.x, pDst -> clipOrigin.y);
+        RegionTranslate(&tmpRegion, pDst -> clipOrigin.x, pDst -> clipOrigin.y);
       }
 
-      REGION_INTERSECT(pDst -> pDrawable -> pScreen, rectRegion, rectRegion, &tmpRegion);
+      RegionIntersect(rectRegion, rectRegion, &tmpRegion);
 
-      REGION_UNINIT(pDst -> pDrawable -> pScreen, &tmpRegion);      
+      RegionUninit(&tmpRegion);
     }
 
     #ifdef TEST
@@ -1629,7 +1629,7 @@ void nxagentCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color,
 
     nxagentUnmarkCorruptedRegion(pDst -> pDrawable, rectRegion);
 
-    REGION_DESTROY(pDrawable -> pScreen, rectRegion);
+    RegionDestroy(rectRegion);
   }
 
   XRenderFillRectangles(nxagentDisplay,
@@ -1716,7 +1716,7 @@ FIXME: Is this useful or just a waste of bandwidth?
    */
 
   if (nxagentDrawableStatus(pDst -> pDrawable) == NotSynchronized &&
-          RECT_IN_REGION(pDst -> pDrawable -> pScreen, nxagentCorruptedRegion(pDst -> pDrawable),
+          RegionContainsRect(nxagentCorruptedRegion(pDst -> pDrawable),
                              nxagentTrapezoidExtents) == rgnIN)
   {
     #ifdef TEST
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index 53a3b3fb7..4cf4afcad 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -772,7 +772,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
       {
         #ifdef WARNING
         fprintf(stderr, "nxagentExportProperty: WARNING! "
-                    "Property [%lu] too long.\n", propertyX);
+                    "Property [%lu] too long.\n", (long unsigned int)propertyX);
         #endif
 
         goto nxagentExportPropertyError;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index a677b7eb4..83bcc01fd 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -171,6 +171,7 @@ WindowPtr nxagentViewportFrameBelow;
 Bool nxagentCreateScreenResources(ScreenPtr pScreen);
 void nxagentPrintAgentGeometry(char *hdrMessage, char *prefix);
 
+
 /*
  * These variables are for shadowing feature.
  */
@@ -390,8 +391,8 @@ Window nxagentCreateIconWindow()
                                         valuemask, &attributes);
 
   #ifdef TEST
-  fprintf(stderr, "nxagentCreateIconWindow: Created new icon window with id [%ld].\n",
-              nxagentIconWindow);
+  fprintf(stderr, "nxagentCreateIconWindow: Created new icon window with id [%lu].\n",
+              (long unsigned int)nxagentIconWindow);
   #endif
 
   /*
@@ -453,7 +454,7 @@ void nxagentSetScreenSaverTime(void)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentSetScreenSaverTime: ScreenSaverTime was [%lu], ScreenSaverInterval was [%lu].\n",
-                  ScreenSaverTime, ScreenSaverInterval);
+                  (long unsigned int)ScreenSaverTime, (long unsigned int)ScreenSaverInterval);
   #endif
 
   /*
@@ -473,7 +474,7 @@ void nxagentSetScreenSaverTime(void)
 
   #ifdef TEST
   fprintf(stderr, "nxagentSetScreenSaverTime: ScreenSaverTime now is [%lu], ScreenSaverInterval now is [%lu].\n",
-                  ScreenSaverTime, ScreenSaverInterval);
+                  (long unsigned int)ScreenSaverTime, (long unsigned int)ScreenSaverInterval);
   #endif
 }
 
@@ -1231,7 +1232,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
       #if defined(DEBUG) || defined(DEBUG_COLORMAP)
       fprintf(stderr, "Debug: Added visual [%lu].\n" ,
-                  visuals[numVisuals].vid); 
+                  (long unsigned int)visuals[numVisuals].vid); 
       #endif
 
       for (j = 0; j < numDepths; j++)
@@ -1270,7 +1271,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
       #if defined(DEBUG) || defined(DEBUG_COLORMAP)
       fprintf(stderr, "Debug: Registered visual [%lu] for depth [%d (%d)].\n" ,
-                  visuals[numVisuals].vid, depthIndex,
+                  (long unsigned int)visuals[numVisuals].vid, depthIndex,
                       depths[depthIndex].depth); 
       #endif
 
@@ -1279,7 +1280,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
     #if defined(DEBUG) || defined(DEBUG_COLORMAP)
     fprintf(stderr, "Debug: Setting default visual [%d (%lu)].\n",
-                defaultVisualIndex, visuals[defaultVisualIndex].vid);
+                defaultVisualIndex, (long unsigned int)visuals[defaultVisualIndex].vid);
 
     fprintf(stderr, "Debug: Setting root depth [%d].\n",
                 visuals[defaultVisualIndex].nplanes); 
@@ -1315,8 +1316,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
     #if defined(DEBUG) || defined(DEBUG_COLORMAP)
     fprintf(stderr, "nxagentOpenScreen: Before fbScreenInit numVisuals [%d] numDepths [%d] "
-              "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
-                  rootDepth, defaultVisual);
+              "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+                  rootDepth, (long unsigned int)defaultVisual);
     #endif
 
     if (monitorResolution < 1)
@@ -1332,8 +1333,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
     #if defined(DEBUG) || defined(DEBUG_COLORMAP)
     fprintf(stderr, "nxagentOpenScreen: After fbScreenInit numVisuals [%d] numDepths [%d] "
-              "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
-                  rootDepth, defaultVisual);
+              "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+                  rootDepth, (long unsigned int)defaultVisual);
     #endif
 
     /*
@@ -1344,8 +1345,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
     #if defined(DEBUG) || defined(DEBUG_COLORMAP)
     fprintf(stderr, "nxagentOpenScreen: Before GLX numVisuals [%d] numDepths [%d] "
-              "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
-                  rootDepth, defaultVisual);
+              "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+                  rootDepth, (long unsigned int)defaultVisual);
     #endif
 
     nxagentInitGlxExtension(&visuals, &depths, &numVisuals, &numDepths,
@@ -1353,8 +1354,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
     #if defined(DEBUG) || defined(DEBUG_COLORMAP)
     fprintf(stderr, "nxagentOpenScreen: After GLX numVisuals [%d] numDepths [%d] "
-              "rootDepth [%d] defaultVisual [%ld].\n", numVisuals, numDepths,
-                  rootDepth, defaultVisual);
+              "rootDepth [%d] defaultVisual [%lu].\n", numVisuals, numDepths,
+                  rootDepth, (long unsigned int)defaultVisual);
     #endif
 
     /*
@@ -1720,7 +1721,7 @@ N/A
 
         #ifdef TEST
         fprintf(stderr, "nxagentOpenScreen: Using root window id [%ld].\n",
-                    nxagentDefaultWindows[pScreen->myNum]);
+                    (long int)nxagentDefaultWindows[pScreen->myNum]);
         #endif
       }
 
@@ -1760,7 +1761,7 @@ N/A
 
       #ifdef TEST
       fprintf(stderr, "nxagentOpenScreen: Created new default window with id [%ld].\n",
-                  nxagentDefaultWindows[pScreen->myNum]);
+                  (long int)nxagentDefaultWindows[pScreen->myNum]);
       #endif
 
       /*
@@ -1772,7 +1773,7 @@ N/A
       {
         #ifdef TEST
         fprintf(stderr, "nxagentOpenScreen: Setting WM_CLASS and WM_NAME for window withid [%ld].\n",
-                nxagentDefaultWindows[pScreen->myNum]);
+                (long int)nxagentDefaultWindows[pScreen->myNum]);
         #endif
         XClassHint hint;
         hint.res_name=malloc(strlen("X2GoAgent")+1);
@@ -1787,7 +1788,7 @@ N/A
       {
         #ifdef TEST
         fprintf(stderr, "nxagentOpenScreen: Setting WM_CLASS and WM_NAME for window withid [%ld].\n",
-                nxagentDefaultWindows[pScreen->myNum]);
+                (long int)nxagentDefaultWindows[pScreen->myNum]);
         #endif
 
         XClassHint hint;
@@ -2147,8 +2148,8 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
             {
                 RegionPtr       borderVisible;
 
-                borderVisible = REGION_CREATE(pScreen, NullBox, 1);
-                REGION_SUBTRACT(pScreen, borderVisible,
+                borderVisible = RegionCreate(NullBox, 1);
+                RegionSubtract(borderVisible,
                                 &pWin->borderClip, &pWin->winSize);
                 pWin->valdata->before.borderVisible = borderVisible;
             }
@@ -2167,18 +2168,18 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
         box.y1 = 0;
         box.x2 = pScreen->width;
         box.y2 = pScreen->height;
-        REGION_INIT (pScreen, &pWin->winSize, &box, 1);
-        REGION_INIT (pScreen, &pWin->borderSize, &box, 1);
+        RegionInit(&pWin->winSize, &box, 1);
+        RegionInit(&pWin->borderSize, &box, 1);
         if (WasViewable)
-            REGION_RESET(pScreen, &pWin->borderClip, &box);
+            RegionReset(&pWin->borderClip, &box);
         pWin->drawable.width = pScreen->width;
         pWin->drawable.height = pScreen->height;
-        REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);
+        RegionBreak(&pWin->clipList);
     }
     else
     {
-        REGION_EMPTY(pScreen, &pWin->borderClip);
-        REGION_BREAK (pWin->drawable.pScreen, &pWin->clipList);
+        RegionEmpty(&pWin->borderClip);
+        RegionBreak(&pWin->clipList);
     }
 
     ResizeChildrenWinSize (pWin, 0, 0, 0, 0);
@@ -2187,8 +2188,8 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
     {
         if (pWin->backStorage)
         {
-            pOldClip = REGION_CREATE(pScreen, NullBox, 1);
-            REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+            pOldClip = RegionCreate(NullBox, 1);
+            RegionCopy(pOldClip, &pWin->clipList);
         }
 
         if (pWin->firstChild)
@@ -2223,7 +2224,7 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
                              (pWin, 0, 0, pOldClip,
                               pWin->drawable.x, pWin->drawable.y);
         if (WasViewable)
-            REGION_DESTROY(pScreen, pOldClip);
+            RegionDestroy(pOldClip);
         if (bsExposed)
         {
             RegionPtr   valExposed = NullRegion;
@@ -2232,8 +2233,8 @@ static void nxagentSetRootClip (ScreenPtr pScreen, Bool enable)
                 valExposed = &pWin->valdata->after.exposed;
             (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
             if (valExposed)
-                REGION_EMPTY(pScreen, valExposed);
-            REGION_DESTROY(pScreen, bsExposed);
+                RegionEmpty(valExposed);
+            RegionDestroy(bsExposed);
         }
     }
     if (WasViewable)
@@ -2418,10 +2419,10 @@ FIXME: We should try to restore the previously
   WindowTable[pScreen -> myNum] -> drawable.x = 0;
   WindowTable[pScreen -> myNum] -> drawable.y = 0;
 
-  REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> borderSize, &box, 1);
-  REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> winSize, &box, 1);
-  REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> clipList, &box, 1);
-  REGION_INIT(pScreen, &WindowTable[pScreen -> myNum] -> borderClip, &box, 1);
+  RegionInit(&WindowTable[pScreen -> myNum] -> borderSize, &box, 1);
+  RegionInit(&WindowTable[pScreen -> myNum] -> winSize, &box, 1);
+  RegionInit(&WindowTable[pScreen -> myNum] -> clipList, &box, 1);
+  RegionInit(&WindowTable[pScreen -> myNum] -> borderClip, &box, 1);
 
   (*pScreen -> PositionWindow)(WindowTable[pScreen -> myNum], 0, 0);
 
@@ -2819,7 +2820,7 @@ int nxagentShadowInit(ScreenPtr pScreen, WindowPtr pWin)
 
   XFreeGC(nxagentDisplay, gc);
 
-  REGION_INIT(pScreen, &nxagentShadowUpdateRegion, (BoxRec*)NULL, 1);
+  RegionInit(&nxagentShadowUpdateRegion, (BoxRec*)NULL, 1);
 
   return 0;
 }
@@ -2973,14 +2974,14 @@ int nxagentShadowSendUpdates(int *suspended)
 {
   *suspended = 0;
 
-  if (REGION_NIL(&nxagentShadowUpdateRegion) == 1)
+  if (RegionNil(&nxagentShadowUpdateRegion) == 1)
   {
     return 0;
   }
 
   nxagentMarkCorruptedRegion((DrawablePtr)nxagentShadowPixmapPtr, &nxagentShadowUpdateRegion);
 
-  REGION_EMPTY(nxagentShadowPixmapPtr -> drawable.pScreen, &nxagentShadowUpdateRegion);
+  RegionEmpty(&nxagentShadowUpdateRegion);
 
   return 1;
 }
@@ -3002,9 +3003,9 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
   int overlap;
 
 
-  REGION_NULL(pScreen, &updateRegion);
+  RegionNull(&updateRegion);
 
-  REGION_NULL(pScreen, &tempRegion);
+  RegionNull(&tempRegion);
 
 #ifdef __CYGWIN32__
 
@@ -3116,15 +3117,15 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
       box.y1 = y;
       box.y2 = y + height;
 
-      REGION_INIT(pScreen, &tempRegion, &box, 1);
+      RegionInit(&tempRegion, &box, 1);
 
-      REGION_APPEND(pScreen, &updateRegion, &tempRegion);
+      RegionAppend(&updateRegion, &tempRegion);
 
-      REGION_UNINIT(pScreen, &tempRegion);
+      RegionUninit(&tempRegion);
 
-      REGION_VALIDATE(pScreen, &updateRegion, &overlap);
+      RegionValidate(&updateRegion, &overlap);
 
-      REGION_UNION(pScreen, &nxagentShadowUpdateRegion, &nxagentShadowUpdateRegion, &updateRegion);
+      RegionUnion(&nxagentShadowUpdateRegion, &nxagentShadowUpdateRegion, &updateRegion);
     }
 
     if (tBuffer)
@@ -3132,7 +3133,7 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
       xfree(tBuffer);
     }
 
-    REGION_UNINIT(pScreen, &updateRegion);
+    RegionUninit(&updateRegion);
   }
   else if (result == -1)
   {
@@ -3185,7 +3186,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
   }
 
   #ifdef TEST
-  fprintf(stderr, "nxagentCorrectDepthShadow: Shadow redMask [%x] greenMask[%x] blueMask[%x].\n",
+  fprintf(stderr, "nxagentCorrectDepthShadow: Shadow redMask [%lu] greenMask[%lu] blueMask[%lu].\n",
              pVisual -> red_mask, pVisual -> green_mask, pVisual -> blue_mask);
   #endif
 
@@ -3194,7 +3195,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
   blueMask = nxagentShadowDisplay -> screens[0].root_visual[0].blue_mask;
 
   #ifdef TEST
-  fprintf(stderr, "nxagentCorrectDepthShadow: Master redMask [%x] greenMask[%x] blueMask[%x].\n",
+  fprintf(stderr, "nxagentCorrectDepthShadow: Master redMask [%lu] greenMask[%lu] blueMask[%lu].\n",
               redMask, greenMask, blueMask);
   #endif
 
@@ -3544,11 +3545,8 @@ Bool nxagentReconnectScreen(void *p0)
 {
   CARD16 w, h;
   PixmapPtr pPixmap = (PixmapPtr)nxagentDefaultScreen->devPrivate;
-  int flexibility;
   Mask mask;
 
-  flexibility = *(int*)p0;
-
 #if defined(NXAGENT_RECONNECT_DEBUG) || defined(NXAGENT_RECONNECT_SCREEN_DEBUG)
   fprintf(stderr, "nxagentReconnectScreen\n");
 #endif
@@ -3595,10 +3593,6 @@ Bool nxagentReconnectScreen(void *p0)
   return True;  
 }
 
-/* FIXME: there must be such macros somewhere already...*/
-#define MAX(a,b) ((a) > (b)) ? (a) : (b);
-#define MIN(a,b) ((a) < (b)) ? (a) : (b);
-
 /* intersect two rectangles */
 Bool intersect(int ax1, int ay1, unsigned int aw, unsigned int ah,
 	       int bx1, int by1, unsigned int bw, unsigned int bh,
@@ -3743,7 +3737,7 @@ int nxagentAdjustRandRXinerama(ScreenPtr pScreen)
 
   if (pScrPriv)
   {
-    int i, j;
+    int i;
     int number = 0;
 
     XineramaScreenInfo *screeninfo = NULL;
@@ -4113,7 +4107,6 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
   nxagentPrivPixmapPtr pPrivPixmap;
   XlibGC gc;
   XGCValues values;
-  DrawablePtr pDrawable;
   int i;
   int xSrc, ySrc, xDst, yDst, w, h;
   int nRects;
@@ -4131,10 +4124,8 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
 
   pPrivPixmap -> isBackingPixmap = 1;
 
-  fbCopyWindowProc(&pWin -> drawable, &pVirtualPixmap -> drawable, 0, REGION_RECTS(prgnSave),
-                       REGION_NUM_RECTS(prgnSave), xorg, yorg, FALSE, FALSE, 0, 0);
-
-  pDrawable = &pWin -> drawable;
+  fbCopyWindowProc(&pWin -> drawable, &pVirtualPixmap -> drawable, 0, RegionRects(prgnSave),
+                       RegionNumRects(prgnSave), xorg, yorg, FALSE, FALSE, 0, 0);
 
   values.subwindow_mode = IncludeInferiors;
 
@@ -4145,34 +4136,34 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
    * Coordinates are relative to the window.
    */
 
-  REGION_INIT(pWin -> pScreen, &cleanRegion, NullBox, 1);
+  RegionInit(&cleanRegion, NullBox, 1);
 
-  REGION_COPY(pWin -> pScreen, &cleanRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
+  RegionCopy(&cleanRegion, nxagentCorruptedRegion((DrawablePtr) pWin));
 
   /*
    * Subtract the corrupted region from the saved region.
    */
 
-  REGION_SUBTRACT(pWin -> pScreen, &pBackingStore -> SavedRegion, &pBackingStore -> SavedRegion, &cleanRegion);
+  RegionSubtract(&pBackingStore -> SavedRegion, &pBackingStore -> SavedRegion, &cleanRegion);
 
   /*
    * Translate the corrupted region. Coordinates
    * are relative to the backing store pixmap.
    */
 
-  REGION_TRANSLATE(pWin -> pScreen, &cleanRegion, -pBackingStore -> x, -pBackingStore -> y);
+  RegionTranslate(&cleanRegion, -pBackingStore -> x, -pBackingStore -> y);
 
   /*
    * Compute the clean region to be saved: subtract
    * the corrupted region from the region to be saved.
    */
 
-  REGION_SUBTRACT(pWin -> pScreen, &cleanRegion, prgnSave, &cleanRegion);
+  RegionSubtract(&cleanRegion, prgnSave, &cleanRegion);
 
-  nRects = REGION_NUM_RECTS(&cleanRegion);
+  nRects = RegionNumRects(&cleanRegion);
   size = nRects * sizeof(*pRects);
   pRects = (XRectangle *) xalloc(size);
-  pBox = REGION_RECTS(&cleanRegion);
+  pBox = RegionRects(&cleanRegion);
 
   for (i = nRects; i-- > 0;)
   {
@@ -4186,9 +4177,9 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
 
   xfree((char *) pRects);
 
-  extents = *REGION_EXTENTS(pWin -> pScreen, &cleanRegion);
+  extents = *RegionExtents(&cleanRegion);
 
-  REGION_UNINIT(pWin -> pScreen, &cleanRegion);
+  RegionUninit(&cleanRegion);
 
   xDst = extents.x1;
   yDst = extents.y1;
@@ -4233,7 +4224,6 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
   RegionPtr clipRegion;
   XlibGC gc;
   XGCValues values;
-  DrawablePtr pDrawable;
   int i;
   int xSrc, ySrc, xDst, yDst, w, h;
   int nRects;
@@ -4248,17 +4238,15 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
    * root window size.
    */
 
-  REGION_INTERSECT(pWin -> pScreen, prgnRestore, prgnRestore,
+  RegionIntersect(prgnRestore, prgnRestore,
                        &WindowTable[pWin -> drawable.pScreen -> myNum] -> winSize);
 
   pBackingStore = (miBSWindowPtr) pWin -> backStorage;
 
   pVirtualPixmap = nxagentVirtualPixmap(pPixmap);
 
-  fbCopyWindowProc(&pVirtualPixmap -> drawable, &pWin -> drawable, 0, REGION_RECTS(prgnRestore),
-                       REGION_NUM_RECTS(prgnRestore), -xorg, -yorg, FALSE, FALSE, 0, 0);
-
-  pDrawable = &pVirtualPixmap -> drawable;
+  fbCopyWindowProc(&pVirtualPixmap -> drawable, &pWin -> drawable, 0, RegionRects(prgnRestore),
+                       RegionNumRects(prgnRestore), -xorg, -yorg, FALSE, FALSE, 0, 0);
 
   values.subwindow_mode = ClipByChildren;
 
@@ -4268,7 +4256,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
    * Translate the reference point to the origin of the window.
    */
 
-  REGION_TRANSLATE(pWin -> drawable.pScreen, prgnRestore,
+  RegionTranslate(prgnRestore,
                        -pWin -> drawable.x - pWin -> borderWidth,
                            -pWin -> drawable.y - pWin -> borderWidth);
 
@@ -4276,26 +4264,26 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
   if (nxagentDrawableStatus((DrawablePtr) pPixmap) == NotSynchronized)
   {
-    clipRegion = REGION_CREATE(pPixmap -> drawable -> pScreen, NullBox, 1);
+    clipRegion = RegionCreate(NullBox, 1);
 
-    REGION_COPY(pPixmap -> drawable -> pScreen, clipRegion,
+    RegionCopy(clipRegion,
                         nxagentCorruptedRegion((DrawablePtr) pPixmap));
 
     /*
      * Translate the reference point to the origin of the window.
      */
 
-    REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion,
+    RegionTranslate(clipRegion,
                          pBackingStore -> x, pBackingStore -> y);
 
-    REGION_INTERSECT(pPixmap -> drawable -> pScreen, clipRegion, prgnRestore, clipRegion);
+    RegionIntersect(clipRegion, prgnRestore, clipRegion);
 
     /*
      * Subtract the corrupted region from the saved areas.
      * miBSRestoreAreas will return the exposure region.
      */
 
-    REGION_SUBTRACT(pPixmap -> drawable -> pScreen, &pBackingStore->SavedRegion,
+    RegionSubtract(&pBackingStore->SavedRegion,
                         &pBackingStore->SavedRegion, clipRegion);
 
     /*
@@ -4304,24 +4292,24 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
     if (nxagentRemoteExposeRegion != NULL)
     {
-      REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion, pWin -> drawable.x, pWin -> drawable.y);
+      RegionTranslate(clipRegion, pWin -> drawable.x, pWin -> drawable.y);
 
-      REGION_UNION(pScreen, nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, clipRegion);
+      RegionUnion(nxagentRemoteExposeRegion, nxagentRemoteExposeRegion, clipRegion);
 
-      REGION_TRANSLATE(pPixmap -> drawable -> pScreen, clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
+      RegionTranslate(clipRegion, -pWin -> drawable.x, -pWin -> drawable.y);
     }
 
     /*
      * Compute the region to be restored.
      */
 
-    REGION_SUBTRACT(pPixmap -> drawable -> pScreen, clipRegion, prgnRestore, clipRegion);
+    RegionSubtract(clipRegion, prgnRestore, clipRegion);
   }
 
-  nRects = REGION_NUM_RECTS(clipRegion);
+  nRects = RegionNumRects(clipRegion);
   size = nRects * sizeof(*pRects);
   pRects = (XRectangle *) xalloc(size);
-  pBox = REGION_RECTS(clipRegion);
+  pBox = RegionRects(clipRegion);
 
   for (i = nRects; i-- > 0;)
   {
@@ -4335,7 +4323,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
   xfree(pRects);
 
-  extents = *REGION_EXTENTS(pWin -> pScreen, clipRegion);
+  extents = *RegionExtents(clipRegion);
 
   xDst = extents.x1;
   yDst = extents.y1;
@@ -4355,14 +4343,14 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
   if (clipRegion != NULL && clipRegion != prgnRestore)
   {
-    REGION_DESTROY(pPixmap -> drawable -> pScreen, clipRegion);
+    RegionDestroy(clipRegion);
   }
 
   /*
    * Restore the reference point to the origin of the screen.
    */
 
-  REGION_TRANSLATE(pWin -> drawable.pScreen, prgnRestore,
+  RegionTranslate(prgnRestore,
                        pWin -> drawable.x - pWin -> borderWidth,
                            pWin -> drawable.y + pWin -> borderWidth);
 
@@ -4437,11 +4425,11 @@ void nxagentShadowAdaptToRatio(void)
   box.x2 = nxagentShadowPixmapPtr -> drawable.width;
   box.y2 = nxagentShadowPixmapPtr -> drawable.height;
 
-  REGION_INIT(pScreen, &region, &box, 1);
+  RegionInit(&region, &box, 1);
 
   nxagentMarkCorruptedRegion((DrawablePtr)nxagentShadowPixmapPtr, &region);
 
-  REGION_UNINIT(pScreen, &region);
+  RegionUninit(&region);
 }
 
 void nxagentPrintGeometry()
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.h b/nx-X11/programs/Xserver/hw/nxagent/Screen.h
index aab3ba19c..305d5648f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.h
@@ -102,6 +102,8 @@ Bool nxagentResizeScreen(ScreenPtr pScreen, int width, int height,
 
 int nxagentChangeScreenConfig(int screen, int width, int height, int mmWidth, int mmHeight);
 
+int nxagentAdjustRandRXinerama(ScreenPtr pScreen);
+
 extern Bool nxagentReconnectScreen(void *p0);
 
 void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg, WindowPtr pWin);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Splash.c b/nx-X11/programs/Xserver/hw/nxagent/Splash.c
index abb0872d1..a069b3e23 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Splash.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Splash.c
@@ -165,7 +165,6 @@ int nxagentShowSplashWindow(Window parentWindow)
 void nxagentPaintLogo(Window win, GC gc, int scale, int width, int height)
 {
   XPoint    rect[4];
-  XPoint    m[12];
   int w, h, c, w2, h2;
 
   /*
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Split.c b/nx-X11/programs/Xserver/hw/nxagent/Split.c
index 4cc2ea607..1840328e4 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Split.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Split.c
@@ -502,7 +502,7 @@ void nxagentReleaseSplit(DrawablePtr pDrawable)
                 (void *) pDrawable);
     #endif
 
-    REGION_DESTROY(pDrawable -> pScreen, pResource -> region);
+    RegionDestroy(pResource -> region);
 
     pResource -> region = NullRegion;
   }
@@ -623,11 +623,11 @@ void nxagentValidateSplit(DrawablePtr pDrawable, RegionPtr pRegion)
      * streamed.
      */
 
-    REGION_INIT(pDrawable -> pScreen, &tmpRegion, NullBox, 1);
+    RegionInit(&tmpRegion, NullBox, 1);
 
-    REGION_INTERSECT(pDrawable -> pScreen, &tmpRegion, pResource -> region, pRegion);
+    RegionIntersect(&tmpRegion, pResource -> region, pRegion);
 
-    if (REGION_NIL(&tmpRegion) == 0)
+    if (RegionNil(&tmpRegion) == 0)
     {
       #ifdef TEST
       fprintf(stderr, "nxagentValidateSplit: Marking the overlapping commits as invalid "
@@ -644,7 +644,7 @@ void nxagentValidateSplit(DrawablePtr pDrawable, RegionPtr pRegion)
     }
     #endif
 
-    REGION_UNINIT(pDrawable -> pScreen, &tmpRegion);
+    RegionUninit(&tmpRegion);
   }
 }
 
@@ -1097,9 +1097,9 @@ void nxagentHandleEndSplitEvent(int resource)
       if (pResource -> drawable != NULL &&
               pResource -> region != NullRegion)
       {
-        if (REGION_NIL(pResource -> region) == 0)
+        if (RegionNil(pResource -> region) == 0)
         {
-          REGION_SUBTRACT(pResource -> drawable -> pScreen,
+          RegionSubtract(
                               nxagentCorruptedRegion(pResource -> drawable),
                                   nxagentCorruptedRegion(pResource -> drawable),
                                       pResource -> region);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Utils.h b/nx-X11/programs/Xserver/hw/nxagent/Utils.h
index f5bd55d8b..ef8c4c714 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Utils.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Utils.h
@@ -36,4 +36,8 @@
 #define MIN(A, B) ( (A) < (B) ? (A) : (B) )
 #endif
 
+#ifndef MAX
+#define MAX(A, B) ( (A) > (B) ? (A) : (B) );
+#endif
+
 #endif /* __Utils_H__ */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Window.c b/nx-X11/programs/Xserver/hw/nxagent/Window.c
index 782ab9c9c..fb26b8242 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Window.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Window.c
@@ -388,7 +388,7 @@ FIXME: We need to set save under on the real display?
 
   nxagentWindowPriv(pWin) -> visibilityState = VisibilityUnobscured;
 
-  nxagentWindowPriv(pWin) -> corruptedRegion = REGION_CREATE(pWin -> drawable.pScreen, NULL, 1);
+  nxagentWindowPriv(pWin) -> corruptedRegion = RegionCreate(NULL, 1);
 
   nxagentWindowPriv(pWin) -> hasTransparentChildren = 0;
 
@@ -486,8 +486,8 @@ FIXME: Do all the windows for which nxagentWindowTopLevel(pWin)
 #endif /* SHAPE */
 #else
 #ifdef SHAPE
-  nxagentWindowPriv(pWin)->boundingShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
-  nxagentWindowPriv(pWin)->clipShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+  nxagentWindowPriv(pWin)->boundingShape = RegionCreate(NULL, 1);
+  nxagentWindowPriv(pWin)->clipShape = RegionCreate(NULL, 1);
 #endif /* SHAPE */
 #endif
 
@@ -546,14 +546,14 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
     {
       if (nxagentExposeQueue.exposures[i].localRegion != NullRegion)
       {
-        REGION_DESTROY(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].localRegion);
+        RegionDestroy(nxagentExposeQueue.exposures[i].localRegion);
       }
 
       nxagentExposeQueue.exposures[i].localRegion = NullRegion;
 
       if (nxagentExposeQueue.exposures[i].remoteRegion != NullRegion)
       {
-        REGION_DESTROY(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].remoteRegion);
+        RegionDestroy(nxagentExposeQueue.exposures[i].remoteRegion);
       }
 
       nxagentExposeQueue.exposures[i].remoteRegion = NullRegion;
@@ -576,13 +576,13 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
 
   if (pWindowPriv->boundingShape)
   {
-    REGION_DESTROY(pWin->drawable.pScreen,
+    RegionDestroy(
                        pWindowPriv->boundingShape);
   }
 
   if (pWindowPriv->clipShape)
   {
-    REGION_DESTROY(pWin->drawable.pScreen,
+    RegionDestroy(
                        pWindowPriv->clipShape);
   }
 
@@ -590,17 +590,17 @@ Bool nxagentDestroyWindow(WindowPtr pWin)
 
   #else
 
-  REGION_DESTROY(pWin->drawable.pScreen,
+  RegionDestroy(
                      pWindowPriv->boundingShape);
 
-  REGION_DESTROY(pWin->drawable.pScreen,
+  RegionDestroy(
                      pWindowPriv->clipShape);
 
   #endif
 
   if (pWindowPriv -> corruptedRegion)
   {
-    REGION_DESTROY(pWin -> drawable.pScreen,
+    RegionDestroy(
                        pWindowPriv -> corruptedRegion);
 
     pWindowPriv -> corruptedRegion = NULL;
@@ -1342,7 +1342,7 @@ void nxagentConfigureWindow(WindowPtr pWin, unsigned int mask)
         if (nxagentExposeQueue.exposures[i].pWindow == pWin &&
                 nxagentExposeQueue.exposures[i].remoteRegion != NullRegion)
         {
-          REGION_TRANSLATE(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[i].remoteRegion, offX, offY);
+          RegionTranslate(nxagentExposeQueue.exposures[i].remoteRegion, offX, offY);
         }
       }
     }
@@ -1989,9 +1989,9 @@ void nxagentPaintWindowBackground(pWin, pRegion, what)
   {
     BoxPtr pBox;
 
-    pBox = REGION_RECTS(pRegion);
+    pBox = RegionRects(pRegion);
 
-    for (i = 0; i < REGION_NUM_RECTS(pRegion); i++)
+    for (i = 0; i < RegionNumRects(pRegion); i++)
     {
       XClearArea(nxagentDisplay, nxagentWindow(pWin),
                  pBox[i].x1 - pWin->drawable.x,
@@ -2015,13 +2015,13 @@ void nxagentPaintWindowBackground(pWin, pRegion, what)
    * so we need to clip ourselves.
    */
 
-  REGION_INIT(pWin -> drawable.pScreen, &temp, NullBox, 1);
+  RegionInit(&temp, NullBox, 1);
 
-  REGION_INTERSECT(pWin -> drawable.pScreen, &temp, pRegion, &pWin -> clipList);
+  RegionIntersect(&temp, pRegion, &pWin -> clipList);
 
   nxagentFrameBufferPaintWindow(pWin, &temp, what);
 
-  REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+  RegionUninit(&temp);
 }
 
 void nxagentPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
@@ -2034,13 +2034,13 @@ void nxagentPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
    * so we need to clip ourselves.
    */
 
-  REGION_INIT(pWin -> drawable.pScreen, &temp, NullBox, 1);
+  RegionInit(&temp, NullBox, 1);
 
-  REGION_INTERSECT(pWin -> drawable.pScreen, &temp, pRegion, &pWin -> borderClip);
+  RegionIntersect(&temp, pRegion, &pWin -> borderClip);
 
   nxagentFrameBufferPaintWindow(pWin, &temp, what);
 
-  REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+  RegionUninit(&temp);
 }
 
 void nxagentCopyWindow(WindowPtr pWin, xPoint oldOrigin, RegionPtr oldRegion)
@@ -2149,49 +2149,48 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
       nxagentExposeArrayIsInitialized = 1;
     }
 
-    REGION_INIT(pWin -> drawable.pScreen, &temp, (BoxRec *) NULL, 1);
+    RegionInit(&temp, (BoxRec *) NULL, 1);
 
     if (pRgn != NULL)
     {
-      if (REGION_NUM_RECTS(pRgn) > RECTLIMIT)
+      if (RegionNumRects(pRgn) > RECTLIMIT)
       {
-        box = *REGION_EXTENTS(pWin -> drawable.pScreen, pRgn);
+        box = *RegionExtents(pRgn);
 
-        REGION_EMPTY(pWin -> drawable.pScreen, pRgn);
-        REGION_INIT(pWin -> drawable.pScreen, pRgn, &box, 1);
+        RegionEmpty(pRgn);
+        RegionInit(pRgn, &box, 1);
       }
 
-      REGION_UNION(pWin -> drawable.pScreen, &temp, &temp, pRgn);
+      RegionUnion(&temp, &temp, pRgn);
     }
 
     if (other_exposed != NULL)
     {
-      REGION_UNION(pWin -> drawable.pScreen, &temp, &temp, other_exposed);
+      RegionUnion(&temp, &temp, other_exposed);
     }
 
-    if (REGION_NIL(&temp) == 0)
+    if (RegionNil(&temp) == 0)
     {
-      REGION_TRANSLATE(pWin -> drawable.pScreen, &temp,
+      RegionTranslate(&temp,
                            -(pWin -> drawable.x), -(pWin -> drawable.y));
 
       if (nxagentExposeQueue.length < EXPOSED_SIZE)
       {
-        XWindowChanges changes;
         int index;
 
         index = (nxagentExposeQueue.start + nxagentExposeQueue.length) % EXPOSED_SIZE;
 
         nxagentExposeQueue.exposures[index].pWindow = pWin;
 
-        nxagentExposeQueue.exposures[index].localRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+        nxagentExposeQueue.exposures[index].localRegion = RegionCreate(NULL, 1);
 
         if (nxagentOption(Rootless) && nxagentWindowPriv(pWin) &&
                 (nxagentWindowPriv(pWin) -> isMapped == 0 ||
                      nxagentWindowPriv(pWin) -> visibilityState != VisibilityUnobscured))
         {
-          nxagentExposeQueue.exposures[index].remoteRegion = REGION_CREATE(pwin -> drawable.pScreen, NULL, 1);
+          nxagentExposeQueue.exposures[index].remoteRegion = RegionCreate(NULL, 1);
 
-          REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].remoteRegion,
+          RegionUnion(nxagentExposeQueue.exposures[index].remoteRegion,
                            nxagentExposeQueue.exposures[index].remoteRegion, &temp);
 
           #ifdef TEST
@@ -2201,7 +2200,7 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
         }
         else
         {
-          REGION_UNION(pWin -> drawable.pScreen, nxagentExposeQueue.exposures[index].localRegion,
+          RegionUnion(nxagentExposeQueue.exposures[index].localRegion,
                            nxagentExposeQueue.exposures[index].localRegion, &temp);
 
           #ifdef TEST
@@ -2212,9 +2211,6 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
 
         nxagentExposeSerial = (nxagentExposeSerial - 1) % EXPOSED_SIZE;
 
-        changes.x = nxagentExposeSerial;
-        changes.y = -2;
-
         nxagentExposeQueue.exposures[index].serial = nxagentExposeSerial;
 
         #ifdef TEST
@@ -2234,21 +2230,21 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
                 (nxagentWindowPriv(pWin) -> isMapped == 0 ||
                      nxagentWindowPriv(pWin) -> visibilityState != VisibilityUnobscured))
         {
-          REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+          RegionUninit(&temp);
 
           return;
         }
       }
       else
       {
-        REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+        RegionUninit(&temp);
 
         #ifdef TEST
         fprintf(stderr, "nxagentWindowExposures: WARNING! Reached maximum size of collect exposures vector.\n");
         #endif
 
-        if ((pRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, pRgn) != 0) ||
-               (other_exposed != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, other_exposed) != 0))
+        if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
+               (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
         {
           nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
 
@@ -2259,11 +2255,11 @@ void nxagentWindowExposures(WindowPtr pWin, RegionPtr pRgn, RegionPtr other_expo
       }
     }
 
-    REGION_UNINIT(pWin -> drawable.pScreen, &temp);
+    RegionUninit(&temp);
   }
 
-  if ((pRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, pRgn) != 0) ||
-         (other_exposed != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, other_exposed) != 0))
+  if ((pRgn != NULL && RegionNotEmpty(pRgn) != 0) ||
+         (other_exposed != NULL && RegionNotEmpty(other_exposed) != 0))
   {
     nxagentUnmarkExposedRegion(pWin, pRgn, other_exposed);
 
@@ -2283,11 +2279,11 @@ static Bool nxagentRegionEqual(RegionPtr pReg1, RegionPtr pReg2)
 
   if (pReg1 == NullRegion || pReg2 == NullRegion) return False;
 
-  pBox1 = REGION_RECTS(pReg1);
-  n1 = REGION_NUM_RECTS(pReg1);
+  pBox1 = RegionRects(pReg1);
+  n1 = RegionNumRects(pReg1);
 
-  pBox2 = REGION_RECTS(pReg2);
-  n2 = REGION_NUM_RECTS(pReg2);
+  pBox2 = RegionRects(pReg2);
+  n2 = RegionNumRects(pReg2);
 
   if (n1 != n2) return False;
 
@@ -2326,23 +2322,23 @@ void nxagentShapeWindow(WindowPtr pWin)
     {
       #ifdef DEBUG
       fprintf(stderr, "nxagentShapeWindow: wBounding shape has [%ld] rects.\n",
-                  REGION_NUM_RECTS(wBoundingShape(pWin)));
+                  RegionNumRects(wBoundingShape(pWin)));
       #endif
 
 #ifdef NXAGENT_SHAPE2
       if (!nxagentWindowPriv(pWin)->boundingShape)
       {
-         nxagentWindowPriv(pWin)->boundingShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+         nxagentWindowPriv(pWin)->boundingShape = RegionCreate(NULL, 1);
       }
 #endif
 
-      REGION_COPY(pWin->drawable.pScreen,
+      RegionCopy(
                       nxagentWindowPriv(pWin)->boundingShape, wBoundingShape(pWin));
 
       reg = XCreateRegion();
-      pBox = REGION_RECTS(nxagentWindowPriv(pWin)->boundingShape);
+      pBox = RegionRects(nxagentWindowPriv(pWin)->boundingShape);
       for (i = 0;
-           i < REGION_NUM_RECTS(nxagentWindowPriv(pWin)->boundingShape);
+           i < RegionNumRects(nxagentWindowPriv(pWin)->boundingShape);
            i++)
       {
         rect.x = pBox[i].x1;
@@ -2365,7 +2361,7 @@ void nxagentShapeWindow(WindowPtr pWin)
       fprintf(stderr, "nxagentShapeWindow: wBounding shape does not exist. Removing the shape.\n");
       #endif
 
-      REGION_EMPTY(pWin->drawable.pScreen,
+      RegionEmpty(
                        nxagentWindowPriv(pWin)->boundingShape);
 
 #ifndef NXAGENT_SHAPE
@@ -2386,23 +2382,23 @@ void nxagentShapeWindow(WindowPtr pWin)
     {
       #ifdef DEBUG
       fprintf(stderr, "nxagentShapeWindow: wClip shape has [%ld] rects.\n",
-                  REGION_NUM_RECTS(wClipShape(pWin)));
+                  RegionNumRects(wClipShape(pWin)));
       #endif
 
 #ifdef NXAGENT_SHAPE2
       if (!nxagentWindowPriv(pWin)->clipShape)
       {
-        nxagentWindowPriv(pWin)->clipShape = REGION_CREATE(pWin->drawable.pScreen, NULL, 1);
+        nxagentWindowPriv(pWin)->clipShape = RegionCreate(NULL, 1);
       }
 #endif
 
-      REGION_COPY(pWin->drawable.pScreen,
+      RegionCopy(
                   nxagentWindowPriv(pWin)->clipShape, wClipShape(pWin));
 
       reg = XCreateRegion();
-      pBox = REGION_RECTS(nxagentWindowPriv(pWin)->clipShape);
+      pBox = RegionRects(nxagentWindowPriv(pWin)->clipShape);
       for (i = 0;
-           i < REGION_NUM_RECTS(nxagentWindowPriv(pWin)->clipShape);
+           i < RegionNumRects(nxagentWindowPriv(pWin)->clipShape);
            i++)
       {
         rect.x = pBox[i].x1;
@@ -2425,7 +2421,7 @@ void nxagentShapeWindow(WindowPtr pWin)
       fprintf(stderr, "nxagentShapeWindow: wClip shape does not exist. Removing the shape.\n");
       #endif
 
-      REGION_EMPTY(pWin->drawable.pScreen,
+      RegionEmpty(
                        nxagentWindowPriv(pWin)->clipShape);
 
 #ifndef NXAGENT_SHAPE
@@ -2450,15 +2446,15 @@ static int nxagentForceExposure(WindowPtr pWin, void * ptr)
     Box.x2 = Box.x1 + pWin->drawable.width;
     Box.y2 = Box.y1 + pWin->drawable.height;
 
-    exposedRgn = REGION_CREATE(pWin->drawable.pScreen, &Box, 1);
-    REGION_INTERSECT(pWin->drawable.pScreen, exposedRgn, exposedRgn, &pRoot->winSize);
+    exposedRgn = RegionCreate(&Box, 1);
+    RegionIntersect(exposedRgn, exposedRgn, &pRoot->winSize);
 
-    if (exposedRgn != NULL && REGION_NOTEMPTY(pWin -> drawable.pScreen, exposedRgn) != 0)
+    if (exposedRgn != NULL && RegionNotEmpty(exposedRgn) != 0)
     {
       miWindowExposures(pWin, exposedRgn, NullRegion);
     }
 
-    REGION_DESTROY(pWin->drawable.pScreen, exposedRgn);
+    RegionDestroy(exposedRgn);
   }
 
   return WT_WALKCHILDREN;
@@ -3186,14 +3182,14 @@ static void nxagentReconfigureWindow(void * param0, XID param1, void * data_buff
 #ifdef SHAPE
   if (nxagentWindowPriv(pWin) -> boundingShape)
   {
-    REGION_DESTROY(pWin -> drawable.pScreen,
+    RegionDestroy(
                    nxagentWindowPriv(pWin) -> boundingShape);
     nxagentWindowPriv(pWin) -> boundingShape = NULL;
   }
 
   if (nxagentWindowPriv(pWin) -> clipShape)
   {
-    REGION_DESTROY(pWin -> drawable.pScreen,
+    RegionDestroy(
                    nxagentWindowPriv(pWin) -> clipShape);
     nxagentWindowPriv(pWin) -> clipShape = NULL;
   }
@@ -3389,7 +3385,7 @@ void nxagentSetTopLevelEventMask(pWin)
   if (nxagentOption(Rootless) && nxagentWindowTopLevel(pWin))
   {
     /* Assume that the mask fits in int... broken on Big Endian 64bit systems. */
-    Mask tmp_mask = attributes.event_mask;
+    Mask tmp_mask = attributes.event_mask = NoEventMask;
     nxagentGetEventMask(pWin, &tmp_mask);
     attributes.event_mask = (int)tmp_mask;
 
@@ -3740,7 +3736,7 @@ void nxagentEmptyBackingStoreRegion(void * param0, XID param1, void * data_buffe
 
   if (pBackingStore != NULL)
   {
-    REGION_EMPTY(pWin -> pScreen, &pBackingStore->SavedRegion);
+    RegionEmpty(&pBackingStore->SavedRegion);
 
     #ifdef TEST
     fprintf(stderr, "nxagentEmptyBackingStoreRegion: Emptying saved region for window at [%p].\n", (void*) pWin);
diff --git a/nx-X11/programs/Xserver/include/dix.h b/nx-X11/programs/Xserver/include/dix.h
index 25260e46c..5f9d3b5d5 100644
--- a/nx-X11/programs/Xserver/include/dix.h
+++ b/nx-X11/programs/Xserver/include/dix.h
@@ -386,8 +386,8 @@ extern void ddxBeforeReset (void);
 /* dixutils.c */
 
 extern void CopyISOLatin1Lowered(
-    unsigned char * /*dest*/,
-    unsigned char * /*source*/,
+    char * /*dest*/,
+    const char * /*source*/,
     int /*length*/);
 
 extern int CompareISOLatin1Lowered(
@@ -511,7 +511,7 @@ extern Bool ClientIsAsleep(
 /* atom.c */
 
 extern Atom MakeAtom(
-    char * /*string*/,
+    const char * /*string*/,
     unsigned /*len*/,
     Bool /*makeit*/);
 
diff --git a/nx-X11/programs/Xserver/include/misc.h b/nx-X11/programs/Xserver/include/misc.h
index e6bc1019d..5f30823fa 100644
--- a/nx-X11/programs/Xserver/include/misc.h
+++ b/nx-X11/programs/Xserver/include/misc.h
@@ -295,7 +295,7 @@ extern int Ones(
     unsigned long /*mask*/);
 
 typedef struct _xPoint *DDXPointPtr;
-typedef struct _Box *BoxPtr;
+typedef struct pixman_box16 *BoxPtr;
 typedef struct _xEvent *xEventPtr;
 typedef struct _xRectangle *xRectanglePtr;
 typedef struct _GrabRec *GrabPtr;
diff --git a/nx-X11/programs/Xserver/include/miscstruct.h b/nx-X11/programs/Xserver/include/miscstruct.h
index 7df9240c9..7b1f8047b 100644
--- a/nx-X11/programs/Xserver/include/miscstruct.h
+++ b/nx-X11/programs/Xserver/include/miscstruct.h
@@ -50,15 +50,15 @@ SOFTWARE.
 #ifndef MISCSTRUCT_H
 #define MISCSTRUCT_H 1
 
+#include <pixman.h>
+
 #include "misc.h"
 #include <nx-X11/Xprotostr.h>
 #include "gc.h"
 
 typedef xPoint DDXPointRec;
 
-typedef struct _Box {
-    short x1, y1, x2, y2;
-} BoxRec;
+typedef struct pixman_box16 BoxRec;
 
 typedef union _DevUnion {
     void *		ptr;
diff --git a/nx-X11/programs/Xserver/include/regionstr.h b/nx-X11/programs/Xserver/include/regionstr.h
index cf41170a6..ace8031e0 100644
--- a/nx-X11/programs/Xserver/include/regionstr.h
+++ b/nx-X11/programs/Xserver/include/regionstr.h
@@ -51,7 +51,9 @@ SOFTWARE.
 #ifndef REGIONSTRUCT_H
 #define REGIONSTRUCT_H
 
-typedef struct _Region RegionRec, *RegionPtr;
+#include <pixman.h>
+
+typedef struct pixman_region16 RegionRec, *RegionPtr;
 
 #include <stddef.h>
 #include <limits.h>
@@ -70,347 +72,343 @@ typedef struct _Region RegionRec, *RegionPtr;
  *   clip region
  */
 
-typedef struct _RegData {
-    long	size;
-    long 	numRects;
-/*  BoxRec	rects[size];   in memory but not explicitly declared */
-} RegDataRec, *RegDataPtr;
-
-struct _Region {
-    BoxRec 	extents;
-    RegDataPtr	data;
-};
-
-extern BoxRec miEmptyBox;
-extern RegDataRec miEmptyData;
-extern RegDataRec miBrokenData;
-
-#define REGION_NIL(reg) ((reg)->data && !(reg)->data->numRects)
-/* not a region */
-#define REGION_NAR(reg)	((reg)->data == &miBrokenData)
-#define REGION_NUM_RECTS(reg) ((reg)->data ? (reg)->data->numRects : 1)
-#define REGION_SIZE(reg) ((reg)->data ? (reg)->data->size : 0)
-#define REGION_RECTS(reg) ((reg)->data ? (BoxPtr)((reg)->data + 1) \
-			               : &(reg)->extents)
-#define REGION_BOXPTR(reg) ((BoxPtr)((reg)->data + 1))
-#define REGION_BOX(reg,i) (&REGION_BOXPTR(reg)[i])
-#define REGION_TOP(reg) REGION_BOX(reg, (reg)->data->numRects)
-#define REGION_END(reg) REGION_BOX(reg, (reg)->data->numRects - 1)
-#define REGION_SZOF(n) (n < ((INT_MAX - sizeof(RegDataRec)) / sizeof(BoxRec)) ?  sizeof(RegDataRec) + ((n) * sizeof(BoxRec)) : 0)
-
-/* Keith recommends weaning the region code of pScreen argument */
-#define REG_pScreen	screenInfo.screens[0]
-
-#ifdef NEED_SCREEN_REGIONS
-
-#define REGION_CREATE(_pScreen, _rect, _size) \
-    (*(REG_pScreen)->RegionCreate)(_rect, _size)
-
-#define REGION_INIT(_pScreen, _pReg, _rect, _size) \
-    (*(REG_pScreen)->RegionInit)(_pReg, _rect, _size)
-
-#define REGION_COPY(_pScreen, dst, src) \
-    (*(REG_pScreen)->RegionCopy)(dst, src)
-
-#define REGION_DESTROY(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionDestroy)(_pReg)
-
-#define REGION_UNINIT(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionUninit)(_pReg)
-
-#define REGION_INTERSECT(_pScreen, newReg, reg1, reg2) \
-    (*(REG_pScreen)->Intersect)(newReg, reg1, reg2)
-
-#define REGION_UNION(_pScreen, newReg, reg1, reg2) \
-    (*(REG_pScreen)->Union)(newReg, reg1, reg2)
-
-#define REGION_SUBTRACT(_pScreen, newReg, reg1, reg2) \
-    (*(REG_pScreen)->Subtract)(newReg, reg1, reg2)
-
-#define REGION_INVERSE(_pScreen, newReg, reg1, invRect) \
-    (*(REG_pScreen)->Inverse)(newReg, reg1, invRect)
-
-#define REGION_RESET(_pScreen, _pReg, _pBox) \
-    (*(REG_pScreen)->RegionReset)(_pReg, _pBox)
-
-#define REGION_TRANSLATE(_pScreen, _pReg, _x, _y) \
-    (*(REG_pScreen)->TranslateRegion)(_pReg, _x, _y)
-
-#define RECT_IN_REGION(_pScreen, _pReg, prect) \
-    (*(REG_pScreen)->RectIn)(_pReg, prect)
-
-#define POINT_IN_REGION(_pScreen, _pReg, _x, _y, prect) \
-    (*(REG_pScreen)->PointInRegion)(_pReg, _x, _y, prect)
-
-#define REGION_NOTEMPTY(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionNotEmpty)(_pReg)
-
-#define REGION_EQUAL(_pScreen, _pReg1, _pReg2) \
-    (*(REG_pScreen)->RegionEqual)(_pReg1, _pReg2)
-
-#define REGION_BROKEN(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionBroken)(_pReg)
-
-#define REGION_BREAK(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionBreak)(_pReg)
-
-#define REGION_EMPTY(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionEmpty)(_pReg)
-
-#define REGION_EXTENTS(_pScreen, _pReg) \
-    (*(REG_pScreen)->RegionExtents)(_pReg)
-
-#define REGION_APPEND(_pScreen, dstrgn, rgn) \
-    (*(REG_pScreen)->RegionAppend)(dstrgn, rgn)
-
-#define REGION_VALIDATE(_pScreen, badreg, pOverlap) \
-    (*(REG_pScreen)->RegionValidate)(badreg, pOverlap)
-
-#define BITMAP_TO_REGION(_pScreen, pPix) \
-    (*(REG_pScreen)->BitmapToRegion)(pPix)
-
-#define RECTS_TO_REGION(_pScreen, nrects, prect, ctype) \
-    (*(REG_pScreen)->RectsToRegion)(nrects, prect, ctype)
-
-#else /* !NEED_SCREEN_REGIONS */
-
-/* Reference _pScreen macro argument and check its type */
-#define REGION_SCREEN(_pScreen) (void)((REG_pScreen)->myNum)
-
-#define REGION_CREATE(_pScreen, _rect, _size) \
-    (REGION_SCREEN(_pScreen), miRegionCreate(_rect, _size))
-
-#define REGION_COPY(_pScreen, dst, src) \
-    (REGION_SCREEN(_pScreen), miRegionCopy(dst, src))
-
-#define REGION_DESTROY(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionDestroy(_pReg))
+typedef struct pixman_region16_data RegDataRec, *RegDataPtr;
 
-#define REGION_INTERSECT(_pScreen, newReg, reg1, reg2) \
-    (REGION_SCREEN(_pScreen), miIntersect(newReg, reg1, reg2))
+extern BoxRec RegionEmptyBox;
+extern RegDataRec RegionEmptyData;
+extern RegDataRec RegionBrokenData;
 
-#define REGION_UNION(_pScreen, newReg, reg1, reg2) \
-    (REGION_SCREEN(_pScreen), miUnion(newReg, reg1, reg2))
-
-#define REGION_SUBTRACT(_pScreen, newReg, reg1, reg2) \
-    (REGION_SCREEN(_pScreen), miSubtract(newReg, reg1, reg2))
-
-#define REGION_INVERSE(_pScreen, newReg, reg1, invRect) \
-    (REGION_SCREEN(_pScreen), miInverse(newReg, reg1, invRect))
-
-#define REGION_TRANSLATE(_pScreen, _pReg, _x, _y) \
-    (REGION_SCREEN(_pScreen), miTranslateRegion(_pReg, _x, _y))
-
-#define RECT_IN_REGION(_pScreen, _pReg, prect) \
-    (REGION_SCREEN(_pScreen), miRectIn(_pReg, prect))
-
-#define POINT_IN_REGION(_pScreen, _pReg, _x, _y, prect) \
-    (REGION_SCREEN(_pScreen), miPointInRegion(_pReg, _x, _y, prect))
-
-#define REGION_APPEND(_pScreen, dstrgn, rgn) \
-    (REGION_SCREEN(_pScreen), miRegionAppend(dstrgn, rgn))
+static inline Bool RegionNil(RegionPtr reg) {
+    return ((reg)->data && !(reg)->data->numRects);
+}
 
-#define REGION_VALIDATE(_pScreen, badreg, pOverlap) \
-    (REGION_SCREEN(_pScreen), miRegionValidate(badreg, pOverlap))
+static inline Bool RegionNar(RegionPtr reg) {
+    return ((reg)->data == &RegionBrokenData);
+}
 
-#define BITMAP_TO_REGION(_pScreen, pPix) \
-    (*(_pScreen)->BitmapToRegion)(pPix) /* no mi version?! */
+static inline int RegionNumRects(RegionPtr reg) {
+    return ((reg)->data ? (reg)->data->numRects : 1);
+}
 
-#define RECTS_TO_REGION(_pScreen, nrects, prect, ctype) \
-    (REGION_SCREEN(_pScreen), miRectsToRegion(nrects, prect, ctype))
+static inline int RegionSize(RegionPtr reg) {
+    return ((reg)->data ? (reg)->data->size : 0);
+}
 
-#define REGION_EQUAL(_pScreen, _pReg1, _pReg2) \
-    (REGION_SCREEN(_pScreen), miRegionEqual(_pReg1, _pReg2))
+static inline BoxPtr RegionRects(RegionPtr reg) {
+    return ((reg)->data ? (BoxPtr)((reg)->data + 1) : &(reg)->extents);
+}
 
-#define REGION_BREAK(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionBreak(_pReg))
+static inline BoxPtr RegionBoxptr(RegionPtr reg) {
+    return ((BoxPtr)((reg)->data + 1));
+}
 
-#ifdef DONT_INLINE_REGION_OPS
+static inline BoxPtr RegionBox(RegionPtr reg, int i) {
+    return (&RegionBoxptr(reg)[i]);
+}
 
-#define REGION_INIT(_pScreen, _pReg, _rect, _size) \
-    (REGION_SCREEN(_pScreen), miRegionInit(_pReg, _rect, _size))
+static inline BoxPtr RegionTop(RegionPtr reg) {
+    return RegionBox(reg, (reg)->data->numRects);
+}
 
-#define REGION_UNINIT(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionUninit(_pReg))
+static inline BoxPtr RegionEnd(RegionPtr reg) {
+    return RegionBox(reg, (reg)->data->numRects - 1);
+}
 
-#define REGION_RESET(_pScreen, _pReg, _pBox) \
-    (REGION_SCREEN(_pScreen), miRegionReset(_pReg, _pBox))
+static inline size_t RegionSizeof(int n) {
+    return (sizeof(RegDataRec) + ((n) * sizeof(BoxRec)));
+}
 
-#define REGION_NOTEMPTY(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionNotEmpty(_pReg))
+static inline void RegionInit(RegionPtr _pReg, BoxPtr _rect, int _size)
+{
+    if ((_rect) != NULL)
+    {
+        (_pReg)->extents = *(_rect);
+        (_pReg)->data = (RegDataPtr)NULL;
+    }
+    else
+    {
+        (_pReg)->extents = RegionEmptyBox;
+        if (((_size) > 1) && ((_pReg)->data =
+                             (RegDataPtr)malloc(RegionSizeof(_size))))
+        {
+            (_pReg)->data->size = (_size);
+            (_pReg)->data->numRects = 0;
+        }
+        else
+            (_pReg)->data = &RegionEmptyData;
+    }
+}
 
-#define REGION_BROKEN(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionBroken(_pReg))
+static inline void RegionUninit(RegionPtr _pReg)
+{
+    if ((_pReg)->data && (_pReg)->data->size) {
+       free((_pReg)->data);
+       (_pReg)->data = NULL;
+    }
+}
 
-#define REGION_EMPTY(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionEmpty(_pReg))
+static inline void RegionReset(RegionPtr _pReg, BoxPtr _pBox)
+{
+    (_pReg)->extents = *(_pBox);
+    RegionUninit(_pReg);
+    (_pReg)->data = (RegDataPtr)NULL;
+}
 
-#define REGION_EXTENTS(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), miRegionExtents(_pReg))
+static inline Bool RegionNotEmpty(RegionPtr _pReg) {
+    return !RegionNil(_pReg);
+}
 
-#else /* inline certain simple region ops for performance */
+static inline Bool RegionBroken(RegionPtr _pReg) {
+    return RegionNar(_pReg);
+}
 
-#define REGION_INIT(_pScreen, _pReg, _rect, _size) \
-{ \
-    REGION_SCREEN(_pScreen); \
-    if (_rect) \
-    { \
-        (_pReg)->extents = *(_rect); \
-        (_pReg)->data = (RegDataPtr)NULL; \
-    } \
-    else \
-    { \
-        size_t rgnSize; \
-        (_pReg)->extents = miEmptyBox; \
-        if (((_size) > 1) && ((rgnSize = REGION_SZOF(_size)) > 0) && \
-            ((_pReg)->data = (RegDataPtr)xalloc(rgnSize))) \
-        { \
-            (_pReg)->data->size = (_size); \
-            (_pReg)->data->numRects = 0; \
-        } \
-        else \
-            (_pReg)->data = &miEmptyData; \
-    } \
- }
+static inline void RegionEmpty(RegionPtr _pReg)
+{
+    RegionUninit(_pReg);
+    (_pReg)->extents.x2 = (_pReg)->extents.x1;
+    (_pReg)->extents.y2 = (_pReg)->extents.y1;
+    (_pReg)->data = &RegionEmptyData;
+}
 
+static inline BoxPtr RegionExtents(RegionPtr _pReg)
+{
+    return (&(_pReg)->extents);
+}
 
-#define REGION_UNINIT(_pScreen, _pReg) \
-{ \
-    REGION_SCREEN(_pScreen); \
-    if ((_pReg)->data && (_pReg)->data->size) { \
-	xfree((_pReg)->data); \
-	(_pReg)->data = NULL; \
-    } \
+static inline void RegionNull(RegionPtr _pReg)
+{
+    (_pReg)->extents = RegionEmptyBox;
+    (_pReg)->data = &RegionEmptyData;
 }
 
-#define REGION_RESET(_pScreen, _pReg, _pBox) \
-{ \
-    REGION_SCREEN(_pScreen); \
-    (_pReg)->extents = *(_pBox); \
-    REGION_UNINIT(_pScreen, _pReg); \
-    (_pReg)->data = (RegDataPtr)NULL; \
+static inline Bool
+RegionCopy(RegionPtr dst, RegionPtr src)
+{
+    return pixman_region_copy (dst, src);
 }
 
-#define REGION_NOTEMPTY(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), !REGION_NIL(_pReg))
+static inline Bool
+RegionIntersect(
+    RegionPtr  newReg,     /* destination Region */
+    RegionPtr  reg1,
+    RegionPtr  reg2        /* source regions     */
+    )
+{
+    return pixman_region_intersect (newReg, reg1, reg2);
+}
 
-#define REGION_BROKEN(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), REGION_NAR(_pReg))
+static inline Bool
+RegionUnion(
+    RegionPtr  newReg,          /* destination Region */
+    RegionPtr  reg1,
+    RegionPtr  reg2             /* source regions     */
+    )
+{
+    return pixman_region_union (newReg, reg1, reg2);
+}
 
-#define REGION_EMPTY(_pScreen, _pReg) \
-{ \
-    REGION_UNINIT(_pScreen, _pReg); \
-    (_pReg)->extents.x2 = (_pReg)->extents.x1; \
-    (_pReg)->extents.y2 = (_pReg)->extents.y1; \
-    (_pReg)->data = &miEmptyData; \
+/*
+ *-----------------------------------------------------------------------
+ * Subtract --
+ *     Subtract regS from regM and leave the result in regD.
+ *     S stands for subtrahend, M for minuend and D for difference.
+ *
+ * Results:
+ *     TRUE if successful.
+ *
+ * Side Effects:
+ *     regD is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+static inline Bool
+RegionSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS)
+{
+    return pixman_region_subtract (regD, regM, regS);
 }
 
-#define REGION_EXTENTS(_pScreen, _pReg) \
-    (REGION_SCREEN(_pScreen), &(_pReg)->extents)
+/*
+ *-----------------------------------------------------------------------
+ * Inverse --
+ *     Take a region and a box and return a region that is everything
+ *     in the box but not in the region. The careful reader will note
+ *     that this is the same as subtracting the region from the box...
+ *
+ * Results:
+ *     TRUE.
+ *
+ * Side Effects:
+ *     newReg is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+static inline Bool
+RegionInverse(
+    RegionPtr    newReg,       /* Destination region */
+    RegionPtr    reg1,         /* Region to invert */
+    BoxPtr       invRect       /* Bounding box for inversion */
+    )
+{
+    return pixman_region_inverse (newReg, reg1, invRect);
+}
 
-#define REGION_NULL(_pScreen, _pReg) \
-{ \
-    REGION_SCREEN(_pScreen); \
-    (_pReg)->extents = miEmptyBox; \
-    (_pReg)->data = &miEmptyData; \
+static inline int
+RegionContainsRect(RegionPtr region, BoxPtr prect)
+{
+    return pixman_region_contains_rectangle (region, prect);
 }
 
-#endif /* DONT_INLINE_REGION_OPS */
+/* TranslateRegion(pReg, x, y)
+ * translates in place
+ */
 
-#endif /* NEED_SCREEN_REGIONS */
+static inline void
+RegionTranslate(RegionPtr pReg, int x, int y)
+{
+    pixman_region_translate (pReg, x, y);
+}
 
-#ifndef REGION_NULL
-#define REGION_NULL(_pScreen, _pReg) \
-    REGION_INIT(_pScreen, _pReg, NullBox, 1)
-#endif
+static inline Bool
+RegionContainsPoint(
+    RegionPtr pReg,
+    int x,
+    int y,
+    BoxPtr box      /* "return" value */
+    )
+{
+    return pixman_region_contains_point (pReg, x, y, box);
+}
 
-/* moved from mi.h */
+static inline Bool
+RegionEqual(RegionPtr reg1, RegionPtr reg2)
+{
+    return pixman_region_equal (reg1, reg2);
+}
 
-extern RegionPtr miRegionCreate(
+extern RegionPtr RegionCreate(
     BoxPtr /*rect*/,
     int /*size*/);
 
-extern void miRegionInit(
+extern void RegionInit(
     RegionPtr /*pReg*/,
     BoxPtr /*rect*/,
     int /*size*/);
 
-extern void miRegionDestroy(
+extern void RegionDestroy(
     RegionPtr /*pReg*/);
 
-extern void miRegionUninit(
+extern void RegionUninit(
     RegionPtr /*pReg*/);
 
-extern Bool miRegionCopy(
+extern Bool RegionCopy(
     RegionPtr /*dst*/,
     RegionPtr /*src*/);
 
-extern Bool miIntersect(
+extern Bool RegionIntersect(
     RegionPtr /*newReg*/,
     RegionPtr /*reg1*/,
     RegionPtr /*reg2*/);
 
-extern Bool miUnion(
+extern Bool RegionUnion(
     RegionPtr /*newReg*/,
     RegionPtr /*reg1*/,
     RegionPtr /*reg2*/);
 
-extern Bool miRegionAppend(
+extern Bool RegionAppend(
     RegionPtr /*dstrgn*/,
     RegionPtr /*rgn*/);
 
-extern Bool miRegionValidate(
+extern Bool RegionValidate(
     RegionPtr /*badreg*/,
     Bool * /*pOverlap*/);
 
-extern RegionPtr miRectsToRegion(
+extern RegionPtr RegionFromRects(
     int /*nrects*/,
     xRectanglePtr /*prect*/,
     int /*ctype*/);
 
-extern Bool miSubtract(
+extern Bool RegionSubtract(
     RegionPtr /*regD*/,
     RegionPtr /*regM*/,
     RegionPtr /*regS*/);
 
-extern Bool miInverse(
+extern Bool RegionInverse(
     RegionPtr /*newReg*/,
     RegionPtr /*reg1*/,
     BoxPtr /*invRect*/);
 
-extern int miRectIn(
+extern int RegionContainsRect(
     RegionPtr /*region*/,
     BoxPtr /*prect*/);
 
-extern void miTranslateRegion(
+extern void RegionTranslate(
     RegionPtr /*pReg*/,
     int /*x*/,
     int /*y*/);
 
-extern void miRegionReset(
+extern void RegionReset(
     RegionPtr /*pReg*/,
     BoxPtr /*pBox*/);
 
-extern Bool miRegionBreak(
+extern Bool RegionBreak(
     RegionPtr /*pReg*/);
 
-extern Bool miPointInRegion(
+extern Bool RegionContainsPoint(
     RegionPtr /*pReg*/,
     int /*x*/,
     int /*y*/,
     BoxPtr /*box*/);
 
-extern Bool miRegionEqual(
+extern Bool RegionEqual(
     RegionPtr /*pReg1*/,
     RegionPtr /*pReg2*/);
 
-extern Bool miRegionNotEmpty(
+extern Bool RegionNotEmpty(
     RegionPtr /*pReg*/);
 
-extern void miRegionEmpty(
+extern void RegionEmpty(
     RegionPtr /*pReg*/);
 
-extern BoxPtr miRegionExtents(
+extern BoxPtr RegionExtents(
     RegionPtr /*pReg*/);
 
+#define INCLUDE_LEGACY_REGION_DEFINES
+#ifdef INCLUDE_LEGACY_REGION_DEFINES
+
+#define REGION_NIL				RegionNil
+#define REGION_NAR				RegionNar
+#define REGION_NUM_RECTS			RegionNumRects
+#define REGION_SIZE				RegionSize
+#define REGION_RECTS				RegionRects
+#define REGION_BOXPTR				RegionBoxptr
+#define REGION_BOX				RegionBox
+#define REGION_TOP				RegionTop
+#define REGION_END				RegionEnd
+#define REGION_SZOF				RegionSizeof
+#define BitmapToRegion			BitmapToRegion
+#define REGION_CREATE(pScreen, r, s)		RegionCreate(r,s)
+#define REGION_COPY(pScreen, d, r)		RegionCopy(d, r)
+#define REGION_DESTROY(pScreen, r)		RegionDestroy(r)
+#define REGION_INTERSECT(pScreen, res, r1, r2)	RegionIntersect(res, r1, r2)
+#define REGION_UNION(pScreen, res, r1, r2)	RegionUnion(res, r1, r2)
+#define REGION_SUBTRACT(pScreen, res, r1, r2)	RegionSubtract(res, r1, r2)
+#define REGION_INVERSE(pScreen, n, r, b)	RegionInverse(n, r, b)
+#define REGION_TRANSLATE(pScreen, r, x, y)	RegionTranslate(r, x, y)
+#define RECT_IN_REGION(pScreen, r, b) 		RegionContainsRect(r, b)
+#define POINT_IN_REGION(pScreen, r, x, y, b) 	RegionContainsPoint(r, x, y, b)
+#define REGION_EQUAL(pScreen, r1, r2)		RegionEqual(r1, r2)
+#define REGION_APPEND(pScreen, d, r)		RegionAppend(d, r)
+#define REGION_VALIDATE(pScreen, r, o)		RegionValidate(r, o)
+#define RECTS_TO_REGION(pScreen, n, r, c)	RegionFromRects(n, r, c)
+#define REGION_BREAK(pScreen, r)		RegionBreak(r)
+#define REGION_INIT(pScreen, r, b, s)		RegionInit(r, b, s)
+#define REGION_UNINIT(pScreen, r)		RegionUninit(r)
+#define REGION_RESET(pScreen, r, b)		RegionReset(r, b)
+#define REGION_NOTEMPTY(pScreen, r)		RegionNotEmpty(r)
+#define REGION_BROKEN(pScreen, r)		RegionBroken(r)
+#define REGION_EMPTY(pScreen, r)		RegionEmpty(r)
+#define REGION_EXTENTS(pScreen, r)		RegionExtents(r)
+#define REGION_NULL(pScreen, r)			RegionNull(r)
+
+#endif /* INCLUDE_LEGACY_REGION_DEFINES */
 #endif /* REGIONSTRUCT_H */
diff --git a/nx-X11/programs/Xserver/include/scrnintstr.h b/nx-X11/programs/Xserver/include/scrnintstr.h
index 0539ca516..2597d6b67 100644
--- a/nx-X11/programs/Xserver/include/scrnintstr.h
+++ b/nx-X11/programs/Xserver/include/scrnintstr.h
@@ -709,6 +709,10 @@ typedef struct _Screen {
 
 } ScreenRec;
 
+static inline RegionPtr BitmapToRegion(ScreenPtr _pScreen, PixmapPtr pPix) {
+    return (*(_pScreen)->BitmapToRegion)(pPix); /* no mi version?! */
+}
+
 typedef struct _ScreenInfo {
     int		imageByteOrder;
     int		bitmapScanlineUnit;
diff --git a/nx-X11/programs/Xserver/mi/Imakefile b/nx-X11/programs/Xserver/mi/Imakefile
index e62fb0005..4f87dec8e 100644
--- a/nx-X11/programs/Xserver/mi/Imakefile
+++ b/nx-X11/programs/Xserver/mi/Imakefile
@@ -44,7 +44,7 @@ SRCS =  $(CBRT_SRC) mivaltree.c mipolyseg.c mipolyrect.c \
 	mipoly.c mipolycon.c mipolygen.c mipolyutil.c \
 	mifillrct.c miwideline.c mispans.c \
 	miarc.c mizerarc.c mifillarc.c \
-	miwindow.c micursor.c miregion.c \
+	miwindow.c micursor.c \
 	mipolytext.c mibitblt.c mipolypnt.c mipushpxl.c \
 	miexpose.c miglblt.c mizerline.c mizerclip.c mifpolycon.c \
 	midash.c mibstore.c mibank.c $(MIINITEXTSRC) mieq.c \
@@ -55,7 +55,7 @@ OBJS =	$(CBRT_OBJ) mivaltree.o mipolyseg.o mipolyrect.o \
 	mipoly.o mipolycon.o mipolygen.o mipolyutil.o \
 	mifillrct.o miwideline.o mispans.o \
 	miarc.o mizerarc.o mifillarc.o \
-	miwindow.o micursor.o miregion.o \
+	miwindow.o micursor.o \
 	mipolytext.o mibitblt.o mipolypnt.o mipushpxl.o \
 	miexpose.o miglblt.o mizerline.o mizerclip.o mifpolycon.o \
 	midash.o mibstore.o mibank.o $(MIINITEXTOBJ) mieq.o \
@@ -90,7 +90,8 @@ EXT_DEFINES = ExtensionDefines -UXINPUT -UXF86VIDMODE -UXFreeXDGA -UXF86MISC \
 
 INCLUDES = -I. -I../include -I../render \
 	    -I../xfixes -I../damageext -I../miext/damage \
-           -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/Xext
+           -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/Xext \
+           `pkg-config --cflags-only-I pixman-1`
 LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 DEFINES  = $(FFS_DEFINES)
 
diff --git a/nx-X11/programs/Xserver/mi/mi.h b/nx-X11/programs/Xserver/mi/mi.h
index 6eea34b6c..86db39ad8 100644
--- a/nx-X11/programs/Xserver/mi/mi.h
+++ b/nx-X11/programs/Xserver/mi/mi.h
@@ -403,16 +403,14 @@ extern void miPushPixels(
     int /*yOrg*/
 );
 
-/* miregion.c */
-
 /* see also region.h */
 
-extern Bool miRectAlloc(
+extern Bool RegionRectAlloc(
     RegionPtr /*pRgn*/,
     int /*n*/
 );
 
-extern void miSetExtents(
+extern void RegionSetExtents(
     RegionPtr /*pReg*/
 );
 
@@ -421,13 +419,12 @@ extern int miFindMaxBand(
 );
 
 #ifdef DEBUG
-extern Bool miValidRegion(
+extern Bool RegionIsValid(
     RegionPtr /*prgn*/
 );
 #endif
 
-extern Bool miRegionDataCopy(RegionPtr dst, RegionPtr src);
-extern Bool miRegionBroken(RegionPtr pReg);
+extern Bool RegionBroken(RegionPtr pReg);
 
 /* miscrinit.c */
 
diff --git a/nx-X11/programs/Xserver/mi/mibank.c b/nx-X11/programs/Xserver/mi/mibank.c
index b5da2267f..24e202094 100644
--- a/nx-X11/programs/Xserver/mi/mibank.c
+++ b/nx-X11/programs/Xserver/mi/mibank.c
@@ -607,8 +607,8 @@ miBankCopy(
             if (!pScreenPriv->pBanks[ns])
                 continue;
 
-            nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
-            pBox = REGION_RECTS(pScreenPriv->pBanks[ns]);
+            nBox = RegionNumRects(pScreenPriv->pBanks[ns]);
+            pBox = RegionRects(pScreenPriv->pBanks[ns]);
 
             for (;  nBox--;  pBox++)
             {
@@ -668,8 +668,8 @@ miBankCopy(
              * It's faster to let the lower-level CopyArea do the clipping
              * within each bank.
              */
-            nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
-            pBox = REGION_RECTS(pScreenPriv->pBanks[nd]);
+            nBox = RegionNumRects(pScreenPriv->pBanks[nd]);
+            pBox = RegionRects(pScreenPriv->pBanks[nd]);
 
             for (;  nBox--;  pBox++)
             {
@@ -775,10 +775,10 @@ miBankCopy(
         }
         else
         {
-            REGION_INIT(pScreen, &rgnDst, &fastBox, 1);
-            REGION_INTERSECT(pScreen, &rgnDst, &rgnDst, prgnSrcClip);
-            pBox = REGION_RECTS(&rgnDst);
-            nBox = REGION_NUM_RECTS(&rgnDst);
+            RegionInit(&rgnDst, &fastBox, 1);
+            RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);
+            pBox = RegionRects(&rgnDst);
+            nBox = RegionNumRects(&rgnDst);
         }
 
         /*
@@ -804,8 +804,8 @@ miBankCopy(
                     if (!pScreenPriv->pBanks[ns])
                         continue;
 
-                    nBoxClipSrc = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
-                    pBoxClipSrc = REGION_RECTS(pScreenPriv->pBanks[ns]);
+                    nBoxClipSrc = RegionNumRects(pScreenPriv->pBanks[ns]);
+                    pBoxClipSrc = RegionRects(pScreenPriv->pBanks[ns]);
 
                     for (;  nBoxClipSrc--;  pBoxClipSrc++)
                     {
@@ -836,9 +836,9 @@ miBankCopy(
                              * so use the bank clips here instead.
                              */
                             nBoxClipDst =
-                                REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
+                                RegionNumRects(pScreenPriv->pBanks[nd]);
                             pBoxClipDst =
-                                REGION_RECTS(pScreenPriv->pBanks[nd]);
+                                RegionRects(pScreenPriv->pBanks[nd]);
 
                             for (;  nBoxClipDst--;  pBoxClipDst++)
                             {
@@ -878,7 +878,7 @@ miBankCopy(
                                       pScreenPriv->nPixelsPerScanlinePadUnit) ||
                                      (ccBox.x2 %
                                       pScreenPriv->nPixelsPerScanlinePadUnit) ||
-                                     (RECT_IN_REGION(pScreen,
+                                     (RegionContainsRect(
                                        pGCPriv->pBankedClips[nd], &ccBox) !=
                                       rgnIN)))
                                     pQueue->fastBlit = FALSE;
@@ -892,9 +892,9 @@ miBankCopy(
 
         if (!fastClip)
         {
-            REGION_UNINIT(pScreen, &rgnDst);
+            RegionUninit(&rgnDst);
             if (freeSrcClip)
-                REGION_DESTROY(pScreen, prgnSrcClip);
+                RegionDestroy(prgnSrcClip);
         }
 
         pQueueNew = pQueue;
@@ -1405,16 +1405,16 @@ miBankValidateGC(
                     continue;
 
                 if (!(prgnClip = pGCPriv->pBankedClips[i]))
-                    prgnClip = REGION_CREATE(pScreen, NULL, 1);
+                    prgnClip = RegionCreate(NULL, 1);
 
-                REGION_INTERSECT(pScreen, prgnClip,
+                RegionIntersect(prgnClip,
                     pScreenPriv->pBanks[i], pGC->pCompositeClip);
 
-                if ((REGION_NUM_RECTS(prgnClip) <= 1) &&
+                if ((RegionNumRects(prgnClip) <= 1) &&
                     ((prgnClip->extents.x1 == prgnClip->extents.x2) ||
                      (prgnClip->extents.y1 == prgnClip->extents.y2)))
                 {
-                    REGION_DESTROY(pScreen, prgnClip);
+                    RegionDestroy(prgnClip);
                     pGCPriv->pBankedClips[i] = NULL;
                 }
                 else
@@ -1469,7 +1469,7 @@ miBankValidateGC(
                 if (!pGCPriv->pBankedClips[i])
                     continue;
 
-                REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
+                RegionDestroy(pGCPriv->pBankedClips[i]);
                 pGCPriv->pBankedClips[i] = NULL;
             }
         }
@@ -1528,7 +1528,7 @@ miBankDestroyGC(
         if (!pGCPriv->pBankedClips[i])
             continue;
 
-        REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
+        RegionDestroy(pGCPriv->pBankedClips[i]);
         pGCPriv->pBankedClips[i] = NULL;
     }
 
@@ -1707,7 +1707,7 @@ miBankCloseScreen(
     /* Delete bank clips */
     for (i = 0;  i < pScreenPriv->nBanks;  i++)
         if (pScreenPriv->pBanks[i])
-            REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
+            RegionDestroy(pScreenPriv->pBanks[i]);
 
     Xfree(pScreenPriv->pBanks);
 
@@ -1915,17 +1915,17 @@ miBankPaintWindow(
     }
     else
     {
-        REGION_NULL(pScreen, &tmpReg);
+        RegionNull(&tmpReg);
 
         for (i = 0;  i < pScreenPriv->nBanks;  i++)
         {
             if (!pScreenPriv->pBanks[i])
                 continue;
 
-            REGION_INTERSECT(pScreen, &tmpReg, pRegion,
+            RegionIntersect(&tmpReg, pRegion,
                 pScreenPriv->pBanks[i]);
 
-            if (REGION_NIL(&tmpReg))
+            if (RegionNil(&tmpReg))
                 continue;
 
             SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
@@ -1933,7 +1933,7 @@ miBankPaintWindow(
             (*PaintWindow)(pWin, &tmpReg, what);
         }
 
-        REGION_UNINIT(pScreen, &tmpReg);
+        RegionUninit(&tmpReg);
     }
 
     if (what == PW_BORDER)
@@ -1968,15 +1968,15 @@ miBankCopyWindow(
     ChangeGC(pGC, GCSubwindowMode, &subWindowMode);
     ValidateGC(pDrawable, pGC);
 
-    pRgnDst = REGION_CREATE(pScreen, NULL, 1);
+    pRgnDst = RegionCreate(NULL, 1);
 
     dx = ptOldOrg.x - pWindow->drawable.x;
     dy = ptOldOrg.y - pWindow->drawable.y;
-    REGION_TRANSLATE(pScreen, pRgnSrc, -dx, -dy);
-    REGION_INTERSECT(pScreen, pRgnDst, &pWindow->borderClip, pRgnSrc);
+    RegionTranslate(pRgnSrc, -dx, -dy);
+    RegionIntersect(pRgnDst, &pWindow->borderClip, pRgnSrc);
 
-    pBox = REGION_RECTS(pRgnDst);
-    nBox = REGION_NUM_RECTS(pRgnDst);
+    pBox = RegionRects(pRgnDst);
+    nBox = RegionNumRects(pRgnDst);
 
     pBoxNew1 = NULL;
     pBoxNew2 = NULL;
@@ -2052,7 +2052,7 @@ miBankCopyWindow(
 
     FreeScratchGC(pGC);
 
-    REGION_DESTROY(pScreen, pRgnDst);
+    RegionDestroy(pRgnDst);
 
     DEALLOCATE_LOCAL(pBoxNew2);
     DEALLOCATE_LOCAL(pBoxNew1);
@@ -2086,30 +2086,30 @@ miBankSaveAreas(
     }
     else
     {
-        REGION_NULL(pScreen, &rgnClipped);
-        REGION_TRANSLATE(pScreen, prgnSave, xorg, yorg);
+        RegionNull(&rgnClipped);
+        RegionTranslate(prgnSave, xorg, yorg);
 
         for (i = 0;  i < pScreenPriv->nBanks;  i++)
         {
             if (!pScreenPriv->pBanks[i])
                 continue;
 
-            REGION_INTERSECT(pScreen, &rgnClipped,
+            RegionIntersect(&rgnClipped,
                 prgnSave, pScreenPriv->pBanks[i]);
 
-            if (REGION_NIL(&rgnClipped))
+            if (RegionNil(&rgnClipped))
                 continue;
 
             SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
 
-            REGION_TRANSLATE(pScreen, &rgnClipped, -xorg, -yorg);
+            RegionTranslate(&rgnClipped, -xorg, -yorg);
 
             (*pScreen->BackingStoreFuncs.SaveAreas)(pPixmap, &rgnClipped,
                 xorg, yorg, pWin);
         }
 
-        REGION_TRANSLATE(pScreen, prgnSave, -xorg, -yorg);
-        REGION_UNINIT(pScreen, &rgnClipped);
+        RegionTranslate(prgnSave, -xorg, -yorg);
+        RegionUninit(&rgnClipped);
     }
 
     SCREEN_WRAP(BackingStoreFuncs.SaveAreas, miBankSaveAreas);
@@ -2140,17 +2140,17 @@ miBankRestoreAreas(
     }
     else
     {
-        REGION_NULL(pScreen, &rgnClipped);
+        RegionNull(&rgnClipped);
 
         for (i = 0;  i < pScreenPriv->nBanks;  i++)
         {
             if (!pScreenPriv->pBanks[i])
                 continue;
 
-            REGION_INTERSECT(pScreen, &rgnClipped,
+            RegionIntersect(&rgnClipped,
                 prgnRestore, pScreenPriv->pBanks[i]);
 
-            if (REGION_NIL(&rgnClipped))
+            if (RegionNil(&rgnClipped))
                 continue;
 
             SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
@@ -2159,7 +2159,7 @@ miBankRestoreAreas(
                 xorg, yorg, pWin);
         }
 
-        REGION_UNINIT(pScreen, &rgnClipped);
+        RegionUninit(&rgnClipped);
     }
 
     SCREEN_WRAP(BackingStoreFuncs.RestoreAreas, miBankRestoreAreas);
@@ -2345,9 +2345,9 @@ miInitializeBanking(
         }
 
         pScreenPriv->pBanks[iBank] =
-            RECTS_TO_REGION(pScreen, pRect - pRects, pRects, 0);
+            RegionFromRects(pRect - pRects, pRects, 0);
         if (!pScreenPriv->pBanks[iBank] ||
-            REGION_NAR(pScreenPriv->pBanks[iBank]))
+            RegionNar(pScreenPriv->pBanks[iBank]))
         {
             we = 1;
             break;
@@ -2358,7 +2358,7 @@ miInitializeBanking(
     {
         for (i = iBank;  i >= 0;  i--)
             if (pScreenPriv->pBanks[i])
-                REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
+                RegionDestroy(pScreenPriv->pBanks[i]);
 
         Xfree(pScreenPriv->pBanks);
         Xfree(pScreenPriv);
diff --git a/nx-X11/programs/Xserver/mi/mibitblt.c b/nx-X11/programs/Xserver/mi/mibitblt.c
index 60318a046..b19a15900 100644
--- a/nx-X11/programs/Xserver/mi/mibitblt.c
+++ b/nx-X11/programs/Xserver/mi/mibitblt.c
@@ -117,7 +117,7 @@ miCopyArea(pSrcDrawable, pDstDrawable,
 	box.x2 = pSrcDrawable->x + (int) pSrcDrawable->width;
 	box.y2 = pSrcDrawable->y + (int) pSrcDrawable->height;
 
-	prgnSrcClip = REGION_CREATE(pGC->pScreen, &box, 1);
+	prgnSrcClip = RegionCreate(&box, 1);
 	realSrcClip = 1;
     }
     else
@@ -148,8 +148,8 @@ miCopyArea(pSrcDrawable, pDstDrawable,
         ALLOCATE_LOCAL(heightSrc * sizeof(DDXPointRec));
     pwidthFirst = pwidth = (unsigned int *)
         ALLOCATE_LOCAL(heightSrc * sizeof(unsigned int));
-    numRects = REGION_NUM_RECTS(prgnSrcClip);
-    boxes = REGION_RECTS(prgnSrcClip);
+    numRects = RegionNumRects(prgnSrcClip);
+    boxes = RegionRects(prgnSrcClip);
     ordering = (unsigned int *)
         ALLOCATE_LOCAL(numRects * sizeof(unsigned int));
     if(!pptFirst || !pwidthFirst || !ordering)
@@ -264,7 +264,7 @@ miCopyArea(pSrcDrawable, pDstDrawable,
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
 		      widthSrc, heightSrc, xOut, yOut, (unsigned long)0);
     if(realSrcClip)
-	REGION_DESTROY(pGC->pScreen, prgnSrcClip);
+	RegionDestroy(prgnSrcClip);
 		
     DEALLOCATE_LOCAL(ordering);
     DEALLOCATE_LOCAL(pwidthFirst);
@@ -452,9 +452,9 @@ miOpqStipDrawable(pDraw, pGC, prgnSrc, pbits, srcx, w, h, dstx, dsty)
        to destroy what it's sent.  note that this means we don't
        have to free prgnSrcClip ourselves.
     */
-    prgnSrcClip = REGION_CREATE(pGCT->pScreen, NULL, 0);
-    REGION_COPY(pGCT->pScreen, prgnSrcClip, prgnSrc);
-    REGION_TRANSLATE(pGCT->pScreen, prgnSrcClip, srcx, 0);
+    prgnSrcClip = RegionCreate(NULL, 0);
+    RegionCopy(prgnSrcClip, prgnSrc);
+    RegionTranslate(prgnSrcClip, srcx, 0);
     (*pGCT->funcs->ChangeClip)(pGCT, CT_REGION, prgnSrcClip, 0);
     ValidateGC((DrawablePtr)pPixmap, pGCT);
 
@@ -587,7 +587,7 @@ miCopyPlane(pSrcDrawable, pDstDrawable,
 	box.x2 = box.x1;
     if (box.y1 > box.y2)
 	box.y2 = box.y1;
-    prgnSrc = REGION_CREATE(pGC->pScreen, &box, 1);
+    prgnSrc = RegionCreate(&box, 1);
 
     if (pSrcDrawable->type != DRAWABLE_PIXMAP) {
 	/* clip to visible drawable */
@@ -595,15 +595,15 @@ miCopyPlane(pSrcDrawable, pDstDrawable,
 	if (pGC->subWindowMode == IncludeInferiors)
 	{
 	    RegionPtr	clipList = NotClippedByChildren ((WindowPtr) pSrcDrawable);
-	    REGION_INTERSECT(pGC->pScreen, prgnSrc, prgnSrc, clipList);
-	    REGION_DESTROY(pGC->pScreen, clipList);
+	    RegionIntersect(prgnSrc, prgnSrc, clipList);
+	    RegionDestroy(clipList);
 	} else
-	    REGION_INTERSECT(pGC->pScreen, prgnSrc, prgnSrc,
+	    RegionIntersect(prgnSrc, prgnSrc,
 				       &((WindowPtr)pSrcDrawable)->clipList);
     }
 
-    box = *REGION_EXTENTS(pGC->pScreen, prgnSrc);
-    REGION_TRANSLATE(pGC->pScreen, prgnSrc, -box.x1, -box.y1);
+    box = *RegionExtents(prgnSrc);
+    RegionTranslate(prgnSrc, -box.x1, -box.y1);
 
     if ((box.x2 > box.x1) && (box.y2 > box.y1))
     {
@@ -627,7 +627,7 @@ miCopyPlane(pSrcDrawable, pDstDrawable,
     }
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
 		      width, height, dstx, dsty, bitPlane);
-    REGION_DESTROY(pGC->pScreen, prgnSrc);
+    RegionDestroy(prgnSrc);
     return prgnExposed;
 }
 
@@ -776,11 +776,11 @@ miPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
 	box.y1 = 0;
 	box.x2 = w;
 	box.y2 = h;
-	prgnSrc = REGION_CREATE(pGC->pScreen, &box, 1);
+	prgnSrc = RegionCreate(&box, 1);
 
         miOpqStipDrawable(pDraw, pGC, prgnSrc, (MiBits *) pImage,
 			  leftPad, w, h, x, y);
-	REGION_DESTROY(pGC->pScreen, prgnSrc);
+	RegionDestroy(prgnSrc);
 	break;
 
       case XYPixmap:
diff --git a/nx-X11/programs/Xserver/mi/mibstore.c b/nx-X11/programs/Xserver/mi/mibstore.c
index 875ec87f3..a24e2cbcd 100644
--- a/nx-X11/programs/Xserver/mi/mibstore.c
+++ b/nx-X11/programs/Xserver/mi/mibstore.c
@@ -477,7 +477,7 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
 	bounds.y1 = sy + pDrawable->y;
 	bounds.x2 = bounds.x1 + w;
 	bounds.y2 = bounds.y1 + h;
-	REGION_INIT(pScreen, &Remaining, &bounds, 0);
+	RegionInit(&Remaining, &bounds, 0);
 	for (;;)
  	{
 	    bounds.x1 = sx + pDrawable->x - pWin->drawable.x;
@@ -486,11 +486,11 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
 	    bounds.y2 = bounds.y1 + h;
 	    if (pWin->viewable && pWin->backStorage &&
 		pWin->drawable.depth == depth &&
-	        (RECT_IN_REGION(pScreen, &(pWindowPriv =
+	        (RegionContainsRect(&(pWindowPriv =
 		    (miBSWindowPtr) pWin->backStorage)->SavedRegion,
 		    &bounds) != rgnOUT ||
-		 RECT_IN_REGION(pScreen, &Remaining,
-		  REGION_EXTENTS(pScreen, &pWin->borderSize)) != rgnOUT))
+		 RegionContainsRect(&Remaining,
+		  RegionExtents(&pWin->borderSize)) != rgnOUT))
 	    {
 		if (!pPixmap)
 		{
@@ -508,8 +508,8 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
 		    }
 		    ChangeGC (pGC, GCSubwindowMode, &subWindowMode);
 		    ValidateGC ((DrawablePtr)pPixmap, pGC);
-		    REGION_NULL(pScreen, &Border);
-		    REGION_NULL(pScreen, &Inside);
+		    RegionNull(&Border);
+		    RegionNull(&Inside);
 		    pSrcWin = (WindowPtr) pDrawable;
 		    x = sx;
 		    y = sy;
@@ -523,28 +523,28 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
  					    (DrawablePtr)pPixmap, pGC,
 					    x, y, w, h,
 					    0, 0);
-		    REGION_SUBTRACT(pScreen, &Remaining, &Remaining,
+		    RegionSubtract(&Remaining, &Remaining,
 				    &((WindowPtr) pDrawable)->borderClip);
 		}
 
-		REGION_INTERSECT(pScreen, &Inside, &Remaining, &pWin->winSize);
-		REGION_TRANSLATE(pScreen, &Inside,
+		RegionIntersect(&Inside, &Remaining, &pWin->winSize);
+		RegionTranslate(&Inside,
 					     -pWin->drawable.x,
  					     -pWin->drawable.y);
-		REGION_INTERSECT(pScreen, &Inside, &Inside,
+		RegionIntersect(&Inside, &Inside,
 				 &pWindowPriv->SavedRegion);
 
 		/* offset of sub-window in GetImage pixmap */
 		xoff = pWin->drawable.x - pDrawable->x - sx;
 		yoff = pWin->drawable.y - pDrawable->y - sy;
 
-		if (REGION_NUM_RECTS(&Inside) > 0)
+		if (RegionNumRects(&Inside) > 0)
 		{
 		    switch (pWindowPriv->status)
 		    {
 		    case StatusContents:
-			pBox = REGION_RECTS(&Inside);
-			for (n = REGION_NUM_RECTS(&Inside); --n >= 0;)
+			pBox = RegionRects(&Inside);
+			for (n = RegionNumRects(&Inside); --n >= 0;)
 			{
 			    (*pGC->ops->CopyArea) (
 				(DrawablePtr)pWindowPriv->pBackingPixmap,
@@ -569,12 +569,12 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
 			break;
 		    }
 		}
-		REGION_SUBTRACT(pScreen, &Border, &pWin->borderSize,
+		RegionSubtract(&Border, &pWin->borderSize,
 				&pWin->winSize);
-		REGION_INTERSECT(pScreen, &Border, &Border, &Remaining);
-		if (REGION_NUM_RECTS(&Border) > 0)
+		RegionIntersect(&Border, &Border, &Remaining);
+		if (RegionNumRects(&Border) > 0)
 		{
-		    REGION_TRANSLATE(pScreen, &Border, -pWin->drawable.x,
+		    RegionTranslate(&Border, -pWin->drawable.x,
 						  -pWin->drawable.y);
 		    miBSFillVirtualBits ((DrawablePtr) pPixmap, pGC, &Border,
 				    	xoff, yoff,
@@ -595,12 +595,12 @@ miBSGetImage (pDrawable, sx, sy, w, h, format, planemask, pdstLine)
 	    }
 	}
 
-	REGION_UNINIT(pScreen, &Remaining);
+	RegionUninit(&Remaining);
 
 	if (pPixmap)
 	{
-	    REGION_UNINIT(pScreen, &Border);
-	    REGION_UNINIT(pScreen, &Inside);
+	    RegionUninit(&Border);
+	    RegionUninit(&Inside);
 	    (*pScreen->GetImage) ((DrawablePtr) pPixmap,
 		0, 0, w, h, format, planemask, pdstLine);
 	    (*pScreen->DestroyPixmap) (pPixmap);
@@ -664,7 +664,7 @@ miBSGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
 	    	bounds.y2 = ppt[i].y;
     	}
     
-    	switch (RECT_IN_REGION(pScreen, &pWindowPriv->SavedRegion, &bounds))
+	switch (RegionContainsRect(&pWindowPriv->SavedRegion, &bounds))
  	{
 	case rgnPART:
 	    if (!pPixmap)
@@ -1177,39 +1177,39 @@ miBSDoCopy(
     box.y1 = srcy + pWin->drawable.y;
     box.y2 = box.y1 + h;
     
-    pRgnExp = REGION_CREATE(pGC->pScreen, &box, 1);
-    REGION_INTERSECT(pGC->pScreen, pRgnExp, pRgnExp, &pWin->clipList);
-    pRgnObs = REGION_CREATE(pGC->pScreen, NULL, 1);
-    REGION_INVERSE( pGC->pScreen, pRgnObs, pRgnExp, &box);
+    pRgnExp = RegionCreate(&box, 1);
+    RegionIntersect(pRgnExp, pRgnExp, &pWin->clipList);
+    pRgnObs = RegionCreate(NULL, 1);
+    RegionInverse(pRgnObs, pRgnExp, &box);
 
     /*
      * Translate regions into window coordinates for proper calls
      * to the copyProc, then make sure none of the obscured region sticks
      * into invalid areas of the backing pixmap.
      */
-    REGION_TRANSLATE(pGC->pScreen, pRgnExp,
+    RegionTranslate(pRgnExp,
 				      -pWin->drawable.x,
 				      -pWin->drawable.y);
-    REGION_TRANSLATE(pGC->pScreen, pRgnObs,
+    RegionTranslate(pRgnObs,
 				      -pWin->drawable.x,
 				      -pWin->drawable.y);
-    REGION_INTERSECT(pGC->pScreen, pRgnObs, pRgnObs, &pBackingStore->SavedRegion);
+    RegionIntersect(pRgnObs, pRgnObs, &pBackingStore->SavedRegion);
 
     /*
      * If the obscured region is empty, there's no point being fancy.
      */
-    if (!REGION_NOTEMPTY(pGC->pScreen, pRgnObs))
+    if (!RegionNotEmpty(pRgnObs))
     {
-	REGION_DESTROY(pGC->pScreen, pRgnExp);
-	REGION_DESTROY(pGC->pScreen, pRgnObs);
+	RegionDestroy(pRgnExp);
+	RegionDestroy(pRgnObs);
 
 	return (FALSE);
     }
 
-    numRectsExp = REGION_NUM_RECTS(pRgnExp);
-    pBoxExp = REGION_RECTS(pRgnExp);
-    pBoxObs = REGION_RECTS(pRgnObs);
-    numRectsObs = REGION_NUM_RECTS(pRgnObs);
+    numRectsExp = RegionNumRects(pRgnExp);
+    pBoxExp = RegionRects(pRgnExp);
+    pBoxObs = RegionRects(pRgnObs);
+    numRectsObs = RegionNumRects(pRgnObs);
     nrects = numRectsExp + numRectsObs;
     
     boxes = (struct BoxDraw *)ALLOCATE_LOCAL(nrects * sizeof(struct BoxDraw));
@@ -1220,8 +1220,8 @@ miBSDoCopy(
     {
 	if (sequence) DEALLOCATE_LOCAL(sequence);
 	if (boxes) DEALLOCATE_LOCAL(boxes);
-	REGION_DESTROY(pGC->pScreen, pRgnExp);
-	REGION_DESTROY(pGC->pScreen, pRgnObs);
+	RegionDestroy(pRgnExp);
+	RegionDestroy(pRgnObs);
 
 	return(TRUE);
     }
@@ -1437,25 +1437,25 @@ miBSDoCopy(
      * to return to dispatch which will send the appropriate expose
      * events.
      */
-    REGION_UNION(pGC->pScreen, pRgnExp, pRgnExp, pRgnObs);
+    RegionUnion(pRgnExp, pRgnExp, pRgnObs);
     box.x1 = srcx;
     box.x2 = srcx + w;
     box.y1 = srcy;
     box.y2 = srcy + h;
-    if (RECT_IN_REGION(pGC->pScreen, pRgnExp, &box) == rgnIN)
+    if (RegionContainsRect(pRgnExp, &box) == rgnIN)
     {
-	REGION_EMPTY(pGC->pScreen, pRgnExp);
+	RegionEmpty(pRgnExp);
     }
     else
     {
-	REGION_INVERSE( pGC->pScreen, pRgnExp, pRgnExp, &box);
-	REGION_TRANSLATE( pGC->pScreen, pRgnExp,
+	RegionInverse(pRgnExp, pRgnExp, &box);
+	RegionTranslate(pRgnExp,
 					   dx + pWin->drawable.x,
  					   dy + pWin->drawable.y);
-	REGION_INTERSECT( pGC->pScreen, pRgnObs, pRgnExp, &pWin->clipList);
+	RegionIntersect(pRgnObs, pRgnExp, &pWin->clipList);
 	(*pWin->drawable.pScreen->PaintWindowBackground) (pWin,
 						pRgnObs, PW_BACKGROUND);
-	REGION_TRANSLATE( pGC->pScreen, pRgnExp,
+	RegionTranslate(pRgnExp,
 					   -pWin->drawable.x,
  					   -pWin->drawable.y);
 	miBSClearBackingRegion (pWin, pRgnExp);
@@ -1463,8 +1463,8 @@ miBSDoCopy(
     if (graphicsExposures)
 	*ppRgn = pRgnExp;
     else
-	REGION_DESTROY(pGC->pScreen, pRgnExp);
-    REGION_DESTROY(pGC->pScreen, pRgnObs);
+	RegionDestroy(pRgnExp);
+    RegionDestroy(pRgnObs);
 
     return (TRUE);
 }
@@ -1524,7 +1524,7 @@ miBSCopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty)
 	     * the backing store.  An unnecessary optimisation,
 	     * but a useful one when GetSpans is slow.
 	     */
-	    pExtents = REGION_EXTENTS(pDst->pScreen,
+	    pExtents = RegionExtents(
 				      (RegionPtr)pBackingGC->clientClip);
 	    bsrcx = srcx;
 	    bsrcy = srcy;
@@ -1573,8 +1573,8 @@ miBSCopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty)
     if (winExposed)
     {
 	if (pixExposed){
-	    REGION_UNION(pDst->pScreen, winExposed, winExposed, pixExposed);
-	    REGION_DESTROY(pDst->pScreen, pixExposed);
+	    RegionUnion(winExposed, winExposed, pixExposed);
+	    RegionDestroy(pixExposed);
 	}
     } else
 	winExposed = pixExposed;
@@ -1633,7 +1633,7 @@ miBSCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane)
 	     * the backing store.  An unnecessary optimisation,
 	     * but a useful one when GetSpans is slow.
 	     */
-	    pExtents = REGION_EXTENTS(pDst->pScreen,
+	    pExtents = RegionExtents(
 				      (RegionPtr)pBackingGC->clientClip);
 	    bsrcx = srcx;
 	    bsrcy = srcy;
@@ -1687,8 +1687,8 @@ miBSCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane)
     {
 	if (pixExposed)
 	{
-	    REGION_UNION(pDst->pScreen, winExposed, winExposed, pixExposed);
-	    REGION_DESTROY(pDst->pScreen, pixExposed);
+	    RegionUnion(winExposed, winExposed, pixExposed);
+	    RegionDestroy(pixExposed);
 	}
     } else
 	winExposed = pixExposed;
@@ -2312,12 +2312,12 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
     box.y1 = y;
     box.x2 = x + w;
     box.y2 = y + h;
-    pRgn = REGION_CREATE(pWin->drawable.pScreen, &box, 1);
+    pRgn = RegionCreate(&box, 1);
     if (!pRgn)
 	return NullRegion;
-    REGION_INTERSECT( pScreen, pRgn, pRgn, &pBackingStore->SavedRegion);
+    RegionIntersect(pRgn, pRgn, &pBackingStore->SavedRegion);
 
-    if (REGION_NOTEMPTY( pScreen, pRgn))
+    if (RegionNotEmpty(pRgn))
     {
 	/*
 	 * if clearing entire window, simply make new virtual
@@ -2393,12 +2393,12 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
 		 * Figure out the array of rectangles to fill and fill them with
 		 * PolyFillRect in the proper mode, as set in the GC above.
 		 */
-		numRects = REGION_NUM_RECTS(pRgn);
+		numRects = RegionNumRects(pRgn);
 		rects = (xRectangle *)ALLOCATE_LOCAL(numRects*sizeof(xRectangle));
 	    
 		if (rects)
 		{
-		    for (i = 0, pBox = REGION_RECTS(pRgn);
+		    for (i = 0, pBox = RegionRects(pRgn);
 			 i < numRects;
 			 i++, pBox++)
 		    {
@@ -2418,7 +2418,7 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
 
 	if (!generateExposures)
  	{
-	    REGION_DESTROY(pScreen, pRgn);
+	    RegionDestroy(pRgn);
 	    pRgn = NULL;
 	}
 	else
@@ -2427,13 +2427,13 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
 	     * result must be screen relative, but is currently
 	     * drawable relative.
 	     */
-	    REGION_TRANSLATE(pScreen, pRgn, pWin->drawable.x,
+	    RegionTranslate(pRgn, pWin->drawable.x,
 			     pWin->drawable.y);
 	}
     }
     else
     {
-	REGION_DESTROY( pScreen, pRgn);
+	RegionDestroy(pRgn);
 	pRgn = NULL;
     }
     return pRgn;
@@ -2447,8 +2447,8 @@ miBSClearBackingRegion (pWin, pRgn)
     BoxPtr	pBox;
     int		i;
 
-    i = REGION_NUM_RECTS(pRgn);
-    pBox = REGION_RECTS(pRgn);
+    i = RegionNumRects(pRgn);
+    pBox = RegionRects(pRgn);
     while (i--)
     {
 	(void) miBSClearBackingStore(pWin, pBox->x1, pBox->y1,
@@ -2485,7 +2485,7 @@ miBSFillVirtualBits (pDrawable, pGC, pRgn, x, y, state, pixunion, planeMask)
 
     if (state == None)
 	return;
-    numRects = REGION_NUM_RECTS(pRgn);
+    numRects = RegionNumRects(pRgn);
     pRect = (xRectangle *)ALLOCATE_LOCAL(numRects * sizeof(xRectangle));
     if (!pRect)
 	return;
@@ -2545,7 +2545,7 @@ miBSFillVirtualBits (pDrawable, pGC, pRgn, x, y, state, pixunion, planeMask)
     if (pDrawable->serialNumber != pGC->serialNumber)
 	ValidateGC (pDrawable, pGC);
 
-    pBox = REGION_RECTS(pRgn);
+    pBox = RegionRects(pRgn);
     for (i = numRects; --i >= 0; pBox++, pRect++)
     {
     	pRect->x = pBox->x1 + x;
@@ -2588,7 +2588,7 @@ miBSAllocate(pWin)
 	pBackingStore->pBackingPixmap = NullPixmap;
 	pBackingStore->x = 0;
 	pBackingStore->y = 0;
-	REGION_NULL( pScreen, &pBackingStore->SavedRegion);
+	RegionNull(&pBackingStore->SavedRegion);
 	pBackingStore->viewable = (char)pWin->viewable;
 	pBackingStore->status = StatusNoPixmap;
 	pBackingStore->backgroundState = None;
@@ -2617,16 +2617,16 @@ miBSAllocate(pWin)
 	box.y1 = pWin->drawable.y;
 	box.y2 = pWin->drawable.y + (int) pWin->drawable.height;
 
-	REGION_INVERSE( pScreen, pSavedRegion, &pWin->clipList,  &box);
-	REGION_TRANSLATE( pScreen, pSavedRegion,
+	RegionInverse(pSavedRegion, &pWin->clipList,  &box);
+	RegionTranslate(pSavedRegion,
 				      -pWin->drawable.x,
 				      -pWin->drawable.y);
 #ifdef SHAPE
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, pSavedRegion, pSavedRegion,
+	    RegionIntersect(pSavedRegion, pSavedRegion,
 			     wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, pSavedRegion, pSavedRegion,
+	    RegionIntersect(pSavedRegion, pSavedRegion,
 			     wClipShape (pWin));
 #endif
 	/* if window is already on-screen, assume it has been drawn to */
@@ -2649,7 +2649,7 @@ miBSAllocate(pWin)
          */
         if (pBackingStore->status != StatusNoPixmap)
         {
-            REGION_EMPTY( pScreen, &pBackingStore->SavedRegion);
+            RegionEmpty(&pBackingStore->SavedRegion);
             miDestroyBSPixmap (pWin);
         }
     }
@@ -2683,7 +2683,7 @@ miBSFree(pWin)
     {
 	miDestroyBSPixmap (pWin);
 
-	REGION_UNINIT( pScreen, &pBackingStore->SavedRegion);
+	RegionUninit(&pBackingStore->SavedRegion);
 
 	xfree(pBackingStore);
 	pWin->backStorage = NULL;
@@ -2726,7 +2726,7 @@ miResizeBackingStore(
     if (!pBackingPixmap)
 	return;
     pScreen = pWin->drawable.pScreen;
-    extents = REGION_EXTENTS(pScreen, &pBackingStore->SavedRegion);
+    extents = RegionExtents(&pBackingStore->SavedRegion);
     pNewPixmap = pBackingPixmap;
 
     nw = extents->x2 - extents->x1;
@@ -2838,7 +2838,7 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
 	pBackingStore->viewable = (char)pWin->viewable;
 	if (pWin->backingStore != Always)
 	{
-	    REGION_EMPTY( pScreen, &pBackingStore->SavedRegion);
+	    RegionEmpty(&pBackingStore->SavedRegion);
 	    miDestroyBSPixmap (pWin);
 	    return;
 	}
@@ -2851,14 +2851,14 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
 	(pBackingStore->backgroundState == None))
 	return;
 
-    if (REGION_NOTEMPTY(pScreen, pObscured))
+    if (RegionNotEmpty(pObscured))
     {
 	BoxRec	oldExtents;
 	x = pWin->drawable.x;
 	y = pWin->drawable.y;
-	REGION_TRANSLATE(pScreen, pObscured, -x, -y);
-	oldExtents = *REGION_EXTENTS(pScreen, &pBackingStore->SavedRegion);
-	REGION_UNION( pScreen, &pBackingStore->SavedRegion,
+	RegionTranslate(pObscured, -x, -y);
+	oldExtents = *RegionExtents(&pBackingStore->SavedRegion);
+	RegionUnion(&pBackingStore->SavedRegion,
 			   &pBackingStore->SavedRegion,
 			   pObscured);
 	/*
@@ -2875,7 +2875,7 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
 	    if (pBackingStore->pBackingPixmap) {
 		if (pBackingStore->x | pBackingStore->y)
 		{
-		    REGION_TRANSLATE( pScreen, pObscured,
+		    RegionTranslate(pObscured,
 						  -pBackingStore->x,
 						  -pBackingStore->y);
 		    x += pBackingStore->x;
@@ -2886,13 +2886,13 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
 		     x - dx, y - dy, pWin);
 	    }
 	}
-	REGION_TRANSLATE(pScreen, pObscured, x, y);
+	RegionTranslate(pObscured, x, y);
     }
     else
     {
-	if (REGION_BROKEN (pScreen, pObscured))
+	if (RegionBroken(pObscured))
 	{
-	    REGION_EMPTY( pScreen, &pBackingStore->SavedRegion);
+	    RegionEmpty(&pBackingStore->SavedRegion);
 	    miDestroyBSPixmap (pWin);
 	    return;
 	}
@@ -2943,11 +2943,11 @@ miBSRestoreAreas(pWin, prgnExposed)
 
     if (pBackingStore->status == StatusContents)
     {
-	REGION_TRANSLATE(pScreen, prgnSaved, pWin->drawable.x,
+	RegionTranslate(prgnSaved, pWin->drawable.x,
 			 pWin->drawable.y);
 
-	prgnRestored = REGION_CREATE( pScreen, (BoxPtr)NULL, 1);
-	REGION_INTERSECT( pScreen, prgnRestored, prgnExposed, prgnSaved);
+	prgnRestored = RegionCreate((BoxPtr)NULL, 1);
+	RegionIntersect(prgnRestored, prgnExposed, prgnSaved);
 	
 	/*
 	 * Since prgnExposed is no longer obscured, we no longer
@@ -2956,10 +2956,10 @@ miBSRestoreAreas(pWin, prgnExposed)
 	 * from the area to be exposed.
 	 */
 
-	if (REGION_NOTEMPTY( pScreen, prgnRestored))
+	if (RegionNotEmpty(prgnRestored))
 	{
-	    REGION_SUBTRACT( pScreen, prgnSaved, prgnSaved, prgnExposed);
-	    REGION_SUBTRACT( pScreen, prgnExposed, prgnExposed, prgnRestored);
+	    RegionSubtract(prgnSaved, prgnSaved, prgnExposed);
+	    RegionSubtract(prgnExposed, prgnExposed, prgnRestored);
 
 	    /*
 	     * Do the actual restoration
@@ -2975,9 +2975,9 @@ miBSRestoreAreas(pWin, prgnExposed)
 	     * region to window relative
 	     */
 
-	    if (REGION_NOTEMPTY(pScreen, prgnSaved))
+	    if (RegionNotEmpty(prgnSaved))
 	    {
-		REGION_TRANSLATE(pScreen, prgnSaved,
+		RegionTranslate(prgnSaved,
 					     -pWin->drawable.x,
 					     -pWin->drawable.y);
 		miResizeBackingStore(pWin, 0, 0, TRUE);
@@ -2986,33 +2986,33 @@ miBSRestoreAreas(pWin, prgnExposed)
 		miDestroyBSPixmap (pWin);
 	}
 	else
-	    REGION_TRANSLATE(pScreen, prgnSaved,
+	    RegionTranslate(prgnSaved,
 				-pWin->drawable.x, -pWin->drawable.y);
-	REGION_DESTROY( pScreen, prgnRestored);
+	RegionDestroy(prgnRestored);
 
     }
     else if ((pBackingStore->status == StatusVirtual) ||
 	     (pBackingStore->status == StatusVDirty))
     {
-	REGION_TRANSLATE(pScreen, prgnSaved,
+	RegionTranslate(prgnSaved,
 				     pWin->drawable.x, pWin->drawable.y);
-	exposures = REGION_CREATE( pScreen, NullBox, 1);
+	exposures = RegionCreate(NullBox, 1);
 	if (SameBackground (pBackingStore->backgroundState,
 			    pBackingStore->background,
 			    pWin->backgroundState,
  			    pWin->background))
 	{
-	    REGION_SUBTRACT( pScreen, exposures, prgnExposed, prgnSaved);
+	    RegionSubtract(exposures, prgnExposed, prgnSaved);
 	}
 	else
 	{
 	    miTileVirtualBS(pWin);
 
 	    /* we need to expose all we have (virtually) retiled */
-	    REGION_UNION( pScreen, exposures, prgnExposed, prgnSaved);
+	    RegionUnion(exposures, prgnExposed, prgnSaved);
 	}
-	REGION_SUBTRACT( pScreen, prgnSaved, prgnSaved, prgnExposed);
-	REGION_TRANSLATE(pScreen, prgnSaved,
+	RegionSubtract(prgnSaved, prgnSaved, prgnExposed);
+	RegionTranslate(prgnSaved,
 				     -pWin->drawable.x, -pWin->drawable.y);
     }
     else if (pWin->viewable && !pBackingStore->viewable &&
@@ -3034,21 +3034,21 @@ miBSRestoreAreas(pWin, prgnExposed)
 	box.y1 = pWin->drawable.y;
 	box.y2 = box.y1 + (int) pWin->drawable.height;
 	
-	REGION_INVERSE( pScreen, prgnSaved, &pWin->clipList,  &box);
-	REGION_TRANSLATE( pScreen, prgnSaved,
+	RegionInverse(prgnSaved, &pWin->clipList,  &box);
+	RegionTranslate(prgnSaved,
 				      -pWin->drawable.x,
 				      -pWin->drawable.y);
 #ifdef SHAPE
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT(pScreen, prgnSaved, prgnSaved,
+	    RegionIntersect(prgnSaved, prgnSaved,
 			     wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT(pScreen, prgnSaved, prgnSaved,
+	    RegionIntersect(prgnSaved, prgnSaved,
 			     wClipShape (pWin));
 #endif
 	miTileVirtualBS(pWin);
 
-	exposures = REGION_CREATE( pScreen, &box, 1);
+	exposures = RegionCreate(&box, 1);
     }
     pBackingStore->viewable = (char)pWin->viewable;
     return exposures;
@@ -3143,22 +3143,22 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
      * Compute the new saved region
      */
 
-    newSaved = REGION_CREATE( pScreen, NullBox, 1);
+    newSaved = RegionCreate(NullBox, 1);
     extents.x1 = pWin->drawable.x;
     extents.x2 = pWin->drawable.x + (int) pWin->drawable.width;
     extents.y1 = pWin->drawable.y;
     extents.y2 = pWin->drawable.y + (int) pWin->drawable.height;
-    REGION_INVERSE( pScreen, newSaved, &pWin->clipList, &extents);
+    RegionInverse(newSaved, &pWin->clipList, &extents);
 
-    REGION_TRANSLATE( pScreen, newSaved,
+    RegionTranslate(newSaved,
 			-pWin->drawable.x, -pWin->drawable.y);
 #ifdef SHAPE
     if (wBoundingShape (pWin) || wClipShape (pWin)) {
 	if (wBoundingShape (pWin))
-	    REGION_INTERSECT( pScreen, newSaved, newSaved,
+	    RegionIntersect(newSaved, newSaved,
 				wBoundingShape (pWin));
 	if (wClipShape (pWin))
-	    REGION_INTERSECT( pScreen, newSaved, newSaved, wClipShape (pWin));
+	    RegionIntersect(newSaved, newSaved, wClipShape (pWin));
     }
 #endif
     
@@ -3191,23 +3191,23 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
 	 * bits on the screen which can be put into the
 	 * new backing store
  	 */
-	REGION_TRANSLATE( pScreen, oldClip, windx - oldx, windy - oldy);
-	doomed = REGION_CREATE( pScreen, NullBox, 1);
-	REGION_INTERSECT( pScreen, doomed, oldClip, newSaved);
-	REGION_TRANSLATE( pScreen, oldClip, oldx - windx, oldy - windy);
+	RegionTranslate(oldClip, windx - oldx, windy - oldy);
+	doomed = RegionCreate(NullBox, 1);
+	RegionIntersect(doomed, oldClip, newSaved);
+	RegionTranslate(oldClip, oldx - windx, oldy - windy);
 
 	/*
 	 * Translate the old saved region to the position in the
 	 * window where it will appear to be
 	 */
-	REGION_TRANSLATE( pScreen, pSavedRegion, windx, windy);
+	RegionTranslate(pSavedRegion, windx, windy);
 
 	/*
 	 * Add the old saved region to the new saved region, so
 	 * that calls to RestoreAreas will be able to fetch those
 	 * bits back
 	 */
-	REGION_UNION( pScreen, newSaved, newSaved, pSavedRegion);
+	RegionUnion(newSaved, newSaved, pSavedRegion);
 
 	/*
 	 * Swap the new saved region into the window
@@ -3227,47 +3227,47 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
 	 * set to background in the backing pixmap and
 	 * sent as exposure events to the client.
 	 */
-	REGION_SUBTRACT( pScreen, newSaved, pSavedRegion, newSaved);
+	RegionSubtract(newSaved, pSavedRegion, newSaved);
 
 	/*
 	 * Fetch bits which will be obscured from
 	 * the screen
 	 */
-	if (REGION_NOTEMPTY( pScreen, doomed))
+	if (RegionNotEmpty(doomed))
 	{
 	    /*
 	     * Don't clear regions which have bits on the
 	     * screen
 	     */
-	    REGION_SUBTRACT( pScreen, newSaved, newSaved, doomed);
+	    RegionSubtract(newSaved, newSaved, doomed);
 
 	    /*
 	     * Make the region to SaveDoomedAreas absolute, instead
 	     * of window relative.
 	     */
-	    REGION_TRANSLATE( pScreen, doomed,
+	    RegionTranslate(doomed,
 					  pWin->drawable.x, pWin->drawable.y);
 	    (* pScreen->SaveDoomedAreas) (pWin, doomed, scrdx, scrdy);
 	}
 	
-	REGION_DESTROY(pScreen, doomed);
+	RegionDestroy(doomed);
 
     	/*
  	 * and clear whatever there is that's new
  	 */
-    	if (REGION_NOTEMPTY( pScreen, newSaved))
+	if (RegionNotEmpty(newSaved))
     	{
 	    miBSClearBackingRegion (pWin, newSaved);
 	    /*
 	     * Make the exposed region absolute
 	     */
-	    REGION_TRANSLATE(pScreen, newSaved,
+	    RegionTranslate(newSaved,
 				     	 pWin->drawable.x,
 				     	 pWin->drawable.y);
     	}
     	else
     	{
-	    REGION_DESTROY(pScreen, newSaved);
+	    RegionDestroy(newSaved);
 	    newSaved = NullRegion;
     	}
     }
@@ -3277,8 +3277,8 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
 	 * ForgetGravity: just reset backing store and
 	 * expose the whole mess
 	 */
-	REGION_COPY( pScreen, pSavedRegion, newSaved);
-	REGION_TRANSLATE( pScreen, newSaved,
+	RegionCopy(pSavedRegion, newSaved);
+	RegionTranslate(newSaved,
 				      pWin->drawable.x, pWin->drawable.y);
 
 	miResizeBackingStore (pWin, 0, 0, FALSE);
@@ -3409,13 +3409,13 @@ miBSValidateGC (pGC, stateChanges, pDrawable)
         ((pDrawable->serialNumber != pPriv->serialNumber) ||
 	 (stateChanges&(GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode))))
     {
-	if (REGION_NOTEMPTY(pGC->pScreen, &pWindowPriv->SavedRegion))
+	if (RegionNotEmpty(&pWindowPriv->SavedRegion))
  	{
-	    backingCompositeClip = REGION_CREATE(pGC->pScreen, NULL, 1);
+	    backingCompositeClip = RegionCreate(NULL, 1);
 	    if ((pGC->clientClipType == CT_NONE) || 
 		(pGC->clientClipType == CT_PIXMAP))
 	    {
-		REGION_COPY(pGC->pScreen, backingCompositeClip,
+		RegionCopy(backingCompositeClip,
 					     &pWindowPriv->SavedRegion); 
 	    }
 	    else
@@ -3425,12 +3425,12 @@ miBSValidateGC (pGC, stateChanges, pDrawable)
 		 * its proper origin.
 		 */
 
-		REGION_COPY(pGC->pScreen, backingCompositeClip,
+		RegionCopy(backingCompositeClip,
 				pGC->clientClip);
-		REGION_TRANSLATE(pGC->pScreen, backingCompositeClip,
+		RegionTranslate(backingCompositeClip,
 						  pGC->clipOrg.x,
 						  pGC->clipOrg.y);
-		REGION_INTERSECT(pGC->pScreen, backingCompositeClip,
+		RegionIntersect(backingCompositeClip,
 					backingCompositeClip,
 					&pWindowPriv->SavedRegion);
 	    }
@@ -3444,14 +3444,14 @@ miBSValidateGC (pGC, stateChanges, pDrawable)
 		 * can be fixed only at great cost to the shadow routines.
 		 */
 		translatedClip = NotClippedByChildren (pWin);
-		REGION_TRANSLATE(pGC->pScreen, translatedClip,
+		RegionTranslate(translatedClip,
 						  -pDrawable->x,
 						  -pDrawable->y);
-		REGION_SUBTRACT(pGC->pScreen, backingCompositeClip,
+		RegionSubtract(backingCompositeClip,
 				backingCompositeClip, translatedClip);
-		REGION_DESTROY(pGC->pScreen, translatedClip);
+		RegionDestroy(translatedClip);
 	    }
-	    if (!REGION_NOTEMPTY(pGC->pScreen, backingCompositeClip))
+	    if (!RegionNotEmpty(backingCompositeClip))
 		lift_functions = TRUE;
 	}
  	else
@@ -3508,7 +3508,7 @@ miBSValidateGC (pGC, stateChanges, pDrawable)
     if (lift_functions)
     {
 	if (backingCompositeClip)
-	    REGION_DESTROY( pGC->pScreen, backingCompositeClip);
+	    RegionDestroy(backingCompositeClip);
 
 	/* unwrap the GC again */
 	miBSDestroyGCPrivate (pGC);
@@ -3541,14 +3541,14 @@ miBSValidateGC (pGC, stateChanges, pDrawable)
 	if (pGC->clientClipType == CT_PIXMAP)
 	{
 	    (*pBackingGC->funcs->CopyClip)(pBackingGC, pGC);
-	    REGION_TRANSLATE(pGC->pScreen, backingCompositeClip,
+	    RegionTranslate(backingCompositeClip,
 					-pGC->clipOrg.x, -pGC->clipOrg.y);
 	    vals[0] = pGC->clipOrg.x - pWindowPriv->x;
 	    vals[1] = pGC->clipOrg.y - pWindowPriv->y;
 	    DoChangeGC(pBackingGC, GCClipXOrigin|GCClipYOrigin, vals, 0);
 	    (* pGC->pScreen->BackingStoreFuncs.SetClipmaskRgn)
 		(pBackingGC, backingCompositeClip);
-	    REGION_DESTROY( pGC->pScreen, backingCompositeClip);
+	    RegionDestroy(backingCompositeClip);
 	}
 	else
 	{
@@ -3732,7 +3732,7 @@ miCreateBSPixmap (pWin, pExtents)
     backSet = ((pBackingStore->status == StatusVirtual) ||
 	       (pBackingStore->status == StatusVDirty));
 
-    extents = REGION_EXTENTS( pScreen, &pBackingStore->SavedRegion);
+    extents = RegionExtents(&pBackingStore->SavedRegion);
 
     if (!pBackingStore->pBackingPixmap &&
 	extents->x2 != extents->x1 &&
@@ -3797,7 +3797,7 @@ miCreateBSPixmap (pWin, pExtents)
 	if (exposed)
 	{
 	    miSendExposures(pWin, exposed, pWin->drawable.x, pWin->drawable.y);
-	    REGION_DESTROY( pScreen, exposed);
+	    RegionDestroy(exposed);
 	}
     }
 
@@ -3846,7 +3846,7 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
     register int  	dx, dy;
     BITS32		gcMask;
 
-    if (!REGION_NOTEMPTY(pGC->pScreen, prgnExposed))
+    if (!RegionNotEmpty(prgnExposed))
 	return;
     pBackingStore = (miBSWindowPtr)pSrc->backStorage;
     
@@ -3854,10 +3854,10 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
 	(pBackingStore->status == StatusBadAlloc))
     	return;
 
-    REGION_NULL( pGC->pScreen, &tempRgn);
-    REGION_INTERSECT( pGC->pScreen, &tempRgn, prgnExposed,
+    RegionNull(&tempRgn);
+    RegionIntersect(&tempRgn, prgnExposed,
 				 &pBackingStore->SavedRegion);
-    REGION_SUBTRACT( pGC->pScreen, prgnExposed, prgnExposed, &tempRgn);
+    RegionSubtract(prgnExposed, prgnExposed, &tempRgn);
 
     if (plane != 0) {
 	copyProc = pGC->ops->CopyPlane;
@@ -3889,7 +3889,7 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
 	}
 	break;
     case StatusContents:
-	for (i = REGION_NUM_RECTS(&tempRgn), pBox = REGION_RECTS(&tempRgn);
+	for (i = RegionNumRects(&tempRgn), pBox = RegionRects(&tempRgn);
 	     --i >= 0;
 	     pBox++)
 	{
@@ -3901,5 +3901,5 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
 	}
 	break;
     }
-    REGION_UNINIT( pGC->pScreen, &tempRgn);
+    RegionUninit(&tempRgn);
 }
diff --git a/nx-X11/programs/Xserver/mi/miexpose.c b/nx-X11/programs/Xserver/mi/miexpose.c
index 782ddad49..379dd380f 100644
--- a/nx-X11/programs/Xserver/mi/miexpose.c
+++ b/nx-X11/programs/Xserver/mi/miexpose.c
@@ -185,21 +185,21 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	if (pGC->subWindowMode == IncludeInferiors)
  	{
 	    prgnSrcClip = NotClippedByChildren (pSrcWin);
-	    if ((RECT_IN_REGION(pscr, prgnSrcClip, &TsrcBox)) == rgnIN)
+	    if ((RegionContainsRect(prgnSrcClip, &TsrcBox)) == rgnIN)
 	    {
-		REGION_DESTROY(pscr, prgnSrcClip);
+		RegionDestroy(prgnSrcClip);
 		return NULL;
 	    }
 	}
  	else
  	{
-	    if ((RECT_IN_REGION(pscr, &pSrcWin->clipList, &TsrcBox)) == rgnIN)
+	    if ((RegionContainsRect(&pSrcWin->clipList, &TsrcBox)) == rgnIN)
 		return NULL;
 	    prgnSrcClip = &rgnSrcRec;
-	    REGION_NULL(pscr, prgnSrcClip);
-	    REGION_COPY(pscr, prgnSrcClip, &pSrcWin->clipList);
+	    RegionNull(prgnSrcClip);
+	    RegionCopy(prgnSrcClip, &pSrcWin->clipList);
 	}
-	REGION_TRANSLATE(pscr, prgnSrcClip,
+	RegionTranslate(prgnSrcClip,
 				-pSrcDrawable->x, -pSrcDrawable->y);
     }
     else
@@ -216,7 +216,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	box.x2 = pSrcDrawable->width;
 	box.y2 = pSrcDrawable->height;
 	prgnSrcClip = &rgnSrcRec;
-	REGION_INIT(pscr, prgnSrcClip, &box, 1);
+	RegionInit(prgnSrcClip, &box, 1);
 	pSrcWin = (WindowPtr)NULL;
     }
 
@@ -233,11 +233,11 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	else
 	{
 	    prgnDstClip = &rgnDstRec;
-	    REGION_NULL(pscr, prgnDstClip);
-	    REGION_COPY(pscr, prgnDstClip,
+	    RegionNull(prgnDstClip);
+	    RegionCopy(prgnDstClip,
 				&((WindowPtr)pDstDrawable)->clipList);
 	}
-	REGION_TRANSLATE(pscr, prgnDstClip,
+	RegionTranslate(prgnDstClip,
 				 -pDstDrawable->x, -pDstDrawable->y);
     }
     else
@@ -249,14 +249,14 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	box.x2 = pDstDrawable->width;
 	box.y2 = pDstDrawable->height;
 	prgnDstClip = &rgnDstRec;
-	REGION_INIT(pscr, prgnDstClip, &box, 1);
+	RegionInit(prgnDstClip, &box, 1);
     }
 
     /* drawable-relative source region */
-    REGION_INIT(pscr, &rgnExposed, &srcBox, 1);
+    RegionInit(&rgnExposed, &srcBox, 1);
 
     /* now get the hidden parts of the source box*/
-    REGION_SUBTRACT(pscr, &rgnExposed, &rgnExposed, prgnSrcClip);
+    RegionSubtract(&rgnExposed, &rgnExposed, prgnSrcClip);
 
     if (pSrcWin && pSrcWin->backStorage)
     {
@@ -274,10 +274,10 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
     }
     
     /* move them over the destination */
-    REGION_TRANSLATE(pscr, &rgnExposed, dstx-srcx, dsty-srcy);
+    RegionTranslate(&rgnExposed, dstx-srcx, dsty-srcy);
 
     /* intersect with visible areas of dest */
-    REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, prgnDstClip);
+    RegionIntersect(&rgnExposed, &rgnExposed, prgnDstClip);
 
     /*
      * If we have LOTS of rectangles, we decide to take the extents
@@ -287,7 +287,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
      * for windows.
      */
     extents = pGC->graphicsExposures &&
-	      (REGION_NUM_RECTS(&rgnExposed) > RECTLIMIT) &&
+	      (RegionNumRects(&rgnExposed) > RECTLIMIT) &&
 	      (pDstDrawable->type != DRAWABLE_PIXMAP);
 #ifdef SHAPE
     if (pSrcWin)
@@ -300,7 +300,7 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
      	 * exposed region will undo all our work!
      	 */
     	if (extents && pSrcWin && region &&
-    	    (RECT_IN_REGION(pscr, region, &srcBox) != rgnIN))
+	    (RegionContainsRect(region, &srcBox) != rgnIN))
 	    	extents = FALSE;
     }
 #endif
@@ -308,8 +308,8 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
     {
 	WindowPtr pWin = (WindowPtr)pDstDrawable;
 
-	expBox = *REGION_EXTENTS(pscr, &rgnExposed);
-	REGION_RESET(pscr, &rgnExposed, &expBox);
+	expBox = *RegionExtents(&rgnExposed);
+	RegionReset(&rgnExposed, &expBox);
 	/* need to clear out new areas of backing store */
 	if (pWin->backStorage)
 	    (void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -326,53 +326,53 @@ miHandleExposures(pSrcDrawable, pDstDrawable,
 	WindowPtr pWin = (WindowPtr)pDstDrawable;
 
 	/* make the exposed area screen-relative */
-	REGION_TRANSLATE(pscr, &rgnExposed, 
+	RegionTranslate(&rgnExposed,
 				 pDstDrawable->x, pDstDrawable->y);
 
 	if (extents)
 	{
 	    /* PaintWindowBackground doesn't clip, so we have to */
-	    REGION_INTERSECT(pscr, &rgnExposed, &rgnExposed, &pWin->clipList);
+	    RegionIntersect(&rgnExposed, &rgnExposed, &pWin->clipList);
 	}
 	(*pWin->drawable.pScreen->PaintWindowBackground)(
 			(WindowPtr)pDstDrawable, &rgnExposed, PW_BACKGROUND);
 
 	if (extents)
 	{
-	    REGION_RESET(pscr, &rgnExposed, &expBox);
+	    RegionReset(&rgnExposed, &expBox);
 	}
 	else
-	    REGION_TRANSLATE(pscr, &rgnExposed,
+	    RegionTranslate(&rgnExposed,
 				     -pDstDrawable->x, -pDstDrawable->y);
     }
     if (prgnDstClip == &rgnDstRec)
     {
-	REGION_UNINIT(pscr, prgnDstClip);
+	RegionUninit(prgnDstClip);
     }
     else if (prgnDstClip != prgnSrcClip)
     {
-	REGION_DESTROY(pscr, prgnDstClip);
+	RegionDestroy(prgnDstClip);
     }
 
     if (prgnSrcClip == &rgnSrcRec)
     {
-	REGION_UNINIT(pscr, prgnSrcClip);
+	RegionUninit(prgnSrcClip);
     }
     else
     {
-	REGION_DESTROY(pscr, prgnSrcClip);
+	RegionDestroy(prgnSrcClip);
     }
 
     if (pGC->graphicsExposures)
     {
 	/* don't look */
-	RegionPtr exposed = REGION_CREATE(pscr, NullBox, 0);
+	RegionPtr exposed = RegionCreate(NullBox, 0);
 	*exposed = rgnExposed;
 	return exposed;
     }
     else
     {
-	REGION_UNINIT(pscr, &rgnExposed);
+	RegionUninit(&rgnExposed);
 	return NULL;
     }
 }
@@ -387,7 +387,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
     int	major;
     int	minor;
 {
-    if (pRgn && !REGION_NIL(pRgn))
+    if (pRgn && !RegionNil(pRgn))
     {
         xEvent *pEvent;
 	register xEvent *pe;
@@ -395,8 +395,8 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
 	register int i;
 	int numRects;
 
-	numRects = REGION_NUM_RECTS(pRgn);
-	pBox = REGION_RECTS(pRgn);
+	numRects = RegionNumRects(pRgn);
+	pBox = RegionRects(pRgn);
 	if(!(pEvent = (xEvent *)ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 		return;
 	pe = pEvent;
@@ -442,8 +442,8 @@ miSendExposures(pWin, pRgn, dx, dy)
     register xEvent *pEvent, *pe;
     register int i;
 
-    pBox = REGION_RECTS(pRgn);
-    numRects = REGION_NUM_RECTS(pRgn);
+    pBox = RegionRects(pRgn);
+    numRects = RegionNumRects(pRgn);
     if(!(pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 	return;
     memset(pEvent, 0, numRects * sizeof(xEvent));
@@ -513,8 +513,8 @@ miWindowExposures(pWin, prgn, other_exposed)
 	 * no areas will be repainted.
 	 */
 	exposures = (*pWin->drawable.pScreen->RestoreAreas)(pWin, prgn);
-    if ((prgn && !REGION_NIL(prgn)) || 
-	(exposures && !REGION_NIL(exposures)) || other_exposed)
+    if ((prgn && !RegionNil(prgn)) || 
+	(exposures && !RegionNil(exposures)) || other_exposed)
     {
 	RegionRec   expRec;
 	int	    clientInterested;
@@ -527,15 +527,15 @@ miWindowExposures(pWin, prgn, other_exposed)
 	{
 	    if (exposures)
 	    {
-		REGION_UNION(pWin->drawable.pScreen, other_exposed,
+		RegionUnion(other_exposed,
 						  exposures,
 					          other_exposed);
 		if (exposures != prgn)
-		    REGION_DESTROY(pWin->drawable.pScreen, exposures);
+		    RegionDestroy(exposures);
 	    }
 	    exposures = other_exposed;
 	}
-	if (clientInterested && exposures && (REGION_NUM_RECTS(exposures) > RECTLIMIT))
+	if (clientInterested && exposures && (RegionNumRects(exposures) > RECTLIMIT))
 	{
 	    /*
 	     * If we have LOTS of rectangles, we decide to take the extents
@@ -545,17 +545,17 @@ miWindowExposures(pWin, prgn, other_exposed)
 	     */
 	    BoxRec box;
 
-	    box = *REGION_EXTENTS( pWin->drawable.pScreen, exposures);
+	    box = *RegionExtents(exposures);
 	    if (exposures == prgn) {
 		exposures = &expRec;
-		REGION_INIT( pWin->drawable.pScreen, exposures, &box, 1);
-		REGION_RESET( pWin->drawable.pScreen, prgn, &box);
+		RegionInit(exposures, &box, 1);
+		RegionReset(prgn, &box);
 	    } else {
-		REGION_RESET( pWin->drawable.pScreen, exposures, &box);
-		REGION_UNION( pWin->drawable.pScreen, prgn, prgn, exposures);
+		RegionReset(exposures, &box);
+		RegionUnion(prgn, prgn, exposures);
 	    }
 	    /* PaintWindowBackground doesn't clip, so we have to */
-	    REGION_INTERSECT( pWin->drawable.pScreen, prgn, prgn, &pWin->clipList);
+	    RegionIntersect(prgn, prgn, &pWin->clipList);
 	    /* need to clear out new areas of backing store, too */
 	    if (pWin->backStorage)
 		(void) (* pWin->drawable.pScreen->ClearBackingStore)(
@@ -566,22 +566,22 @@ miWindowExposures(pWin, prgn, other_exposed)
 					     box.y2 - box.y1,
 					     FALSE);
 	}
-	if (prgn && !REGION_NIL(prgn))
+	if (prgn && !RegionNil(prgn))
 	    (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, prgn, PW_BACKGROUND);
-	if (clientInterested && exposures && !REGION_NIL(exposures))
+	if (clientInterested && exposures && !RegionNil(exposures))
 	    miSendExposures(pWin, exposures,
 			    pWin->drawable.x, pWin->drawable.y);
 	if (exposures == &expRec)
 	{
-	    REGION_UNINIT( pWin->drawable.pScreen, exposures);
+	    RegionUninit(exposures);
 	}
 	else if (exposures && exposures != prgn && exposures != other_exposed)
-	    REGION_DESTROY( pWin->drawable.pScreen, exposures);
+	    RegionDestroy(exposures);
 	if (prgn)
-	    REGION_EMPTY( pWin->drawable.pScreen, prgn);
+	    RegionEmpty(prgn);
     }
     else if (exposures && exposures != prgn)
-	REGION_DESTROY( pWin->drawable.pScreen, exposures);
+	RegionDestroy(exposures);
 }
 
 
@@ -706,7 +706,7 @@ int what;
 	}
     }
 
-    prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
+    prect = (xRectangle *)ALLOCATE_LOCAL(RegionNumRects(prgn) *
 					 sizeof(xRectangle));
     if (!prect)
 	return;
@@ -749,7 +749,7 @@ int what;
 	    box.y1 = 0;
 	    box.x2 = pScreen->width;
 	    box.y2 = pScreen->height;
-	    REGION_INIT(pScreen, &pWin->clipList, &box, 1);
+	    RegionInit(&pWin->clipList, &box, 1);
 	    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    newValues[ABSX].val = pBgWin->drawable.x;
 	    newValues[ABSY].val = pBgWin->drawable.y;
@@ -852,8 +852,8 @@ int what;
     if (pWin->drawable.serialNumber != pGC->serialNumber)
 	ValidateGC((DrawablePtr)pWin, pGC);
 
-    numRects = REGION_NUM_RECTS(prgn);
-    pbox = REGION_RECTS(prgn);
+    numRects = RegionNumRects(prgn);
+    pbox = RegionRects(prgn);
     for (i= numRects; --i >= 0; pbox++, prect++)
     {
 	prect->x = pbox->x1 - pWin->drawable.x;
@@ -872,7 +872,7 @@ int what;
     {
 	if (what == PW_BORDER)
 	{
-	    REGION_UNINIT(pScreen, &pWin->clipList);
+	    RegionUninit(&pWin->clipList);
 	    pWin->clipList = prgnWin;
 	    pWin->drawable.x = oldCorner.x;
 	    pWin->drawable.y = oldCorner.y;
diff --git a/nx-X11/programs/Xserver/mi/migc.c b/nx-X11/programs/Xserver/mi/migc.c
index 2b38b257d..167163686 100644
--- a/nx-X11/programs/Xserver/mi/migc.c
+++ b/nx-X11/programs/Xserver/mi/migc.c
@@ -33,6 +33,7 @@ from The Open Group.
 #include <dix-config.h>
 #endif
 
+#include "regionstr.h"
 #include "scrnintstr.h"
 #include "gcstruct.h"
 #include "pixmapstr.h"
@@ -55,7 +56,7 @@ miDestroyGC(pGC)
     if (pGC->pRotatedPixmap)
 	(*pGC->pScreen->DestroyPixmap) (pGC->pRotatedPixmap);
     if (pGC->freeCompClip)
-	REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
+	RegionDestroy(pGC->pCompositeClip);
     miDestroyGCOps(pGC->ops);
 }
 
@@ -104,7 +105,7 @@ miDestroyClip(pGC)
 	 * we know we'll never have a list of rectangles, since ChangeClip
 	 * immediately turns them into a region
 	 */
-	REGION_DESTROY(pGC->pScreen, pGC->clientClip);
+	RegionDestroy(pGC->clientClip);
     }
     pGC->clientClip = NULL;
     pGC->clientClipType = CT_NONE;
@@ -121,7 +122,7 @@ miChangeClip(pGC, type, pvalue, nrects)
     if (type == CT_PIXMAP)
     {
 	/* convert the pixmap to a region */
-	pGC->clientClip = (void *) BITMAP_TO_REGION(pGC->pScreen,
+	pGC->clientClip = (void *) BitmapToRegion(pGC->pScreen,
 							(PixmapPtr) pvalue);
 	(*pGC->pScreen->DestroyPixmap) (pvalue);
     }
@@ -132,7 +133,7 @@ miChangeClip(pGC, type, pvalue, nrects)
     }
     else if (type != CT_NONE)
     {
-	pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nrects,
+	pGC->clientClip = (void *) RegionFromRects(nrects,
 						      (xRectangle *) pvalue,
 								    type);
 	xfree(pvalue);
@@ -157,8 +158,8 @@ miCopyClip(pgcDst, pgcSrc)
 				   pgcSrc->clientClip, 0);
 	break;
       case CT_REGION:
-	prgnNew = REGION_CREATE(pgcSrc->pScreen, NULL, 1);
-	REGION_COPY(pgcDst->pScreen, prgnNew,
+	prgnNew = RegionCreate(NULL, 1);
+	RegionCopy(prgnNew,
 					(RegionPtr) (pgcSrc->clientClip));
 	(*pgcDst->funcs->ChangeClip) (pgcDst, CT_REGION, (void *) prgnNew, 0);
 	break;
@@ -213,7 +214,7 @@ miComputeCompositeClip(pGC, pDrawable)
 	if (pGC->clientClipType == CT_NONE)
 	{
 	    if (freeCompClip)
-		REGION_DESTROY(pScreen, pGC->pCompositeClip);
+		RegionDestroy(pGC->pCompositeClip);
 	    pGC->pCompositeClip = pregWin;
 	    pGC->freeCompClip = freeTmpClip;
 	}
@@ -228,30 +229,30 @@ miComputeCompositeClip(pGC, pDrawable)
 	     * clip. if neither is real, create a new region.
 	     */
 
-	    REGION_TRANSLATE(pScreen, pGC->clientClip,
+	    RegionTranslate(pGC->clientClip,
 					 pDrawable->x + pGC->clipOrg.x,
 					 pDrawable->y + pGC->clipOrg.y);
 
 	    if (freeCompClip)
 	    {
-		REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
+		RegionIntersect(pGC->pCompositeClip,
 					    pregWin, pGC->clientClip);
 		if (freeTmpClip)
-		    REGION_DESTROY(pScreen, pregWin);
+		    RegionDestroy(pregWin);
 	    }
 	    else if (freeTmpClip)
 	    {
-		REGION_INTERSECT(pScreen, pregWin, pregWin, pGC->clientClip);
+		RegionIntersect(pregWin, pregWin, pGC->clientClip);
 		pGC->pCompositeClip = pregWin;
 	    }
 	    else
 	    {
-		pGC->pCompositeClip = REGION_CREATE(pScreen, NullBox, 0);
-		REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+		pGC->pCompositeClip = RegionCreate(NullBox, 0);
+		RegionIntersect(pGC->pCompositeClip,
 				       pregWin, pGC->clientClip);
 	    }
 	    pGC->freeCompClip = TRUE;
-	    REGION_TRANSLATE(pScreen, pGC->clientClip,
+	    RegionTranslate(pGC->clientClip,
 					 -(pDrawable->x + pGC->clipOrg.x),
 					 -(pDrawable->y + pGC->clipOrg.y));
 	}
@@ -269,31 +270,31 @@ miComputeCompositeClip(pGC, pDrawable)
 
 	if (pGC->freeCompClip)
 	{
-	    REGION_RESET(pScreen, pGC->pCompositeClip, &pixbounds);
+	    RegionReset(pGC->pCompositeClip, &pixbounds);
 	}
 	else
 	{
 	    pGC->freeCompClip = TRUE;
-	    pGC->pCompositeClip = REGION_CREATE(pScreen, &pixbounds, 1);
+	    pGC->pCompositeClip = RegionCreate(&pixbounds, 1);
 	}
 
 	if (pGC->clientClipType == CT_REGION)
 	{
 	    if(pDrawable->x || pDrawable->y) {
-	        REGION_TRANSLATE(pScreen, pGC->clientClip,
+	        RegionTranslate(pGC->clientClip,
 					  pDrawable->x + pGC->clipOrg.x, 
 					  pDrawable->y + pGC->clipOrg.y);
-	        REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+	        RegionIntersect(pGC->pCompositeClip,
 				pGC->pCompositeClip, pGC->clientClip);
-	        REGION_TRANSLATE(pScreen, pGC->clientClip,
+	        RegionTranslate(pGC->clientClip,
 					  -(pDrawable->x + pGC->clipOrg.x), 
 					  -(pDrawable->y + pGC->clipOrg.y));
 	    } else {
-	        REGION_TRANSLATE(pScreen, pGC->pCompositeClip,
+	        RegionTranslate(pGC->pCompositeClip,
 					 -pGC->clipOrg.x, -pGC->clipOrg.y);
-	        REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+	        RegionIntersect(pGC->pCompositeClip,
 				pGC->pCompositeClip, pGC->clientClip);
-	        REGION_TRANSLATE(pScreen, pGC->pCompositeClip,
+	        RegionTranslate(pGC->pCompositeClip,
 					 pGC->clipOrg.x, pGC->clipOrg.y);
 	    }
 	}
diff --git a/nx-X11/programs/Xserver/mi/mioverlay.c b/nx-X11/programs/Xserver/mi/mioverlay.c
index f67704e11..96d5cc4f0 100644
--- a/nx-X11/programs/Xserver/mi/mioverlay.c
+++ b/nx-X11/programs/Xserver/mi/mioverlay.c
@@ -212,8 +212,8 @@ miOverlayCreateWindow(WindowPtr pWin)
 	    pTree->visibility = VisibilityNotViewable;
 	    pWinPriv->tree = pTree;
 	    if(pWin->parent) {
-		REGION_NULL(pScreen, &(pTree->borderClip));
-		REGION_NULL(pScreen, &(pTree->clipList));
+		RegionNull(&(pTree->borderClip));
+		RegionNull(&(pTree->clipList));
 		RebuildTree(pWin);
 	    } else {
 		BoxRec fullBox;
@@ -221,8 +221,8 @@ miOverlayCreateWindow(WindowPtr pWin)
 		fullBox.y1 = 0;
 		fullBox.x2 = pScreen->width;
 		fullBox.y2 = pScreen->height;
-		REGION_INIT(pScreen, &(pTree->borderClip), &fullBox, 1);
-		REGION_INIT(pScreen, &(pTree->clipList), &fullBox, 1);
+		RegionInit(&(pTree->borderClip), &fullBox, 1);
+		RegionInit(&(pTree->clipList), &fullBox, 1);
 	    }
 	} else xfree(pTree);
     }
@@ -250,8 +250,8 @@ miOverlayDestroyWindow(WindowPtr pWin)
 	else if(pTree->parent)
 	   pTree->parent->lastChild = pTree->prevSib;
 
-	REGION_UNINIT(pScreen, &(pTree->borderClip));
-	REGION_UNINIT(pScreen, &(pTree->clipList));
+	RegionUninit(&(pTree->borderClip));
+	RegionUninit(&(pTree->clipList));
 	xfree(pTree);
     }
 
@@ -349,7 +349,7 @@ miOverlayMarkOverlappedWindows(
 
     doUnderlay = (IN_UNDERLAY(pWin) || HasUnderlayChildren(pWin));
 
-    box = REGION_EXTENTS(pScreen, &pWin->borderSize);
+    box = RegionExtents(&pWin->borderSize);
 
     if((pChild = pFirst)) {
 	pLast = pChild->parent->lastChild;
@@ -360,13 +360,13 @@ miOverlayMarkOverlappedWindows(
 		pTree = MIOVERLAY_GET_WINDOW_TREE(pChild);
 
 	    if(pChild->viewable) {
-                if (REGION_BROKEN (pScreen, &pChild->winSize))
+                if (RegionBroken(&pChild->winSize))
                     SetWinSize (pChild);
-                if (REGION_BROKEN (pScreen, &pChild->borderSize))
+                if (RegionBroken(&pChild->borderSize))
 		    SetBorderSize (pChild);
 
 	    	if (markAll || 
-		    RECT_IN_REGION(pScreen, &pChild->borderSize, box))
+		    RegionContainsRect(&pChild->borderSize, box))
 		{
 		    MARK_OVERLAY(pChild);
 		    overMarked = TRUE;
@@ -421,12 +421,12 @@ miOverlayMarkOverlappedWindows(
 
 	while(1) {
 	    if(tChild->pWin->viewable) { 
-                if (REGION_BROKEN (pScreen, &tChild->pWin->winSize))
+                if (RegionBroken(&tChild->pWin->winSize))
                     SetWinSize (tChild->pWin);
-                if (REGION_BROKEN (pScreen, &tChild->pWin->borderSize))
+                if (RegionBroken(&tChild->pWin->borderSize))
 		    SetBorderSize (tChild->pWin);
 
-		if(RECT_IN_REGION(pScreen, &(tChild->pWin->borderSize), box)) 
+		if(RegionContainsRect(&(tChild->pWin->borderSize), box))
 	        {
 		    MARK_UNDERLAY(tChild->pWin);
 		    underMarked = TRUE;
@@ -484,7 +484,7 @@ miOverlayComputeClips(
     borderSize.y2 = dy;
   
     oldVis = tParent->visibility;
-    switch (RECT_IN_REGION( pScreen, universe, &borderSize)) {
+    switch (RegionContainsRect(universe, &borderSize)) {
 	case rgnIN:
 	    newVis = VisibilityUnobscured;
 	    break;
@@ -534,8 +534,8 @@ miOverlayComputeClips(
 	    while (1) {
 		if (tChild->pWin->viewable) {
 		    if (tChild->visibility != VisibilityFullyObscured) {
-			REGION_TRANSLATE( pScreen, &tChild->borderClip, dx, dy);
-			REGION_TRANSLATE( pScreen, &tChild->clipList, dx, dy);
+			RegionTranslate(&tChild->borderClip, dx, dy);
+			RegionTranslate(&tChild->clipList, dx, dy);
 		
 			tChild->pWin->drawable.serialNumber = 
 							 NEXT_SERIAL_NUMBER;
@@ -543,14 +543,14 @@ miOverlayComputeClips(
                             (* pScreen->ClipNotify) (tChild->pWin, dx, dy);
 		    }
 		    if (tChild->valdata) {
-			REGION_NULL(pScreen, &tChild->valdata->borderExposed);
+			RegionNull(&tChild->valdata->borderExposed);
 			if (HasParentRelativeBorder(tChild->pWin)){
-			    REGION_SUBTRACT(pScreen,
+			    RegionSubtract(
 					 &tChild->valdata->borderExposed,
 					 &tChild->borderClip,
 					 &tChild->pWin->winSize);
 			}
-			REGION_NULL(pScreen, &tChild->valdata->exposed);
+			RegionNull(&tChild->valdata->exposed);
 		    }
 		    if (tChild->firstChild) {
 			tChild = tChild->firstChild;
@@ -568,50 +568,50 @@ miOverlayComputeClips(
 	/* fall through */
     default:
     	if (dx || dy)  {
-	    REGION_TRANSLATE( pScreen, &tParent->borderClip, dx, dy);
-	    REGION_TRANSLATE( pScreen, &tParent->clipList, dx, dy);
+	    RegionTranslate(&tParent->borderClip, dx, dy);
+	    RegionTranslate(&tParent->clipList, dx, dy);
     	} 
 	break;
     case VTBroken:
-	REGION_EMPTY (pScreen, &tParent->borderClip);
-	REGION_EMPTY (pScreen, &tParent->clipList);
+	RegionEmpty(&tParent->borderClip);
+	RegionEmpty(&tParent->clipList);
 	break;
     }
 
     borderVisible = tParent->valdata->borderVisible;
-    REGION_NULL(pScreen, &tParent->valdata->borderExposed);
-    REGION_NULL(pScreen, &tParent->valdata->exposed);
+    RegionNull(&tParent->valdata->borderExposed);
+    RegionNull(&tParent->valdata->exposed);
 
     if (HasBorder (pParent)) {
     	if (borderVisible) {
-	    REGION_SUBTRACT( pScreen, exposed, universe, borderVisible);
-	    REGION_DESTROY( pScreen, borderVisible);
+	    RegionSubtract(exposed, universe, borderVisible);
+	    RegionDestroy(borderVisible);
     	} else
-	    REGION_SUBTRACT( pScreen, exposed, universe, &tParent->borderClip);
+	    RegionSubtract(exposed, universe, &tParent->borderClip);
 
 	if (HasParentRelativeBorder(pParent) && (dx || dy))
-	    REGION_SUBTRACT( pScreen, &tParent->valdata->borderExposed,
+	    RegionSubtract(&tParent->valdata->borderExposed,
 				  universe, &pParent->winSize);
 	else
-	    REGION_SUBTRACT( pScreen, &tParent->valdata->borderExposed,
+	    RegionSubtract(&tParent->valdata->borderExposed,
 			       exposed, &pParent->winSize);
 
-    	REGION_COPY( pScreen, &tParent->borderClip, universe);    
-    	REGION_INTERSECT( pScreen, universe, universe, &pParent->winSize);
+	RegionCopy(&tParent->borderClip, universe);
+	RegionIntersect(universe, universe, &pParent->winSize);
     }
     else
-    	REGION_COPY( pScreen, &tParent->borderClip, universe);
+	RegionCopy(&tParent->borderClip, universe);
 
     if ((tChild = tParent->firstChild) && pParent->mapped) {
-	REGION_NULL(pScreen, &childUniverse);
-	REGION_NULL(pScreen, &childUnion);
+	RegionNull(&childUniverse);
+	RegionNull(&childUnion);
 
 	for (; tChild; tChild = tChild->nextSib) {
 	    if (tChild->pWin->viewable)
-		REGION_APPEND( pScreen, &childUnion, &tChild->pWin->borderSize);
+		RegionAppend(&childUnion, &tChild->pWin->borderSize);
 	}
 
-	REGION_VALIDATE( pScreen, &childUnion, &overlap);
+	RegionValidate(&childUnion, &overlap);
 
 	for (tChild = tParent->firstChild;
 	     tChild;
@@ -619,31 +619,31 @@ miOverlayComputeClips(
  	{
 	    if (tChild->pWin->viewable) {
 		if (tChild->valdata) {
-		    REGION_INTERSECT( pScreen, &childUniverse, universe,
+		    RegionIntersect(&childUniverse, universe,
 					    &tChild->pWin->borderSize);
 		    miOverlayComputeClips (tChild->pWin, &childUniverse, 
 						kind, exposed);
 		}
 		if (overlap)
-		    REGION_SUBTRACT( pScreen, universe, universe,
+		    RegionSubtract(universe, universe,
 					  &tChild->pWin->borderSize);
 	    }
 	}
 	if (!overlap)
-	    REGION_SUBTRACT( pScreen, universe, universe, &childUnion);
-	REGION_UNINIT( pScreen, &childUnion);
-	REGION_UNINIT( pScreen, &childUniverse);
+	    RegionSubtract(universe, universe, &childUnion);
+	RegionUninit(&childUnion);
+	RegionUninit(&childUniverse);
     } 
 
     if (oldVis == VisibilityFullyObscured ||
 	oldVis == VisibilityNotViewable)
     {
-	REGION_COPY( pScreen, &tParent->valdata->exposed, universe);
+	RegionCopy(&tParent->valdata->exposed, universe);
     }
     else if (newVis != VisibilityFullyObscured &&
 	     newVis != VisibilityNotViewable)
     {
-    	REGION_SUBTRACT( pScreen, &tParent->valdata->exposed,
+	RegionSubtract(&tParent->valdata->exposed,
 			       universe, &tParent->clipList);
     }
     
@@ -721,14 +721,14 @@ miOverlayMarkUnrealizedWindow(
     if ((pChild != pWin) || fromConfigure) {
 	miOverlayTreePtr pTree;
 
-        REGION_EMPTY(pChild->drawable.pScreen, &pChild->clipList);
+        RegionEmpty(&pChild->clipList);
         if (pChild->drawable.pScreen->ClipNotify)
             (* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0);
-        REGION_EMPTY(pChild->drawable.pScreen, &pChild->borderClip);
+        RegionEmpty(&pChild->borderClip);
 	if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
 	    if(pTree->valdata != (miOverlayValDataPtr)UnmapValData) {
-		REGION_EMPTY(pChild->drawable.pScreen, &pTree->clipList);
-		REGION_EMPTY(pChild->drawable.pScreen, &pTree->borderClip);
+		RegionEmpty(&pTree->clipList);
+		RegionEmpty(&pTree->borderClip);
 	    }
 	}
     }
@@ -753,9 +753,9 @@ miOverlayValidateTree(
 
     if (!pChild) pChild = pParent->firstChild;
 
-    REGION_NULL(pScreen, &totalClip);
-    REGION_NULL(pScreen, &childClip);
-    REGION_NULL(pScreen, &exposed);
+    RegionNull(&totalClip);
+    RegionNull(&childClip);
+    RegionNull(&exposed);
 
     newParent = pParent;
 
@@ -769,52 +769,52 @@ miOverlayValidateTree(
     else
 	tChild = tParent->firstChild;
 
-    if (REGION_BROKEN (pScreen, &tParent->clipList) &&
-        !REGION_BROKEN (pScreen, &tParent->borderClip))
+    if (RegionBroken(&tParent->clipList) &&
+        !RegionBroken(&tParent->borderClip))
     {
 	kind = VTBroken;
-	REGION_COPY (pScreen, &totalClip, &tParent->borderClip);
-	REGION_INTERSECT (pScreen, &totalClip, &totalClip,
+	RegionCopy(&totalClip, &tParent->borderClip);
+	RegionIntersect(&totalClip, &totalClip,
 						 &tParent->pWin->winSize);
         
         for (tWin = tParent->firstChild; tWin != tChild; tWin = tWin->nextSib) {
             if (tWin->pWin->viewable)
-                REGION_SUBTRACT (pScreen, &totalClip, &totalClip, 
+                RegionSubtract(&totalClip, &totalClip,
 					&tWin->pWin->borderSize);
         }        
-        REGION_EMPTY (pScreen, &tParent->clipList);
+        RegionEmpty(&tParent->clipList);
     } else {
 	for(tWin = tChild; tWin; tWin = tWin->nextSib) {
 	    if(tWin->valdata)
-		REGION_APPEND(pScreen, &totalClip, &tWin->borderClip);
+		RegionAppend(&totalClip, &tWin->borderClip);
 	}
-	REGION_VALIDATE(pScreen, &totalClip, &overlap);
+	RegionValidate(&totalClip, &overlap);
     }
 
     if(kind != VTStack)
-	REGION_UNION(pScreen, &totalClip, &totalClip, &tParent->clipList);
+	RegionUnion(&totalClip, &totalClip, &tParent->clipList);
 	
     for(tWin = tChild; tWin; tWin = tWin->nextSib) {
 	if(tWin->valdata) {
 	    if(tWin->pWin->viewable) {
-		REGION_INTERSECT(pScreen, &childClip, &totalClip,
+		RegionIntersect(&childClip, &totalClip,
 					&tWin->pWin->borderSize);
 		miOverlayComputeClips(tWin->pWin, &childClip, kind, &exposed);
-		REGION_SUBTRACT(pScreen, &totalClip, &totalClip,
+		RegionSubtract(&totalClip, &totalClip,
 					&tWin->pWin->borderSize);
 	    } else {  /* Means we are unmapping */
-                REGION_EMPTY(pScreen, &tWin->clipList);
-                REGION_EMPTY( pScreen, &tWin->borderClip);
+                RegionEmpty(&tWin->clipList);
+                RegionEmpty(&tWin->borderClip);
 		tWin->valdata = NULL;
 	    }
 	}
     }
 
-    REGION_UNINIT(pScreen, &childClip);
+    RegionUninit(&childClip);
 
     if(!((*pPriv->InOverlay)(newParent))) {
-	REGION_NULL(pScreen, &tParent->valdata->exposed);
-	REGION_NULL(pScreen, &tParent->valdata->borderExposed);
+	RegionNull(&tParent->valdata->exposed);
+	RegionNull(&tParent->valdata->borderExposed);
     }
 
     switch (kind) {
@@ -822,18 +822,18 @@ miOverlayValidateTree(
 	break;
     default:
     	if(!((*pPriv->InOverlay)(newParent))) 
-	    REGION_SUBTRACT(pScreen, &tParent->valdata->exposed, &totalClip, 
+	    RegionSubtract(&tParent->valdata->exposed, &totalClip,
 						&tParent->clipList);
 	/* fall through */
     case VTMap:
-	REGION_COPY( pScreen, &tParent->clipList, &totalClip);
+	RegionCopy(&tParent->clipList, &totalClip);
     	if(!((*pPriv->InOverlay)(newParent))) 
 	    newParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	break;
     }
 
-    REGION_UNINIT( pScreen, &totalClip);
-    REGION_UNINIT( pScreen, &exposed);
+    RegionUninit(&totalClip);
+    RegionUninit(&exposed);
 
 SKIP_UNDERLAY:
 
@@ -866,13 +866,13 @@ miOverlayHandleExposures(WindowPtr pWin)
 	while (1) {
 	    if((mival = pTree->valdata)) {
 		if(!((*pPriv->InOverlay)(pTree->pWin))) {
-		    if (REGION_NOTEMPTY(pScreen, &mival->borderExposed))
+		    if (RegionNotEmpty(&mival->borderExposed))
 			(*pWin->drawable.pScreen->PaintWindowBorder)(
 				pTree->pWin, &mival->borderExposed, PW_BORDER);
-		    REGION_UNINIT(pScreen, &mival->borderExposed);
+		    RegionUninit(&mival->borderExposed);
 
 		    (*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion);
-		    REGION_UNINIT(pScreen, &mival->exposed);
+		    RegionUninit(&mival->exposed);
 		}
 		xfree(mival);
 		pTree->valdata = NULL;
@@ -894,24 +894,24 @@ miOverlayHandleExposures(WindowPtr pWin)
     while (1) {
 	if ( (val = pChild->valdata) ) {
 	    if(!((*pPriv->InOverlay)(pChild))) {
-		REGION_UNION(pScreen, &val->after.exposed, &val->after.exposed,
+		RegionUnion(&val->after.exposed, &val->after.exposed,
 			&val->after.borderExposed);
 
-		if (REGION_NOTEMPTY(pScreen, &val->after.exposed)) {
+		if (RegionNotEmpty(&val->after.exposed)) {
 		   (*(MIOVERLAY_GET_SCREEN_PRIVATE(pScreen)->MakeTransparent))(
 				pScreen, 
-				REGION_NUM_RECTS(&val->after.exposed),
-				REGION_RECTS(&val->after.exposed));
+				RegionNumRects(&val->after.exposed),
+				RegionRects(&val->after.exposed));
 		}
 	    } else {
-		if (REGION_NOTEMPTY(pScreen, &val->after.borderExposed))
+		if (RegionNotEmpty(&val->after.borderExposed))
 		    (*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
 						    &val->after.borderExposed,
 						    PW_BORDER);
 		(*WindowExposures)(pChild, &val->after.exposed, NullRegion);
 	    }
-	    REGION_UNINIT(pScreen, &val->after.borderExposed);
-	    REGION_UNINIT(pScreen, &val->after.exposed);
+	    RegionUninit(&val->after.borderExposed);
+	    RegionUninit(&val->after.exposed);
 	    xfree(val);
 	    pChild->valdata = (ValidatePtr)NULL;
 	    if (pChild->firstChild)
@@ -955,13 +955,13 @@ miOverlayMoveWindow(
     oldpt.x = pWin->drawable.x;
     oldpt.y = pWin->drawable.y;
     if (WasViewable) {
-	REGION_NULL(pScreen, &overReg);
-	REGION_NULL(pScreen, &underReg);
+	RegionNull(&overReg);
+	RegionNull(&underReg);
 	if(pTree) {
-	    REGION_COPY(pScreen, &overReg, &pWin->borderClip);
-	    REGION_COPY(pScreen, &underReg, &pTree->borderClip);
+	    RegionCopy(&overReg, &pWin->borderClip);
+	    RegionCopy(&underReg, &pTree->borderClip);
         } else {
-	    REGION_COPY(pScreen, &overReg, &pWin->borderClip);
+	    RegionCopy(&overReg, &pWin->borderClip);
 	    CollectUnderlayChildrenRegions(pWin, &underReg);
 	}
 	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
@@ -990,16 +990,16 @@ miOverlayMoveWindow(
 #endif /* DO_SAVE_UNDERS */
 
 	(*pScreen->ValidateTree)(pWin->parent, NullWindow, kind);
-	if(REGION_NOTEMPTY(pScreen, &underReg)) {
+	if(RegionNotEmpty(&underReg)) {
 	    pPriv->copyUnderlay = TRUE;
 	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &underReg);
 	}
-	REGION_UNINIT(pScreen, &underReg);
-	if(REGION_NOTEMPTY(pScreen, &overReg)) {
+	RegionUninit(&underReg);
+	if(RegionNotEmpty(&overReg)) {
 	    pPriv->copyUnderlay = FALSE;
 	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, &overReg);
 	}
-	REGION_UNINIT(pScreen, &overReg);
+	RegionUninit(&overReg);
 	(*pScreen->HandleExposures)(pWin->parent);
 
 #ifdef DO_SAVE_UNDERS
@@ -1028,8 +1028,8 @@ miOverlayWindowExposures(
 
     if (pWin->backStorage && prgn)
 	exposures = (*pScreen->RestoreAreas)(pWin, prgn);
-    if ((prgn && !REGION_NIL(prgn)) || 
-	(exposures && !REGION_NIL(exposures)) || other_exposed)
+    if ((prgn && !RegionNil(prgn)) || 
+	(exposures && !RegionNil(exposures)) || other_exposed)
     {
 	RegionRec   expRec;
 	int	    clientInterested;
@@ -1038,35 +1038,35 @@ miOverlayWindowExposures(
 		 	    ExposureMask;
 	if (other_exposed) {
 	    if (exposures) {
-		REGION_UNION(pScreen, other_exposed, exposures, other_exposed);
+		RegionUnion(other_exposed, exposures, other_exposed);
 		if (exposures != prgn)
-		    REGION_DESTROY(pScreen, exposures);
+		    RegionDestroy(exposures);
 	    }
 	    exposures = other_exposed;
 	}
 	if (clientInterested && exposures && 
-	   (REGION_NUM_RECTS(exposures) > RECTLIMIT))
+	   (RegionNumRects(exposures) > RECTLIMIT))
 	{
             miOverlayScreenPtr pPriv = MIOVERLAY_GET_SCREEN_PRIVATE(pScreen);
 	    BoxRec box;
 
-	    box = *REGION_EXTENTS(pScreen, exposures);
+	    box = *RegionExtents(exposures);
 	    if (exposures == prgn) {
 		exposures = &expRec;
-		REGION_INIT(pScreen, exposures, &box, 1);
-		REGION_RESET(pScreen, prgn, &box);
+		RegionInit(exposures, &box, 1);
+		RegionReset(prgn, &box);
 	    } else {
-		REGION_RESET(pScreen, exposures, &box);
-		REGION_UNION(pScreen, prgn, prgn, exposures);
+		RegionReset(exposures, &box);
+		RegionUnion(prgn, prgn, exposures);
 	    }
 	    /* This is the only reason why we are replacing mi's version
                of this file */
 	    
 	    if(!((*pPriv->InOverlay)(pWin))) {
 		miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
-		REGION_INTERSECT(pScreen, prgn, prgn, &pTree->clipList);
+		RegionIntersect(prgn, prgn, &pTree->clipList);
 	    } else
-		REGION_INTERSECT(pScreen, prgn, prgn, &pWin->clipList);
+		RegionIntersect(prgn, prgn, &pWin->clipList);
 
 	    /* need to clear out new areas of backing store, too */
 	    if (pWin->backStorage)
@@ -1078,22 +1078,22 @@ miOverlayWindowExposures(
 					     box.y2 - box.y1,
 					     FALSE);
 	}
-	if (prgn && !REGION_NIL(prgn))
+	if (prgn && !RegionNil(prgn))
 	    (*pScreen->PaintWindowBackground)(
 			pWin, prgn, PW_BACKGROUND);
-	if (clientInterested && exposures && !REGION_NIL(exposures))
+	if (clientInterested && exposures && !RegionNil(exposures))
 	    miSendExposures(pWin, exposures,
 			    pWin->drawable.x, pWin->drawable.y);
 	if (exposures == &expRec) {
-	    REGION_UNINIT(pScreen, exposures);
+	    RegionUninit(exposures);
 	} 
 	else if (exposures && exposures != prgn && exposures != other_exposed)
-	    REGION_DESTROY(pScreen, exposures);
+	    RegionDestroy(exposures);
 	if (prgn)
-	    REGION_EMPTY(pScreen, prgn);
+	    RegionEmpty(prgn);
     }
     else if (exposures && exposures != prgn)
-	REGION_DESTROY(pScreen, exposures);
+	RegionDestroy(exposures);
 }
 
 
@@ -1118,23 +1118,23 @@ miOverlayRecomputeExposures (
 	/*
 	 * compute exposed regions of this window
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+	RegionSubtract(&pWin->valdata->after.exposed,
 			&pWin->clipList, pValid->over);
 	/*
 	 * compute exposed regions of the border
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->borderClip, &pWin->winSize);
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->valdata->after.borderExposed, pValid->over);
     } 
 
     if(pTree && pTree->valdata) {
-	REGION_SUBTRACT(pScreen, &pTree->valdata->exposed,
+	RegionSubtract(&pTree->valdata->exposed,
 			&pTree->clipList, pValid->under);
-	REGION_SUBTRACT(pScreen, &pTree->valdata->borderExposed,
+	RegionSubtract(&pTree->valdata->borderExposed,
 			     &pTree->borderClip, &pWin->winSize);
-	REGION_SUBTRACT(pScreen, &pTree->valdata->borderExposed,
+	RegionSubtract(&pTree->valdata->borderExposed,
 			     &pTree->valdata->borderExposed, pValid->under);    
     } else if (!pWin->valdata)
 	return WT_NOMATCH;
@@ -1194,11 +1194,11 @@ miOverlayResizeWindow(
 	/*
 	 * save the visible region of the window
 	 */
-	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
-	REGION_COPY(pScreen, oldRegion, &pWin->winSize);
+	oldRegion = RegionCreate(NullBox, 1);
+	RegionCopy(oldRegion, &pWin->winSize);
 	if(doUnderlay) {
-	    oldRegion2 = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, oldRegion2, &pWin->winSize);
+	    oldRegion2 = RegionCreate(NullBox, 1);
+	    RegionCopy(oldRegion2, &pWin->winSize);
 	}
 
 	/*
@@ -1210,16 +1210,16 @@ miOverlayResizeWindow(
 	    g = pChild->winGravity;
 	    if (g != UnmapGravity) {
 		if (!gravitate[g])
-		    gravitate[g] = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_UNION(pScreen, gravitate[g],
+		    gravitate[g] = RegionCreate(NullBox, 1);
+		RegionUnion(gravitate[g],
 				   gravitate[g], &pChild->borderClip);
 		
 		if(doUnderlay) {
 		    if (!gravitate2[g])
-			gravitate2[g] = REGION_CREATE(pScreen, NullBox, 0);
+			gravitate2[g] = RegionCreate(NullBox, 0);
 		
 		    if((tChild = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
-		        REGION_UNION(pScreen, gravitate2[g],
+		        RegionUnion(gravitate2[g],
 				   gravitate2[g], &tChild->borderClip);
 		    } else 
 			CollectUnderlayChildrenRegions(pChild, gravitate2[g]);
@@ -1233,11 +1233,11 @@ miOverlayResizeWindow(
 
 	oldWinClip = oldWinClip2 = NULL;
 	if (pWin->bitGravity != ForgetGravity) {
-	    oldWinClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, oldWinClip, &pWin->clipList);
+	    oldWinClip = RegionCreate(NullBox, 1);
+	    RegionCopy(oldWinClip, &pWin->clipList);
 	    if(pTree) {
-		oldWinClip2 = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_COPY(pScreen, oldWinClip2, &pTree->clipList);
+		oldWinClip2 = RegionCreate(NullBox, 1);
+		RegionCopy(oldWinClip2, &pTree->clipList);
 	    }
 	}
 	/*
@@ -1253,26 +1253,26 @@ miOverlayResizeWindow(
 	if ((pWin->drawable.height != h || pWin->drawable.width != w) &&
 	    HasBorder (pWin))
 	{
-	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+	    borderVisible = RegionCreate(NullBox, 1);
 	    if(pTree)
-		borderVisible2 = REGION_CREATE(pScreen, NullBox, 1);
+		borderVisible2 = RegionCreate(NullBox, 1);
 	    /* for tiled borders, we punt and draw the whole thing */
 	    if (pWin->borderIsPixel || !moved)
 	    {
 		if (shrunk || moved)
-		    REGION_SUBTRACT(pScreen, borderVisible,
+		    RegionSubtract(borderVisible,
 					  &pWin->borderClip,
 					  &pWin->winSize);
 		else
-		    REGION_COPY(pScreen, borderVisible,
+		    RegionCopy(borderVisible,
 					    &pWin->borderClip);
 		if(pTree) {
 		    if (shrunk || moved)
-			REGION_SUBTRACT(pScreen, borderVisible,
+			RegionSubtract(borderVisible,
 					  &pTree->borderClip,
 					  &pWin->winSize);
 		    else
-			REGION_COPY(pScreen, borderVisible,
+			RegionCopy(borderVisible,
 					    &pTree->borderClip);
 		}
 	    }
@@ -1299,9 +1299,9 @@ miOverlayResizeWindow(
     pFirstChange = MoveWindowInStack(pWin, pSib);
 
     if (WasViewable) {
-	pRegion = REGION_CREATE(pScreen, NullBox, 1);
+	pRegion = RegionCreate(NullBox, 1);
 	if (pWin->backStorage)
-	    REGION_COPY(pScreen, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, &pWin->clipList);
 
 	(*pScreen->MarkOverlappedWindows)(pWin, pFirstChange, NULL);
 
@@ -1320,9 +1320,9 @@ miOverlayResizeWindow(
 	 * the entire window is trashed unless bitGravity
 	 * recovers portions of it
 	 */
-	REGION_COPY(pScreen, &pWin->valdata->after.exposed, &pWin->clipList);
+	RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList);
 	if(pTree)
-	    REGION_COPY(pScreen, &pTree->valdata->exposed, &pTree->clipList);
+	    RegionCopy(&pTree->valdata->exposed, &pTree->clipList);
     }
 
     GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny);
@@ -1361,20 +1361,20 @@ miOverlayResizeWindow(
 		dx = (oldx - nx) - offx;
 		dy = (oldy - ny) - offy;
 		if (dx || dy) {
-		    REGION_TRANSLATE(pScreen, &pWin->winSize, dx, dy);
+		    RegionTranslate(&pWin->winSize, dx, dy);
 		    offx += dx;
 		    offy += dy;
 		}
 		if(gravitate[g])
-		    REGION_INTERSECT(pScreen, gravitate[g], gravitate[g],
+		    RegionIntersect(gravitate[g], gravitate[g],
 				 &pWin->winSize);
 		if(gravitate2[g])
-		    REGION_INTERSECT(pScreen, gravitate2[g], gravitate2[g],
+		    RegionIntersect(gravitate2[g], gravitate2[g],
 				 &pWin->winSize);
 	    }
 	    /* get winSize back where it belongs */
 	    if (offx || offy)
-		REGION_TRANSLATE(pScreen, &pWin->winSize, -offx, -offy);
+		RegionTranslate(&pWin->winSize, -offx, -offy);
 	}
 	/*
 	 * add screen bits to the appropriate bucket
@@ -1382,22 +1382,22 @@ miOverlayResizeWindow(
 
 	if (oldWinClip2)
 	{
-	    REGION_COPY(pScreen, pRegion, oldWinClip2);
-	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
-	    REGION_INTERSECT(pScreen, oldWinClip2, pRegion, &pTree->clipList);
+	    RegionCopy(pRegion, oldWinClip2);
+	    RegionTranslate(pRegion, nx - oldx, ny - oldy);
+	    RegionIntersect(oldWinClip2, pRegion, &pTree->clipList);
 
 	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) {
 		if (gravitate2[g])
-		    REGION_SUBTRACT(pScreen, oldWinClip2, oldWinClip2,
+		    RegionSubtract(oldWinClip2, oldWinClip2,
 					gravitate2[g]);
 	    }
-	    REGION_TRANSLATE(pScreen, oldWinClip2, oldx - nx, oldy - ny);
+	    RegionTranslate(oldWinClip2, oldx - nx, oldy - ny);
 	    g = pWin->bitGravity;
 	    if (!gravitate2[g])
 		gravitate2[g] = oldWinClip2;
 	    else {
-		REGION_UNION(pScreen,gravitate2[g],gravitate2[g],oldWinClip2);
-		REGION_DESTROY(pScreen, oldWinClip2);
+		RegionUnion(gravitate2[g],gravitate2[g],oldWinClip2);
+		RegionDestroy(oldWinClip2);
 	    }
 	}
 
@@ -1406,9 +1406,9 @@ miOverlayResizeWindow(
 	    /*
 	     * clip to new clipList
 	     */
-	    REGION_COPY(pScreen, pRegion, oldWinClip);
-	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
-	    REGION_INTERSECT(pScreen, oldWinClip, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, oldWinClip);
+	    RegionTranslate(pRegion, nx - oldx, ny - oldy);
+	    RegionIntersect(oldWinClip, pRegion, &pWin->clipList);
 	    /*
 	     * don't step on any gravity bits which will be copied after this
 	     * region.	Note -- this assumes that the regions will be copied
@@ -1416,16 +1416,16 @@ miOverlayResizeWindow(
 	     */
 	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++) {
 		if (gravitate[g])
-		    REGION_SUBTRACT(pScreen, oldWinClip, oldWinClip,
+		    RegionSubtract(oldWinClip, oldWinClip,
 					gravitate[g]);
 	    }
-	    REGION_TRANSLATE(pScreen, oldWinClip, oldx - nx, oldy - ny);
+	    RegionTranslate(oldWinClip, oldx - nx, oldy - ny);
 	    g = pWin->bitGravity;
 	    if (!gravitate[g])
 		gravitate[g] = oldWinClip;
 	    else {
-		REGION_UNION(pScreen, gravitate[g], gravitate[g], oldWinClip);
-		REGION_DESTROY(pScreen, oldWinClip);
+		RegionUnion(gravitate[g], gravitate[g], oldWinClip);
+		RegionDestroy(oldWinClip);
 	    }
 	}
 
@@ -1449,23 +1449,23 @@ miOverlayResizeWindow(
 	    /* only copy the remaining useful bits */
 
 	    if(gravitate[g])
-		REGION_INTERSECT(pScreen, gravitate[g], 
+		RegionIntersect(gravitate[g],
 				 gravitate[g], oldRegion);
 	    if(gravitate2[g])
-		REGION_INTERSECT(pScreen, gravitate2[g], 
+		RegionIntersect(gravitate2[g],
 				 gravitate2[g], oldRegion2);
 
 	    /* clip to not overwrite already copied areas */
 
 	    if (destClip && gravitate[g]) {
-		REGION_TRANSLATE(pScreen, destClip, oldpt.x - x, oldpt.y - y);
-		REGION_SUBTRACT(pScreen, gravitate[g], gravitate[g], destClip);
-		REGION_TRANSLATE(pScreen, destClip, x - oldpt.x, y - oldpt.y);
+		RegionTranslate(destClip, oldpt.x - x, oldpt.y - y);
+		RegionSubtract(gravitate[g], gravitate[g], destClip);
+		RegionTranslate(destClip, x - oldpt.x, y - oldpt.y);
 	    }
 	    if (destClip2 && gravitate2[g]) {
-		REGION_TRANSLATE(pScreen, destClip2, oldpt.x - x, oldpt.y - y);
-		REGION_SUBTRACT(pScreen,gravitate2[g],gravitate2[g],destClip2);
-		REGION_TRANSLATE(pScreen, destClip2, x - oldpt.x, y - oldpt.y);
+		RegionTranslate(destClip2, oldpt.x - x, oldpt.y - y);
+		RegionSubtract(gravitate2[g],gravitate2[g],destClip2);
+		RegionTranslate(destClip2, x - oldpt.x, y - oldpt.y);
 	    }
 
 	    /* and move those bits */
@@ -1486,9 +1486,9 @@ miOverlayResizeWindow(
 	    /* remove any overwritten bits from the remaining useful bits */
 
 	    if(gravitate[g])
-		REGION_SUBTRACT(pScreen, oldRegion, oldRegion, gravitate[g]);
+		RegionSubtract(oldRegion, oldRegion, gravitate[g]);
 	    if(gravitate2[g])
-		REGION_SUBTRACT(pScreen, oldRegion2, oldRegion2, gravitate2[g]);
+		RegionSubtract(oldRegion2, oldRegion2, gravitate2[g]);
 
 	    /*
 	     * recompute exposed regions of child windows
@@ -1513,38 +1513,38 @@ miOverlayResizeWindow(
 
 	    if (g == pWin->bitGravity) {
 		if(gravitate[g])
-		    REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+		    RegionSubtract(&pWin->valdata->after.exposed,
 				&pWin->valdata->after.exposed, gravitate[g]);
 		if(gravitate2[g] && pTree) 
-		    REGION_SUBTRACT(pScreen, &pTree->valdata->exposed,
+		    RegionSubtract(&pTree->valdata->exposed,
 				&pTree->valdata->exposed, gravitate2[g]);
 	    }
 	    if(gravitate[g]) {
 		if (!destClip)
 		    destClip = gravitate[g];
 		else {
-		    REGION_UNION(pScreen, destClip, destClip, gravitate[g]);
-		    REGION_DESTROY(pScreen, gravitate[g]);
+		    RegionUnion(destClip, destClip, gravitate[g]);
+		    RegionDestroy(gravitate[g]);
 		}
 	    }
 	    if(gravitate2[g]) {
 		if (!destClip2)
 		    destClip2 = gravitate2[g];
 		else {
-		    REGION_UNION(pScreen, destClip2, destClip2, gravitate2[g]);
-		    REGION_DESTROY(pScreen, gravitate2[g]);
+		    RegionUnion(destClip2, destClip2, gravitate2[g]);
+		    RegionDestroy(gravitate2[g]);
 		}
 	    }
 	}
 
-	REGION_DESTROY(pScreen, pRegion);
-	REGION_DESTROY(pScreen, oldRegion);
+	RegionDestroy(pRegion);
+	RegionDestroy(oldRegion);
 	if(doUnderlay)
-	    REGION_DESTROY(pScreen, oldRegion2);
+	    RegionDestroy(oldRegion2);
 	if (destClip)
-	    REGION_DESTROY(pScreen, destClip);
+	    RegionDestroy(destClip);
 	if (destClip2)
-	    REGION_DESTROY(pScreen, destClip2);
+	    RegionDestroy(destClip2);
 	if (bsExposed) {
 	    RegionPtr	valExposed = NullRegion;
 
@@ -1552,8 +1552,8 @@ miOverlayResizeWindow(
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
 	(*pScreen->HandleExposures)(pWin->parent);
 #ifdef DO_SAVE_UNDERS
@@ -1565,7 +1565,7 @@ miOverlayResizeWindow(
     }
     else if (bsExposed) {
 	(*pScreen->WindowExposures) (pWin, NullRegion, bsExposed);
-	REGION_DESTROY(pScreen, bsExposed);
+	RegionDestroy(bsExposed);
     }
     if (pWin->realized)
 	WindowsRestructured ();
@@ -1589,8 +1589,8 @@ miOverlaySetShape(WindowPtr pWin)
 	if (HasBorder (pWin)) {
 	    RegionPtr borderVisible;
 
-	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_SUBTRACT(pScreen, borderVisible,
+	    borderVisible = RegionCreate(NullBox, 1);
+	    RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 	    pWin->valdata->before.borderVisible = borderVisible;
 	    pWin->valdata->before.resized = TRUE;
@@ -1598,8 +1598,8 @@ miOverlaySetShape(WindowPtr pWin)
 		miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
 		RegionPtr borderVisible2;
 
-		borderVisible2 = REGION_CREATE(pScreen, NULL, 1);
-		REGION_SUBTRACT(pScreen, borderVisible2,
+		borderVisible2 = RegionCreate(NULL, 1);
+		RegionSubtract(borderVisible2,
 				      &pTree->borderClip, &pWin->winSize);
 		pTree->valdata->borderVisible = borderVisible2;
 	    }
@@ -1613,8 +1613,8 @@ miOverlaySetShape(WindowPtr pWin)
 
     if (WasViewable) {
 	if (pWin->backStorage) {
-	    pOldClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+	    pOldClip = RegionCreate(NullBox, 1);
+	    RegionCopy(pOldClip, &pWin->clipList);
 	}
 
 	(*pScreen->MarkOverlappedWindows)(pWin, pWin, NULL);
@@ -1634,7 +1634,7 @@ miOverlaySetShape(WindowPtr pWin)
 			     (pWin, 0, 0, pOldClip,
 			      pWin->drawable.x, pWin->drawable.y);
 	if (WasViewable)
-	    REGION_DESTROY(pScreen, pOldClip);
+	    RegionDestroy(pOldClip);
 	if (bsExposed)
 	{
 	    RegionPtr	valExposed = NullRegion;
@@ -1643,8 +1643,8 @@ miOverlaySetShape(WindowPtr pWin)
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
     }
     if (WasViewable) {
@@ -1694,16 +1694,16 @@ miOverlayChangeBorderWidth(
 
 	    if (HadBorder) {
 		RegionPtr   borderVisible;
-		borderVisible = REGION_CREATE(pScreen, NULL, 1);
-		REGION_SUBTRACT(pScreen, borderVisible,
+		borderVisible = RegionCreate(NULL, 1);
+		RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 		pWin->valdata->before.borderVisible = borderVisible;
 		if(IN_UNDERLAY(pWin)) {
 		    miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
 		    RegionPtr borderVisible2;
 
-		    borderVisible2 = REGION_CREATE(pScreen, NULL, 1);
-		    REGION_SUBTRACT(pScreen, borderVisible2,
+		    borderVisible2 = RegionCreate(NULL, 1);
+		    RegionSubtract(borderVisible2,
 				      &pTree->borderClip, &pWin->winSize);
 		    pTree->valdata->borderVisible = borderVisible2;
 		}
@@ -1746,11 +1746,11 @@ miOverlaySetRootClip(ScreenPtr pScreen, Bool enable)
 	box.x2 = pScreen->width;
 	box.y2 = pScreen->height;
 
-	REGION_RESET(pScreen, &pTree->borderClip, &box);
+	RegionReset(&pTree->borderClip, &box);
     } else 
-	REGION_EMPTY(pScreen, &pTree->borderClip);
+	RegionEmpty(&pTree->borderClip);
 
-    REGION_BREAK(pScreen, &pTree->clipList);
+    RegionBreak(&pTree->clipList);
 }
 
 static void 
@@ -1785,7 +1785,7 @@ miOverlayClearToBackground(
     clipList = ((*pScreenPriv->InOverlay)(pWin)) ? &pWin->clipList :
                                                  &pTree->clipList;
 
-    extents = REGION_EXTENTS(pScreen, clipList);
+    extents = RegionExtents(clipList);
     
     if (x1 < extents->x1) x1 = extents->x1;
     if (x2 > extents->x2) x2 = extents->x2;
@@ -1798,20 +1798,20 @@ miOverlayClearToBackground(
     box.x1 = x1; box.x2 = x2;
     box.y1 = y1; box.y2 = y2;
 
-    REGION_INIT(pScreen, &reg, &box, 1);
+    RegionInit(&reg, &box, 1);
     if (pWin->backStorage) {
         pBSReg = (* pScreen->ClearBackingStore)(pWin, x, y, w, h,
                                                  generateExposures);
     }
 
-    REGION_INTERSECT(pScreen, &reg, &reg, clipList);
+    RegionIntersect(&reg, &reg, clipList);
     if (generateExposures)
         (*pScreen->WindowExposures)(pWin, &reg, pBSReg);
     else if (pWin->backgroundState != None)
         (*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
-    REGION_UNINIT(pScreen, &reg);
+    RegionUninit(&reg);
     if (pBSReg)
-        REGION_DESTROY(pScreen, pBSReg);
+        RegionDestroy(pBSReg);
 }
 
 
@@ -1865,12 +1865,12 @@ miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
     }
 
     if (pGC->subWindowMode == IncludeInferiors) {
-	pregWin = REGION_CREATE(pScreen, NullBox, 1);
+	pregWin = RegionCreate(NullBox, 1);
 	freeTmpClip = TRUE;
 	if (pWin->parent || (screenIsSaved != SCREEN_SAVER_ON) ||
 		!HasSaverWindow (pScreen->myNum))
 	{
-            REGION_INTERSECT(pScreen,pregWin,&pTree->borderClip,&pWin->winSize);
+            RegionIntersect(pregWin,&pTree->borderClip,&pWin->winSize);
 	}
     } else {
 	pregWin = &pTree->clipList;
@@ -1879,29 +1879,29 @@ miOverlayComputeCompositeClip(GCPtr pGC, WindowPtr pWin)
     freeCompClip = pGC->freeCompClip;
     if (pGC->clientClipType == CT_NONE) {
 	if (freeCompClip) 
-	    REGION_DESTROY(pScreen, pGC->pCompositeClip);
+	    RegionDestroy(pGC->pCompositeClip);
 	pGC->pCompositeClip = pregWin;
 	pGC->freeCompClip = freeTmpClip;
     } else {
-	REGION_TRANSLATE(pScreen, pGC->clientClip,
+	RegionTranslate(pGC->clientClip,
 				pWin->drawable.x + pGC->clipOrg.x,
 				pWin->drawable.y + pGC->clipOrg.y);
 
 	if (freeCompClip) {
-	    REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
+	    RegionIntersect(pGC->pCompositeClip,
 					    pregWin, pGC->clientClip);
 	    if (freeTmpClip)
-		REGION_DESTROY(pScreen, pregWin);
+		RegionDestroy(pregWin);
 	} else if (freeTmpClip) {
-	    REGION_INTERSECT(pScreen, pregWin, pregWin, pGC->clientClip);
+	    RegionIntersect(pregWin, pregWin, pGC->clientClip);
 	    pGC->pCompositeClip = pregWin;
 	} else {
-	    pGC->pCompositeClip = REGION_CREATE(pScreen, NullBox, 0);
-	    REGION_INTERSECT(pScreen, pGC->pCompositeClip,
+	    pGC->pCompositeClip = RegionCreate(NullBox, 0);
+	    RegionIntersect(pGC->pCompositeClip,
 				       pregWin, pGC->clientClip);
 	}
 	pGC->freeCompClip = TRUE;
-	REGION_TRANSLATE(pScreen, pGC->clientClip,
+	RegionTranslate(pGC->clientClip,
 				-(pWin->drawable.x + pGC->clipOrg.x),
 				-(pWin->drawable.y + pGC->clipOrg.y));
     }
@@ -1919,7 +1919,7 @@ miOverlayCollectUnderlayRegions(
 	return FALSE;
     }
 
-    *region = REGION_CREATE(pWin->drawable.pScreen, NullBox, 0);
+    *region = RegionCreate(NullBox, 0);
     
     CollectUnderlayChildrenRegions(pWin, *region);
 
@@ -2041,7 +2041,7 @@ CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg)
 
     while(1) {
 	if((pTree = MIOVERLAY_GET_WINDOW_TREE(pChild))) {
-	    REGION_APPEND(pScreen, pReg, &pTree->borderClip);
+	    RegionAppend(pReg, &pTree->borderClip);
 	    hasUnderlay = TRUE;
 	} else
 	if(pChild->firstChild) {
@@ -2059,7 +2059,7 @@ CollectUnderlayChildrenRegions(WindowPtr pWin, RegionPtr pReg)
 
     if(hasUnderlay) {
 	Bool overlap;
-	REGION_VALIDATE(pScreen, pReg, &overlap);
+	RegionValidate(pReg, &overlap);
     } 
 
     return hasUnderlay;
diff --git a/nx-X11/programs/Xserver/mi/miscrinit.c b/nx-X11/programs/Xserver/mi/miscrinit.c
index 4950eaa93..addd5dd64 100644
--- a/nx-X11/programs/Xserver/mi/miscrinit.c
+++ b/nx-X11/programs/Xserver/mi/miscrinit.c
@@ -267,31 +267,31 @@ miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
     /* CreateColormap, DestroyColormap, InstallColormap, UninstallColormap */
     /* ListInstalledColormaps, StoreColors, ResolveColor */
 #ifdef NEED_SCREEN_REGIONS
-    pScreen->RegionCreate = miRegionCreate;
-    pScreen->RegionInit = miRegionInit;
-    pScreen->RegionCopy = miRegionCopy;
-    pScreen->RegionDestroy = miRegionDestroy;
-    pScreen->RegionUninit = miRegionUninit;
-    pScreen->Intersect = miIntersect;
-    pScreen->Union = miUnion;
-    pScreen->Subtract = miSubtract;
-    pScreen->Inverse = miInverse;
-    pScreen->RegionReset = miRegionReset;
-    pScreen->TranslateRegion = miTranslateRegion;
-    pScreen->RectIn = miRectIn;
-    pScreen->PointInRegion = miPointInRegion;
-    pScreen->RegionNotEmpty = miRegionNotEmpty;
-    pScreen->RegionEqual = miRegionEqual;
-    pScreen->RegionBroken = miRegionBroken;
-    pScreen->RegionBreak = miRegionBreak;
-    pScreen->RegionEmpty = miRegionEmpty;
-    pScreen->RegionExtents = miRegionExtents;
-    pScreen->RegionAppend = miRegionAppend;
-    pScreen->RegionValidate = miRegionValidate;
+    pScreen->RegionCreate = RegionCreate;
+    pScreen->RegionInit = RegionInit;
+    pScreen->RegionCopy = RegionCopy;
+    pScreen->RegionDestroy = RegionDestroy;
+    pScreen->RegionUninit = RegionUninit;
+    pScreen->Intersect = RegionIntersect;
+    pScreen->Union = RegionUnion;
+    pScreen->Subtract = RegionSubtract;
+    pScreen->Inverse = RegionInverse;
+    pScreen->RegionReset = RegionReset;
+    pScreen->TranslateRegion = RegionTranslate;
+    pScreen->RectIn = RegionContainsRect;
+    pScreen->PointInRegion = RegionContainsPoint;
+    pScreen->RegionNotEmpty = RegionNotEmpty;
+    pScreen->RegionEqual = RegionEqual;
+    pScreen->RegionBroken = RegionBroken;
+    pScreen->RegionBreak = RegionBreak;
+    pScreen->RegionEmpty = RegionEmpty;
+    pScreen->RegionExtents = RegionExtents;
+    pScreen->RegionAppend = RegionAppend;
+    pScreen->RegionValidate = RegionValidate;
 #endif /* NEED_SCREEN_REGIONS */
     /* BitmapToRegion */
 #ifdef NEED_SCREEN_REGIONS
-    pScreen->RectsToRegion = miRectsToRegion;
+    pScreen->RectsToRegion = RegionFromRects;
 #endif /* NEED_SCREEN_REGIONS */
     pScreen->SendGraphicsExpose = miSendGraphicsExpose;
     pScreen->BlockHandler = (ScreenBlockHandlerProcPtr)NoopDDA;
diff --git a/nx-X11/programs/Xserver/mi/mispans.h b/nx-X11/programs/Xserver/mi/mispans.h
index b6e97e2b4..0db0afc1c 100644
--- a/nx-X11/programs/Xserver/mi/mispans.h
+++ b/nx-X11/programs/Xserver/mi/mispans.h
@@ -101,7 +101,7 @@ extern void miDisposeSpanGroup(
     SpanGroup * /*spanGroup*/
 );
 
-extern int miClipSpans(
+extern int RegionClipSpans(
     RegionPtr /*prgnDst*/,
     DDXPointPtr /*ppt*/,
     int * /*pwidth*/,
diff --git a/nx-X11/programs/Xserver/mi/misprite.c b/nx-X11/programs/Xserver/mi/misprite.c
index a5e3f9ccf..c854984fc 100644
--- a/nx-X11/programs/Xserver/mi/misprite.c
+++ b/nx-X11/programs/Xserver/mi/misprite.c
@@ -136,7 +136,7 @@ miSpriteReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
     pScreenPriv = (miSpriteScreenPtr) pScreen->devPrivates[miSpriteScreenIndex].ptr;
     
     if (pScreenPriv->isUp &&
-	RECT_IN_REGION (pScreen, pRegion, &pScreenPriv->saved) != rgnOUT)
+	RegionContainsRect(pRegion, &pScreenPriv->saved) != rgnOUT)
     {
 	SPRITE_DEBUG(("Damage remove\n"));
 	miSpriteRemoveCursor (pScreen);
@@ -389,7 +389,7 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
      * Damage will take care of destination check
      */
     if (pScreenPriv->isUp &&
-	RECT_IN_REGION (pScreen, prgnSrc, &pScreenPriv->saved) != rgnOUT)
+	RegionContainsRect(prgnSrc, &pScreenPriv->saved) != rgnOUT)
     {
 	SPRITE_DEBUG (("CopyWindow remove\n"));
 	miSpriteRemoveCursor (pScreen);
@@ -589,7 +589,7 @@ miSpriteSaveDoomedAreas (pWin, pObscured, dx, dy)
 	    cursorBox.x2 += dx;
 	    cursorBox.y2 += dy;
 	}
-	if (RECT_IN_REGION( pScreen, pObscured, &cursorBox) != rgnOUT)
+	if (RegionContainsRect(pObscured, &cursorBox) != rgnOUT)
 	    miSpriteRemoveCursor (pScreen);
     }
 
diff --git a/nx-X11/programs/Xserver/mi/mivaltree.c b/nx-X11/programs/Xserver/mi/mivaltree.c
index b9a42472f..73028a074 100644
--- a/nx-X11/programs/Xserver/mi/mivaltree.c
+++ b/nx-X11/programs/Xserver/mi/mivaltree.c
@@ -123,8 +123,8 @@ miShapedWindowIn (pScreen, universe, bounding, rect, x, y)
     Bool    someIn, someOut;
     register int t, x1, y1, x2, y2;
 
-    nbox = REGION_NUM_RECTS (bounding);
-    boundBox = REGION_RECTS (bounding);
+    nbox = RegionNumRects (bounding);
+    boundBox = RegionRects (bounding);
     someIn = someOut = FALSE;
     x1 = rect->x1;
     y1 = rect->y1;
@@ -148,7 +148,7 @@ miShapedWindowIn (pScreen, universe, bounding, rect, x, y)
 	    box.x2 = box.x1;
 	if (box.y1 > box.y2)
 	    box.y2 = box.y1;
-	switch (RECT_IN_REGION(pScreen, universe, &box))
+	switch (RegionContainsRect(universe, &box))
 	{
 	case rgnIN:
 	    if (someOut)
@@ -241,7 +241,7 @@ miComputeClips (
     borderSize.y2 = dy;
 
     oldVis = pParent->visibility;
-    switch (RECT_IN_REGION( pScreen, universe, &borderSize)) 
+    switch (RegionContainsRect(universe, &borderSize))
     {
 	case rgnIN:
 	    newVis = VisibilityUnobscured;
@@ -287,7 +287,7 @@ miComputeClips (
     {
 	if (miSetRedirectBorderClipProc)
 	    (*miSetRedirectBorderClipProc) (pParent, universe);
-	REGION_COPY(pScreen, universe, &pParent->borderSize);
+	RegionCopy(universe, &pParent->borderSize);
     }
 #endif
 
@@ -315,9 +315,9 @@ miComputeClips (
 		{
 		    if (pChild->visibility != VisibilityFullyObscured)
 		    {
-			REGION_TRANSLATE( pScreen, &pChild->borderClip,
+			RegionTranslate(&pChild->borderClip,
 						      dx, dy);
-			REGION_TRANSLATE( pScreen, &pChild->clipList,
+			RegionTranslate(&pChild->clipList,
 						      dx, dy);
 			pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 			if (pScreen->ClipNotify)
@@ -326,16 +326,16 @@ miComputeClips (
 		    }
 		    if (pChild->valdata)
 		    {
-			REGION_NULL(pScreen,
+			RegionNull(
 				    &pChild->valdata->after.borderExposed);
 			if (HasParentRelativeBorder(pChild))
 			{
-			    REGION_SUBTRACT(pScreen,
+			    RegionSubtract(
 					 &pChild->valdata->after.borderExposed,
 					 &pChild->borderClip,
 					 &pChild->winSize);
 			}
-			REGION_NULL(pScreen, &pChild->valdata->after.exposed);
+			RegionNull(&pChild->valdata->after.exposed);
 		    }
 		    if (pChild->firstChild)
 		    {
@@ -364,20 +364,20 @@ miComputeClips (
 	     * We translate the old clipList because that will be exposed or copied
 	     * if gravity is right.
 	     */
-	    REGION_TRANSLATE( pScreen, &pParent->borderClip, dx, dy);
-	    REGION_TRANSLATE( pScreen, &pParent->clipList, dx, dy);
+	    RegionTranslate(&pParent->borderClip, dx, dy);
+	    RegionTranslate(&pParent->clipList, dx, dy);
     	} 
 	break;
     case VTBroken:
-	REGION_EMPTY (pScreen, &pParent->borderClip);
-	REGION_EMPTY (pScreen, &pParent->clipList);
+	RegionEmpty(&pParent->borderClip);
+	RegionEmpty(&pParent->clipList);
 	break;
     }
 
     borderVisible = pParent->valdata->before.borderVisible;
     resized = pParent->valdata->before.resized;
-    REGION_NULL(pScreen, &pParent->valdata->after.borderExposed);
-    REGION_NULL(pScreen, &pParent->valdata->after.exposed);
+    RegionNull(&pParent->valdata->after.borderExposed);
+    RegionNull(&pParent->valdata->after.exposed);
 
     /*
      * Since the borderClip must not be clipped by the children, we do
@@ -397,22 +397,22 @@ miComputeClips (
 	     * of the border will be saved by DIX in borderVisible --
 	     * use that region and destroy it
 	     */
-	    REGION_SUBTRACT( pScreen, exposed, universe, borderVisible);
-	    REGION_DESTROY( pScreen, borderVisible);
+	    RegionSubtract(exposed, universe, borderVisible);
+	    RegionDestroy(borderVisible);
     	}
     	else
     	{
-	    REGION_SUBTRACT( pScreen, exposed, universe, &pParent->borderClip);
+	    RegionSubtract(exposed, universe, &pParent->borderClip);
     	}
 	if (HasParentRelativeBorder(pParent) && (dx || dy))
-	    REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
+	    RegionSubtract(&pParent->valdata->after.borderExposed,
 				  universe,
 				  &pParent->winSize);
 	else
-	    REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
+	    RegionSubtract(&pParent->valdata->after.borderExposed,
 			       exposed, &pParent->winSize);
 
-    	REGION_COPY( pScreen, &pParent->borderClip, universe);
+	RegionCopy(&pParent->borderClip, universe);
     
     	/*
      	 * To get the right clipList for the parent, and to make doubly sure
@@ -420,15 +420,15 @@ miComputeClips (
      	 * border from the universe before proceeding.
      	 */
     
-    	REGION_INTERSECT( pScreen, universe, universe, &pParent->winSize);
+	RegionIntersect(universe, universe, &pParent->winSize);
     }
     else
-    	REGION_COPY( pScreen, &pParent->borderClip, universe);
+	RegionCopy(&pParent->borderClip, universe);
     
     if ((pChild = pParent->firstChild) && pParent->mapped)
     {
-	REGION_NULL(pScreen, &childUniverse);
-	REGION_NULL(pScreen, &childUnion);
+	RegionNull(&childUniverse);
+	RegionNull(&childUnion);
 	if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
 	    ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
 	     (pChild->drawable.x < pParent->lastChild->drawable.x)))
@@ -436,7 +436,7 @@ miComputeClips (
 	    for (; pChild; pChild = pChild->nextSib)
 	    {
 		if (pChild->viewable)
-		    REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
+		    RegionAppend(&childUnion, &pChild->borderSize);
 	    }
 	}
 	else
@@ -444,10 +444,10 @@ miComputeClips (
 	    for (pChild = pParent->lastChild; pChild; pChild = pChild->prevSib)
 	    {
 		if (pChild->viewable)
-		    REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
+		    RegionAppend(&childUnion, &pChild->borderSize);
 	    }
 	}
-	REGION_VALIDATE( pScreen, &childUnion, &overlap);
+	RegionValidate(&childUnion, &overlap);
 
 	for (pChild = pParent->firstChild;
 	     pChild;
@@ -464,7 +464,7 @@ miComputeClips (
 		     * Figure out the new universe from the child's
 		     * perspective and recurse.
 		     */
-		    REGION_INTERSECT( pScreen, &childUniverse,
+		    RegionIntersect(&childUniverse,
 					    universe,
 					    &pChild->borderSize);
 		    miComputeClips (pChild, pScreen, &childUniverse, kind,
@@ -476,14 +476,14 @@ miComputeClips (
 		 * other sibling.
 		 */
 		if (overlap)
-		    REGION_SUBTRACT( pScreen, universe, universe,
+		    RegionSubtract(universe, universe,
 					  &pChild->borderSize);
 	    }
 	}
 	if (!overlap)
-	    REGION_SUBTRACT( pScreen, universe, universe, &childUnion);
-	REGION_UNINIT( pScreen, &childUnion);
-	REGION_UNINIT( pScreen, &childUniverse);
+	    RegionSubtract(universe, universe, &childUnion);
+	RegionUninit(&childUnion);
+	RegionUninit(&childUniverse);
     } /* if any children */
 
     /*
@@ -496,12 +496,12 @@ miComputeClips (
     if (oldVis == VisibilityFullyObscured ||
 	oldVis == VisibilityNotViewable)
     {
-	REGION_COPY( pScreen, &pParent->valdata->after.exposed, universe);
+	RegionCopy(&pParent->valdata->after.exposed, universe);
     }
     else if (newVis != VisibilityFullyObscured &&
 	     newVis != VisibilityNotViewable)
     {
-    	REGION_SUBTRACT( pScreen, &pParent->valdata->after.exposed,
+	RegionSubtract(&pParent->valdata->after.exposed,
 			       universe, &pParent->clipList);
     }
 
@@ -513,7 +513,7 @@ miComputeClips (
      */
     if (pParent->backStorage && !resized)
     {
-	REGION_SUBTRACT( pScreen, exposed, &pParent->clipList, universe);
+	RegionSubtract(exposed, &pParent->clipList, universe);
 	(* pScreen->SaveDoomedAreas)(pParent, exposed, dx, dy);
     }
     
@@ -527,7 +527,7 @@ miComputeClips (
     }
 
 #ifdef NOTDEF
-    REGION_COPY( pScreen, &pParent->clipList, universe);
+    RegionCopy(&pParent->clipList, universe);
 #endif
 
     pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
@@ -622,8 +622,8 @@ miValidateTree (pParent, pChild, kind)
     if (pChild == NullWindow)
 	pChild = pParent->firstChild;
 
-    REGION_NULL(pScreen, &childClip);
-    REGION_NULL(pScreen, &exposed);
+    RegionNull(&childClip);
+    RegionNull(&exposed);
 
     /*
      * compute the area of the parent window occupied
@@ -631,10 +631,10 @@ miValidateTree (pParent, pChild, kind)
      * is the area which can be divied up among the marked
      * children in their new configuration.
      */
-    REGION_NULL(pScreen, &totalClip);
+    RegionNull(&totalClip);
     viewvals = 0;
-    if (REGION_BROKEN (pScreen, &pParent->clipList) &&
-	!REGION_BROKEN (pScreen, &pParent->borderClip))
+    if (RegionBroken(&pParent->clipList) &&
+	!RegionBroken(&pParent->borderClip))
     {
 	kind = VTBroken;
 	/*
@@ -642,19 +642,19 @@ miValidateTree (pParent, pChild, kind)
 	 * assume everything is busted.
 	 */
 	forward = TRUE;
-	REGION_COPY (pScreen, &totalClip, &pParent->borderClip);
-	REGION_INTERSECT (pScreen, &totalClip, &totalClip, &pParent->winSize);
+	RegionCopy(&totalClip, &pParent->borderClip);
+	RegionIntersect(&totalClip, &totalClip, &pParent->winSize);
 	
 	for (pWin = pParent->firstChild; pWin != pChild; pWin = pWin->nextSib)
 	{
 	    if (pWin->viewable)
-		REGION_SUBTRACT (pScreen, &totalClip, &totalClip, &pWin->borderSize);
+		RegionSubtract(&totalClip, &totalClip, &pWin->borderSize);
 	}
 	for (pWin = pChild; pWin; pWin = pWin->nextSib)
 	    if (pWin->valdata && pWin->viewable)
 		viewvals++;
 	
-	REGION_EMPTY (pScreen, &pParent->clipList);
+	RegionEmpty(&pParent->clipList);
     }
     else 
     {
@@ -672,7 +672,7 @@ miValidateTree (pParent, pChild, kind)
 		    if (pWin->redirectDraw && miGetRedirectBorderClipProc)
 			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);
 #endif
-		    REGION_APPEND( pScreen, &totalClip, pBorderClip );
+		    RegionAppend(&totalClip, pBorderClip );
 		    if (pWin->viewable)
 			viewvals++;
 		}
@@ -691,7 +691,7 @@ miValidateTree (pParent, pChild, kind)
 		    if (pWin->redirectDraw && miGetRedirectBorderClipProc)
 			pBorderClip = (*miGetRedirectBorderClipProc)(pWin);
 #endif
-		    REGION_APPEND( pScreen, &totalClip, pBorderClip );
+		    RegionAppend(&totalClip, pBorderClip );
 		    if (pWin->viewable)
 			viewvals++;
 		}
@@ -700,7 +700,7 @@ miValidateTree (pParent, pChild, kind)
 		pWin = pWin->prevSib;
 	    }
 	}
-	REGION_VALIDATE( pScreen, &totalClip, &overlap);
+	RegionValidate(&totalClip, &overlap);
     }
 
     /*
@@ -713,7 +713,7 @@ miValidateTree (pParent, pChild, kind)
     overlap = TRUE;
     if (kind != VTStack)
     {
-	REGION_UNION( pScreen, &totalClip, &totalClip, &pParent->clipList);
+	RegionUnion(&totalClip, &totalClip, &pParent->clipList);
 	if (viewvals > 1)
 	{
 	    /*
@@ -723,12 +723,12 @@ miValidateTree (pParent, pChild, kind)
 	     * lower than the cost of multiple Subtracts in the
 	     * loop below.
 	     */
-	    REGION_NULL(pScreen, &childUnion);
+	    RegionNull(&childUnion);
 	    if (forward)
 	    {
 		for (pWin = pChild; pWin; pWin = pWin->nextSib)
 		    if (pWin->valdata && pWin->viewable)
-			REGION_APPEND( pScreen, &childUnion,
+			RegionAppend(&childUnion,
 						   &pWin->borderSize);
 	    }
 	    else
@@ -737,16 +737,16 @@ miValidateTree (pParent, pChild, kind)
 		while (1)
 		{
 		    if (pWin->valdata && pWin->viewable)
-			REGION_APPEND( pScreen, &childUnion,
+			RegionAppend(&childUnion,
 						   &pWin->borderSize);
 		    if (pWin == pChild)
 			break;
 		    pWin = pWin->prevSib;
 		}
 	    }
-	    REGION_VALIDATE(pScreen, &childUnion, &overlap);
+	    RegionValidate(&childUnion, &overlap);
 	    if (overlap)
-		REGION_UNINIT(pScreen, &childUnion);
+		RegionUninit(&childUnion);
 	}
     }
 
@@ -756,13 +756,13 @@ miValidateTree (pParent, pChild, kind)
     {
 	if (pWin->viewable) {
 	    if (pWin->valdata) {
-		REGION_INTERSECT( pScreen, &childClip,
+		RegionIntersect(&childClip,
 					&totalClip,
  					&pWin->borderSize);
 		miComputeClips (pWin, pScreen, &childClip, kind, &exposed);
 		if (overlap)
 		{
-		    REGION_SUBTRACT( pScreen, &totalClip,
+		    RegionSubtract(&totalClip,
 				       	   &totalClip,
 				       	   &pWin->borderSize);
 		}
@@ -771,24 +771,24 @@ miValidateTree (pParent, pChild, kind)
 	    }
 	} else {
 	    if (pWin->valdata) {
-		REGION_EMPTY( pScreen, &pWin->clipList);
+		RegionEmpty(&pWin->clipList);
 		if (pScreen->ClipNotify)
 		    (* pScreen->ClipNotify) (pWin, 0, 0);
-		REGION_EMPTY( pScreen, &pWin->borderClip);
+		RegionEmpty(&pWin->borderClip);
 		pWin->valdata = (ValidatePtr)NULL;
 	    }
 	}
     }
 
-    REGION_UNINIT( pScreen, &childClip);
+    RegionUninit(&childClip);
     if (!overlap)
     {
-	REGION_SUBTRACT(pScreen, &totalClip, &totalClip, &childUnion);
-	REGION_UNINIT(pScreen, &childUnion);
+	RegionSubtract(&totalClip, &totalClip, &childUnion);
+	RegionUninit(&childUnion);
     }
 
-    REGION_NULL(pScreen, &pParent->valdata->after.exposed);
-    REGION_NULL(pScreen, &pParent->valdata->after.borderExposed);
+    RegionNull(&pParent->valdata->after.exposed);
+    RegionNull(&pParent->valdata->after.borderExposed);
 
     /*
      * each case below is responsible for updating the
@@ -804,22 +804,22 @@ miValidateTree (pParent, pChild, kind)
 	 * exposures and obscures as per miComputeClips and reset the parent's
 	 * clipList.
 	 */
-	REGION_SUBTRACT( pScreen, &pParent->valdata->after.exposed,
+	RegionSubtract(&pParent->valdata->after.exposed,
 			       &totalClip, &pParent->clipList);
 	/* fall through */
     case VTMap:
 	if (pParent->backStorage) {
-	    REGION_SUBTRACT( pScreen, &exposed, &pParent->clipList, &totalClip);
+	    RegionSubtract(&exposed, &pParent->clipList, &totalClip);
 	    (* pScreen->SaveDoomedAreas)(pParent, &exposed, 0, 0);
 	}
 	
-	REGION_COPY( pScreen, &pParent->clipList, &totalClip);
+	RegionCopy(&pParent->clipList, &totalClip);
 	pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	break;
     }
 
-    REGION_UNINIT( pScreen, &totalClip);
-    REGION_UNINIT( pScreen, &exposed);
+    RegionUninit(&totalClip);
+    RegionUninit(&exposed);
     if (pScreen->ClipNotify)
 	(*pScreen->ClipNotify) (pParent, 0, 0);
     return (1);
diff --git a/nx-X11/programs/Xserver/mi/miwindow.c b/nx-X11/programs/Xserver/mi/miwindow.c
index 44b7ada60..198f765dd 100644
--- a/nx-X11/programs/Xserver/mi/miwindow.c
+++ b/nx-X11/programs/Xserver/mi/miwindow.c
@@ -114,7 +114,7 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
     box.y2 = y2;
 
     pScreen = pWin->drawable.pScreen;
-    REGION_INIT(pScreen, &reg, &box, 1);
+    RegionInit(&reg, &box, 1);
     if (pWin->backStorage)
     {
 	/*
@@ -128,14 +128,14 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
 						 generateExposures);
     }
 
-    REGION_INTERSECT(pScreen, &reg, &reg, &pWin->clipList);
+    RegionIntersect(&reg, &reg, &pWin->clipList);
     if (generateExposures)
 	(*pScreen->WindowExposures)(pWin, &reg, pBSReg);
     else if (pWin->backgroundState != None)
         (*pScreen->PaintWindowBackground)(pWin, &reg, PW_BACKGROUND);
-    REGION_UNINIT(pScreen, &reg);
+    RegionUninit(&reg);
     if (pBSReg)
-	REGION_DESTROY(pScreen, pBSReg);
+	RegionDestroy(pBSReg);
 }
 
 /*
@@ -181,7 +181,7 @@ miCheckSubSaveUnder(
 
 	for (; pChild != pFirst; pChild = pChild->nextSib)
 	    if (pChild->viewable && pChild->saveUnder)
-		REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+		RegionUnion(pRegion, pRegion, &pChild->borderSize);
 	
 	/*
 	 * check region below and including first changed window
@@ -200,10 +200,10 @@ miCheckSubSaveUnder(
 		{
 		    if (!subInited)
 		    {
-			REGION_NULL(pScreen, &SubRegion);
+			RegionNull(&SubRegion);
 			subInited = TRUE;
 		    }
-		    REGION_COPY(pScreen, &SubRegion, pRegion);
+		    RegionCopy(&SubRegion, pRegion);
 		    res |= miCheckSubSaveUnder(pChild, pChild->firstChild,
 					     &SubRegion);
 		}
@@ -214,12 +214,12 @@ miCheckSubSaveUnder(
 		}
 
 		if (pChild->saveUnder)
-		    REGION_UNION(pScreen, pRegion, pRegion, &pChild->borderSize);
+		    RegionUnion(pRegion, pRegion, &pChild->borderSize);
 	    }
 	}
 
 	if (subInited)
-	    REGION_UNINIT(pScreen, &SubRegion);
+	    RegionUninit(&SubRegion);
     }
 
     /*
@@ -230,8 +230,8 @@ miCheckSubSaveUnder(
 
     if (pParent->viewable && 
 	((pParent->eventMask | wOtherEventMasks(pParent)) & ExposureMask) &&
-	REGION_NOTEMPTY(pScreen, &pParent->borderSize) &&
-	RECT_IN_REGION(pScreen, pRegion, REGION_EXTENTS(pScreen, 
+	RegionNotEmpty(&pParent->borderSize) &&
+	RegionContainsRect(pRegion, RegionExtents(
 					&pParent->borderSize)) != rgnOUT)
     {
 	if (!pParent->DIXsaveUnder)
@@ -283,11 +283,11 @@ miChangeSaveUnder(pWin, first)
     numSaveUndersViewable += deltaSaveUndersViewable;
     deltaSaveUndersViewable = 0;
     pScreen = pWin->drawable.pScreen;
-    REGION_NULL(pScreen, &rgn);
+    RegionNull(&rgn);
     res = miCheckSubSaveUnder (pWin->parent,
 			       pWin->saveUnder ? first : pWin->nextSib,
 			       &rgn);
-    REGION_UNINIT(pScreen, &rgn);
+    RegionUninit(&rgn);
     return res;
 }
 
@@ -386,9 +386,9 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
 	{
 	    if (pChild->viewable)
 	    {
-		if (REGION_BROKEN (pScreen, &pChild->winSize))
+		if (RegionBroken(&pChild->winSize))
 		    SetWinSize (pChild);
-		if (REGION_BROKEN (pScreen, &pChild->borderSize))
+		if (RegionBroken(&pChild->borderSize))
 		    SetBorderSize (pChild);
 		(* MarkWindow)(pChild);
 		if (pChild->firstChild)
@@ -408,17 +408,17 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
     }
     if ( (pChild = pFirst) )
     {
-	box = REGION_EXTENTS(pChild->drawable.pScreen, &pWin->borderSize);
+	box = RegionExtents(&pWin->borderSize);
 	pLast = pChild->parent->lastChild;
 	while (1)
 	{
 	    if (pChild->viewable)
 	    {
-		if (REGION_BROKEN (pScreen, &pChild->winSize))
+		if (RegionBroken(&pChild->winSize))
 		    SetWinSize (pChild);
-		if (REGION_BROKEN (pScreen, &pChild->borderSize))
+		if (RegionBroken(&pChild->borderSize))
 		    SetBorderSize (pChild);
-		if (RECT_IN_REGION(pScreen, &pChild->borderSize, box))
+		if (RegionContainsRect(&pChild->borderSize, box))
 		{
 		    (* MarkWindow)(pChild);
 		    anyMarked = TRUE;
@@ -464,13 +464,13 @@ miHandleValidateExposures(pWin)
     {
 	if ( (val = pChild->valdata) )
 	{
-	    if (REGION_NOTEMPTY(pScreen, &val->after.borderExposed))
+	    if (RegionNotEmpty(&val->after.borderExposed))
 		(*pChild->drawable.pScreen->PaintWindowBorder)(pChild,
 						    &val->after.borderExposed,
 						    PW_BORDER);
-	    REGION_UNINIT(pScreen, &val->after.borderExposed);
+	    RegionUninit(&val->after.borderExposed);
 	    (*WindowExposures)(pChild, &val->after.exposed, NullRegion);
-	    REGION_UNINIT(pScreen, &val->after.exposed);
+	    RegionUninit(&val->after.exposed);
 	    xfree(val);
 	    pChild->valdata = (ValidatePtr)NULL;
 	    if (pChild->firstChild)
@@ -517,8 +517,8 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
     oldpt.y = pWin->drawable.y;
     if (WasViewable)
     {
-	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
-	REGION_COPY(pScreen, oldRegion, &pWin->borderClip);
+	oldRegion = RegionCreate(NullBox, 1);
+	RegionCopy(oldRegion, &pWin->borderClip);
 	anyMarked = (*pScreen->MarkOverlappedWindows)(pWin, pWin, &pLayerWin);
     }
     pWin->origin.x = x + (int)bw;
@@ -555,7 +555,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
 	{
 	    (*pScreen->ValidateTree)(pLayerWin->parent, NullWindow, kind);
 	    (* pWin->drawable.pScreen->CopyWindow)(pWin, oldpt, oldRegion);
-	    REGION_DESTROY(pScreen, oldRegion);
+	    RegionDestroy(oldRegion);
 	    /* XXX need to retile border if ParentRelative origin */
 	    (*pScreen->HandleExposures)(pLayerWin->parent);
 	}
@@ -590,14 +590,14 @@ miRecomputeExposures (
 	/*
 	 * compute exposed regions of this window
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+	RegionSubtract(&pWin->valdata->after.exposed,
 			&pWin->clipList, pValid);
 	/*
 	 * compute exposed regions of the border
 	 */
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->borderClip, &pWin->winSize);
-	REGION_SUBTRACT(pScreen, &pWin->valdata->after.borderExposed,
+	RegionSubtract(&pWin->valdata->after.borderExposed,
 			     &pWin->valdata->after.borderExposed, pValid);
 	return WT_WALKCHILDREN;
     }
@@ -654,8 +654,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	/*
 	 * save the visible region of the window
 	 */
-	oldRegion = REGION_CREATE(pScreen, NullBox, 1);
-	REGION_COPY(pScreen, oldRegion, &pWin->winSize);
+	oldRegion = RegionCreate(NullBox, 1);
+	RegionCopy(oldRegion, &pWin->winSize);
 
 	/*
 	 * categorize child windows into regions to be moved
@@ -668,8 +668,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    if (g != UnmapGravity)
 	    {
 		if (!gravitate[g])
-		    gravitate[g] = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_UNION(pScreen, gravitate[g],
+		    gravitate[g] = RegionCreate(NullBox, 1);
+		RegionUnion(gravitate[g],
 				   gravitate[g], &pChild->borderClip);
 	    }
 	    else
@@ -684,8 +684,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	oldWinClip = NULL;
 	if (pWin->bitGravity != ForgetGravity)
 	{
-	    oldWinClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, oldWinClip, &pWin->clipList);
+	    oldWinClip = RegionCreate(NullBox, 1);
+	    RegionCopy(oldWinClip, &pWin->clipList);
 	}
 	/*
 	 * if the window is changing size, borderExposed
@@ -700,16 +700,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	if ((pWin->drawable.height != h || pWin->drawable.width != w) &&
 	    HasBorder (pWin))
 	{
-	    borderVisible = REGION_CREATE(pScreen, NullBox, 1);
+	    borderVisible = RegionCreate(NullBox, 1);
 	    /* for tiled borders, we punt and draw the whole thing */
 	    if (pWin->borderIsPixel || !moved)
 	    {
 		if (shrunk || moved)
-		    REGION_SUBTRACT(pScreen, borderVisible,
+		    RegionSubtract(borderVisible,
 					  &pWin->borderClip,
 					  &pWin->winSize);
 		else
-		    REGION_COPY(pScreen, borderVisible,
+		    RegionCopy(borderVisible,
 					    &pWin->borderClip);
 	    }
 	}
@@ -736,9 +736,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
     if (WasViewable)
     {
-	pRegion = REGION_CREATE(pScreen, NullBox, 1);
+	pRegion = RegionCreate(NullBox, 1);
 	if (pWin->backStorage)
-	    REGION_COPY(pScreen, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, &pWin->clipList);
 
 	if (pLayerWin == pWin)
 	    anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pFirstChange,
@@ -766,7 +766,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	 * the entire window is trashed unless bitGravity
 	 * recovers portions of it
 	 */
-	REGION_COPY(pScreen, &pWin->valdata->after.exposed, &pWin->clipList);
+	RegionCopy(&pWin->valdata->after.exposed, &pWin->clipList);
     }
 
     GravityTranslate (x, y, oldx, oldy, dw, dh, pWin->bitGravity, &nx, &ny);
@@ -810,16 +810,16 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		dy = (oldy - ny) - offy;
 		if (dx || dy)
 		{
-		    REGION_TRANSLATE(pScreen, &pWin->winSize, dx, dy);
+		    RegionTranslate(&pWin->winSize, dx, dy);
 		    offx += dx;
 		    offy += dy;
 		}
-		REGION_INTERSECT(pScreen, gravitate[g], gravitate[g],
+		RegionIntersect(gravitate[g], gravitate[g],
 				 &pWin->winSize);
 	    }
 	    /* get winSize back where it belongs */
 	    if (offx || offy)
-		REGION_TRANSLATE(pScreen, &pWin->winSize, -offx, -offy);
+		RegionTranslate(&pWin->winSize, -offx, -offy);
 	}
 	/*
 	 * add screen bits to the appropriate bucket
@@ -830,9 +830,9 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    /*
 	     * clip to new clipList
 	     */
-	    REGION_COPY(pScreen, pRegion, oldWinClip);
-	    REGION_TRANSLATE(pScreen, pRegion, nx - oldx, ny - oldy);
-	    REGION_INTERSECT(pScreen, oldWinClip, pRegion, &pWin->clipList);
+	    RegionCopy(pRegion, oldWinClip);
+	    RegionTranslate(pRegion, nx - oldx, ny - oldy);
+	    RegionIntersect(oldWinClip, pRegion, &pWin->clipList);
 	    /*
 	     * don't step on any gravity bits which will be copied after this
 	     * region.	Note -- this assumes that the regions will be copied
@@ -841,17 +841,17 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    for (g = pWin->bitGravity + 1; g <= StaticGravity; g++)
 	    {
 		if (gravitate[g])
-		    REGION_SUBTRACT(pScreen, oldWinClip, oldWinClip,
+		    RegionSubtract(oldWinClip, oldWinClip,
 					gravitate[g]);
 	    }
-	    REGION_TRANSLATE(pScreen, oldWinClip, oldx - nx, oldy - ny);
+	    RegionTranslate(oldWinClip, oldx - nx, oldy - ny);
 	    g = pWin->bitGravity;
 	    if (!gravitate[g])
 		gravitate[g] = oldWinClip;
 	    else
 	    {
-		REGION_UNION(pScreen, gravitate[g], gravitate[g], oldWinClip);
-		REGION_DESTROY(pScreen, oldWinClip);
+		RegionUnion(gravitate[g], gravitate[g], oldWinClip);
+		RegionDestroy(oldWinClip);
 	    }
 	}
 
@@ -875,14 +875,14 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
 	    /* only copy the remaining useful bits */
 
-	    REGION_INTERSECT(pScreen, gravitate[g], gravitate[g], oldRegion);
+	    RegionIntersect(gravitate[g], gravitate[g], oldRegion);
 
 	    /* clip to not overwrite already copied areas */
 
 	    if (destClip) {
-		REGION_TRANSLATE(pScreen, destClip, oldpt.x - x, oldpt.y - y);
-		REGION_SUBTRACT(pScreen, gravitate[g], gravitate[g], destClip);
-		REGION_TRANSLATE(pScreen, destClip, x - oldpt.x, y - oldpt.y);
+		RegionTranslate(destClip, oldpt.x - x, oldpt.y - y);
+		RegionSubtract(gravitate[g], gravitate[g], destClip);
+		RegionTranslate(destClip, x - oldpt.x, y - oldpt.y);
 	    }
 
 	    /* and move those bits */
@@ -898,7 +898,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 
 	    /* remove any overwritten bits from the remaining useful bits */
 
-	    REGION_SUBTRACT(pScreen, oldRegion, oldRegion, gravitate[g]);
+	    RegionSubtract(oldRegion, oldRegion, gravitate[g]);
 
 	    /*
 	     * recompute exposed regions of child windows
@@ -908,7 +908,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	    {
 		if (pChild->winGravity != g)
 		    continue;
-		REGION_INTERSECT(pScreen, pRegion,
+		RegionIntersect(pRegion,
 				       &pChild->borderClip, gravitate[g]);
 		TraverseTree (pChild, miRecomputeExposures, (void *)pRegion);
 	    }
@@ -919,21 +919,21 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 	     */
 
 	    if (g == pWin->bitGravity)
-		REGION_SUBTRACT(pScreen, &pWin->valdata->after.exposed,
+		RegionSubtract(&pWin->valdata->after.exposed,
 				     &pWin->valdata->after.exposed, gravitate[g]);
 	    if (!destClip)
 		destClip = gravitate[g];
 	    else
 	    {
-		REGION_UNION(pScreen, destClip, destClip, gravitate[g]);
-		REGION_DESTROY(pScreen, gravitate[g]);
+		RegionUnion(destClip, destClip, gravitate[g]);
+		RegionDestroy(gravitate[g]);
 	    }
 	}
 
-	REGION_DESTROY(pScreen, oldRegion);
-	REGION_DESTROY(pScreen, pRegion);
+	RegionDestroy(oldRegion);
+	RegionDestroy(pRegion);
 	if (destClip)
-	    REGION_DESTROY(pScreen, destClip);
+	    RegionDestroy(destClip);
 	if (bsExposed)
 	{
 	    RegionPtr	valExposed = NullRegion;
@@ -942,8 +942,8 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
 	if (anyMarked)
 	    (*pScreen->HandleExposures)(pLayerWin->parent);
@@ -960,7 +960,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
     else if (bsExposed)
     {
 	(*pScreen->WindowExposures) (pWin, NullRegion, bsExposed);
-	REGION_DESTROY(pScreen, bsExposed);
+	RegionDestroy(bsExposed);
     }
     if (pWin->realized)
 	WindowsRestructured ();
@@ -1004,8 +1004,8 @@ miSetShape(pWin)
 	    {
 		RegionPtr	borderVisible;
 
-		borderVisible = REGION_CREATE(pScreen, NullBox, 1);
-		REGION_SUBTRACT(pScreen, borderVisible,
+		borderVisible = RegionCreate(NullBox, 1);
+		RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 		pWin->valdata->before.borderVisible = borderVisible;
 	    }
@@ -1022,8 +1022,8 @@ miSetShape(pWin)
     {
 	if (pWin->backStorage)
 	{
-	    pOldClip = REGION_CREATE(pScreen, NullBox, 1);
-	    REGION_COPY(pScreen, pOldClip, &pWin->clipList);
+	    pOldClip = RegionCreate(NullBox, 1);
+	    RegionCopy(pOldClip, &pWin->clipList);
 	}
 
 	anyMarked |= (*pScreen->MarkOverlappedWindows)(pWin, pWin,
@@ -1049,7 +1049,7 @@ miSetShape(pWin)
 			     (pWin, 0, 0, pOldClip,
 			      pWin->drawable.x, pWin->drawable.y);
 	if (WasViewable)
-	    REGION_DESTROY(pScreen, pOldClip);
+	    RegionDestroy(pOldClip);
 	if (bsExposed)
 	{
 	    RegionPtr	valExposed = NullRegion;
@@ -1058,8 +1058,8 @@ miSetShape(pWin)
 		valExposed = &pWin->valdata->after.exposed;
 	    (*pScreen->WindowExposures) (pWin, valExposed, bsExposed);
 	    if (valExposed)
-		REGION_EMPTY(pScreen, valExposed);
-	    REGION_DESTROY(pScreen, bsExposed);
+		RegionEmpty(valExposed);
+	    RegionDestroy(bsExposed);
 	}
     }
     if (WasViewable)
@@ -1120,8 +1120,8 @@ miChangeBorderWidth(pWin, width)
 	    if (pWin->valdata && HadBorder)
 	    {
 		RegionPtr   borderVisible;
-		borderVisible = REGION_CREATE(pScreen, NULL, 1);
-		REGION_SUBTRACT(pScreen, borderVisible,
+		borderVisible = RegionCreate(NULL, 1);
+		RegionSubtract(borderVisible,
 				      &pWin->borderClip, &pWin->winSize);
 		pWin->valdata->before.borderVisible = borderVisible;
 	    }
@@ -1158,10 +1158,10 @@ miMarkUnrealizedWindow(pChild, pWin, fromConfigure)
 {
     if ((pChild != pWin) || fromConfigure)
     {
-	REGION_EMPTY(pChild->drawable.pScreen, &pChild->clipList);
+	RegionEmpty(&pChild->clipList);
 	if (pChild->drawable.pScreen->ClipNotify)
 	    (* pChild->drawable.pScreen->ClipNotify)(pChild, 0, 0);
-	REGION_EMPTY(pChild->drawable.pScreen, &pChild->borderClip);
+	RegionEmpty(&pChild->borderClip);
     }
 }
 
@@ -1176,7 +1176,7 @@ miSegregateChildren(WindowPtr pWin, RegionPtr pReg, int depth)
     for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib)
     {
 	if (pChild->drawable.depth == depth)
-	    REGION_UNION(pScreen, pReg, pReg, &pChild->borderClip);
+	    RegionUnion(pReg, pReg, &pChild->borderClip);
 
 	if (pChild->firstChild)
 	    miSegregateChildren(pChild, pReg, depth);
diff --git a/nx-X11/programs/Xserver/miext/cw/Imakefile b/nx-X11/programs/Xserver/miext/cw/Imakefile
index 39106ac13..795ed1987 100755
--- a/nx-X11/programs/Xserver/miext/cw/Imakefile
+++ b/nx-X11/programs/Xserver/miext/cw/Imakefile
@@ -7,7 +7,8 @@ OBJS = cw.o cw_ops.o cw_render.o
 
    INCLUDES = -I../../mi -I../../fb -I../../render -I../../composite \
 	      -I../../include -I$(XINCLUDESRC) $(EXTRAINCLUDES) \
-	      -I$(EXTINCSRC)
+	      -I$(EXTINCSRC) \
+	      `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
 	     ../../mi/llib-lmi.ln
 
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.c b/nx-X11/programs/Xserver/miext/cw/cw.c
index 8079a0009..9f39b9650 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw.c
@@ -190,8 +190,8 @@ cwValidateGC(GCPtr pGC, unsigned long stateChanges, DrawablePtr pDrawable)
 	XID vals[2];
 	RegionPtr   pCompositeClip;
 
-	pCompositeClip = REGION_CREATE (pScreen, NULL, 0);
-	REGION_COPY (pScreen, pCompositeClip, pGC->pCompositeClip);
+	pCompositeClip = RegionCreate(NULL, 0);
+	RegionCopy(pCompositeClip, pGC->pCompositeClip);
 
 	/* Either the drawable has changed, or the clip list in the drawable has
 	 * changed.  Copy the new clip list over and set the new translated
@@ -397,8 +397,8 @@ cwFillRegionSolid(DrawablePtr pDrawable, RegionPtr pRegion, unsigned long pixel)
 		NULL, v);
     ValidateGC(pDrawable, pGC);
 
-    pBox = REGION_RECTS(pRegion);
-    nbox = REGION_NUM_RECTS(pRegion);
+    pBox = RegionRects(pRegion);
+    nbox = RegionNumRects(pRegion);
 
     for (i = 0; i < nbox; i++, pBox++) {
 	xRectangle rect;
@@ -433,8 +433,8 @@ cwFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
 
     ValidateGC(pDrawable, pGC);
 
-    pBox = REGION_RECTS(pRegion);
-    nbox = REGION_NUM_RECTS(pRegion);
+    pBox = RegionRects(pRegion);
+    nbox = RegionNumRects(pRegion);
 
     for (i = 0; i < nbox; i++, pBox++) {
 	xRectangle rect;
@@ -473,7 +473,7 @@ cwPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what)
 	if (pWin && (pWin->backgroundState == BackgroundPixel ||
 		pWin->backgroundState == BackgroundPixmap))
 	{
-	    REGION_TRANSLATE(pScreen, pRegion, x_screen, y_screen);
+	    RegionTranslate(pRegion, x_screen, y_screen);
 
 	    if (pWin->backgroundState == BackgroundPixel) {
 		cwFillRegionSolid(pBackingDrawable, pRegion,
@@ -483,7 +483,7 @@ cwPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what)
 				  pWin->background.pixmap, x_off, y_off);
 	    }
 
-	    REGION_TRANSLATE(pScreen, pRegion, -x_screen, -y_screen);
+	    RegionTranslate(pRegion, -x_screen, -y_screen);
 	}
     }
 
@@ -509,7 +509,7 @@ cwPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
 	x_screen = x_off - pWin->drawable.x;
 	y_screen = y_off - pWin->drawable.y;
 
-	REGION_TRANSLATE(pScreen, pRegion, x_screen, y_screen);
+	RegionTranslate(pRegion, x_screen, y_screen);
 
 	if (pWin->borderIsPixel) {
 	    cwFillRegionSolid(pBackingDrawable, pRegion, pWin->border.pixel);
@@ -518,7 +518,7 @@ cwPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
 			      x_off, y_off);
 	}
 
-	REGION_TRANSLATE(pScreen, pRegion, -x_screen, -y_screen);
+	RegionTranslate(pRegion, -x_screen, -y_screen);
     }
 
     SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder);
@@ -545,7 +545,7 @@ cwCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 	dx = ptOldOrg.x - pWin->drawable.x;
 	dy = ptOldOrg.y - pWin->drawable.y;
 
-	pExtents = REGION_EXTENTS(pScreen, prgnSrc);
+	pExtents = RegionExtents(prgnSrc);
 
 	pBackingPixmap = (PixmapPtr) cwGetBackingDrawable((DrawablePtr)pWin,
 							  &x_off, &y_off);
@@ -558,15 +558,15 @@ cwCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 	dst_y = src_y - dy;
 			       
 	/* Translate region (as required by API) */
-	REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
+	RegionTranslate(prgnSrc, -dx, -dy);
 	
 	pGC = GetScratchGC(pBackingPixmap->drawable.depth, pScreen);
 	/*
 	 * Copy region to GC as clip, aligning as dest clip
 	 */
-	pClip = REGION_CREATE (pScreen, NULL, 0);
-	REGION_INTERSECT(pScreen, pClip, &pWin->borderClip, prgnSrc);
-	REGION_TRANSLATE(pScreen, pClip, 
+	pClip = RegionCreate(NULL, 0);
+	RegionIntersect(pClip, &pWin->borderClip, prgnSrc);
+	RegionTranslate(pClip,
 			 -pBackingPixmap->screen_x,
 			 -pBackingPixmap->screen_y);
 	
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_ops.c b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
index 9e09d0532..e4c53b79f 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw_ops.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
@@ -195,7 +195,7 @@ cwCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
 					   dstx, dsty);
 
     if (exposed != NULL)
-	REGION_TRANSLATE(pDst->pScreen, exposed, odstx - dstx, odsty - dsty);
+	RegionTranslate(exposed, odstx - dstx, odsty - dsty);
 
     EPILOGUE(pGC);
 
@@ -223,7 +223,7 @@ cwCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
 					    dstx, dsty, plane);
 
     if (exposed != NULL)
-	REGION_TRANSLATE(pDst->pScreen, exposed, odstx - dstx, odsty - dsty);
+	RegionTranslate(exposed, odstx - dstx, odsty - dsty);
 
     EPILOGUE(pGC);
 
diff --git a/nx-X11/programs/Xserver/miext/damage/Imakefile b/nx-X11/programs/Xserver/miext/damage/Imakefile
index 7fa745b65..a28786203 100755
--- a/nx-X11/programs/Xserver/miext/damage/Imakefile
+++ b/nx-X11/programs/Xserver/miext/damage/Imakefile
@@ -11,7 +11,8 @@ OBJS = damage.o
 
    INCLUDES = -I. -I../shadow -I../../mi -I../../fb -I../../include -I$(XINCLUDESRC) \
 	      -I$(XF86SRC)/common $(EXTRAINCLUDES) \
-	      -I../../render -I../cw -I$(EXTINCSRC)
+	      -I../../render -I../cw -I$(EXTINCSRC) \
+	      `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
 	     ../../mi/llib-lmi.ln
 
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
index 0dd788ec3..60e2ae4b5 100755
--- a/nx-X11/programs/Xserver/miext/damage/damage.c
+++ b/nx-X11/programs/Xserver/miext/damage/damage.c
@@ -137,7 +137,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 #endif
 
     /* short circuit for empty regions */
-    if (!REGION_NOTEMPTY(pScreen, pRegion))
+    if (!RegionNotEmpty(pRegion))
 	return;
     
 #ifdef COMPOSITE
@@ -152,7 +152,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	screen_y = ((PixmapPtr) pDrawable)->screen_y - pDrawable->y;
     }
     if (screen_x || screen_y)
-        REGION_TRANSLATE (pScreen, pRegion, screen_x, screen_y);
+        RegionTranslate(pRegion, screen_x, screen_y);
 #endif
 	
     if (pDrawable->type == DRAWABLE_WINDOW &&
@@ -160,22 +160,22 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
     {
 	if (subWindowMode == ClipByChildren)
 	{
-	    REGION_INTERSECT(pScreen, pRegion, pRegion,
+	    RegionIntersect(pRegion, pRegion,
 			     &((WindowPtr)(pDrawable))->clipList);
 	}
 	else if (subWindowMode == IncludeInferiors)
 	{
 	    RegionPtr pTempRegion =
 		NotClippedByChildren((WindowPtr)(pDrawable));
-	    REGION_INTERSECT(pScreen, pRegion, pRegion, pTempRegion);
-	    REGION_DESTROY(pScreen, pTempRegion);
+	    RegionIntersect(pRegion, pRegion, pTempRegion);
+	    RegionDestroy(pTempRegion);
 	}
 	/* If subWindowMode is set to an invalid value, don't perform
 	 * any drawable-based clipping. */
     }
         
 
-    REGION_NULL (pScreen, &clippedRec);
+    RegionNull(&clippedRec);
     for (; pDamage; pDamage = pNext)
     {
 	pNext = pDamage->pNext;
@@ -223,7 +223,7 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	{
 	    pDamageRegion = &clippedRec;
 	    if (pDamage->pDrawable->type == DRAWABLE_WINDOW) {
-		REGION_INTERSECT (pScreen, pDamageRegion, pRegion,
+		RegionIntersect(pDamageRegion, pRegion,
 		    &((WindowPtr)(pDamage->pDrawable))->borderClip);
 	    } else {
 		BoxRec	box;
@@ -231,14 +231,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 		box.y1 = draw_y;
 		box.x2 = draw_x + pDamage->pDrawable->width;
 		box.y2 = draw_y + pDamage->pDrawable->height;
-		REGION_INIT(pScreen, &pixClip, &box, 1);
-		REGION_INTERSECT (pScreen, pDamageRegion, pRegion, &pixClip);
-		REGION_UNINIT(pScreen, &pixClip);
+		RegionInit(&pixClip, &box, 1);
+		RegionIntersect(pDamageRegion, pRegion, &pixClip);
+		RegionUninit(&pixClip);
 	    }
 	    /*
 	     * Short circuit empty results
 	     */
-	    if (!REGION_NOTEMPTY(pScreen, pDamageRegion))
+	    if (!RegionNotEmpty(pDamageRegion))
 		continue;
 	}
 	
@@ -253,39 +253,39 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	 * Move region to target coordinate space
 	 */
 	if (draw_x || draw_y)
-	    REGION_TRANSLATE (pScreen, pDamageRegion, -draw_x, -draw_y);
+	    RegionTranslate(pDamageRegion, -draw_x, -draw_y);
 	
 	switch (pDamage->damageLevel) {
 	case DamageReportRawRegion:
 	    (*pDamage->damageReport) (pDamage, pDamageRegion, pDamage->closure);
 	    break;
 	case DamageReportDeltaRegion:
-	    REGION_NULL (pScreen, &tmpRegion);
-	    REGION_SUBTRACT (pScreen, &tmpRegion, pDamageRegion, &pDamage->damage);
-	    if (REGION_NOTEMPTY (pScreen, &tmpRegion))
+	    RegionNull(&tmpRegion);
+	    RegionSubtract(&tmpRegion, pDamageRegion, &pDamage->damage);
+	    if (RegionNotEmpty(&tmpRegion))
 	    {
-		REGION_UNION(pScreen, &pDamage->damage,
+		RegionUnion(&pDamage->damage,
 			     &pDamage->damage, pDamageRegion);
 		(*pDamage->damageReport) (pDamage, &tmpRegion, pDamage->closure);
 	    }
-	    REGION_UNINIT(pScreen, &tmpRegion);
+	    RegionUninit(&tmpRegion);
 	    break;
 	case DamageReportBoundingBox:
-	    tmpBox = *REGION_EXTENTS (pScreen, &pDamage->damage);
-	    REGION_UNION(pScreen, &pDamage->damage,
+	    tmpBox = *RegionExtents(&pDamage->damage);
+	    RegionUnion(&pDamage->damage,
 			 &pDamage->damage, pDamageRegion);
-	    if (!BOX_SAME (&tmpBox, REGION_EXTENTS (pScreen, &pDamage->damage)))
+	    if (!BOX_SAME (&tmpBox, RegionExtents(&pDamage->damage)))
 		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
 	    break;
 	case DamageReportNonEmpty:
-	    was_empty = !REGION_NOTEMPTY(pScreen, &pDamage->damage);
-	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+	    was_empty = !RegionNotEmpty(&pDamage->damage);
+	    RegionUnion(&pDamage->damage, &pDamage->damage,
 			 pDamageRegion);
-	    if (was_empty && REGION_NOTEMPTY(pScreen, &pDamage->damage))
+	    if (was_empty && RegionNotEmpty(&pDamage->damage))
 		(*pDamage->damageReport) (pDamage, &pDamage->damage, pDamage->closure);
 	    break;
 	case DamageReportNone:
-	    REGION_UNION(pScreen, &pDamage->damage, &pDamage->damage,
+	    RegionUnion(&pDamage->damage, &pDamage->damage,
 			 pDamageRegion);
 	    break;
 	}
@@ -293,14 +293,14 @@ damageDamageRegion (DrawablePtr pDrawable, RegionPtr pRegion, Bool clip,
 	 * translate original region back
 	 */
 	if (pDamageRegion == pRegion && (draw_x || draw_y))
-	    REGION_TRANSLATE (pScreen, pDamageRegion, draw_x, draw_y);
+	    RegionTranslate(pDamageRegion, draw_x, draw_y);
     }
 #ifdef COMPOSITE
     if (screen_x || screen_y)
-	REGION_TRANSLATE (pScreen, pRegion, -screen_x, -screen_y);
+	RegionTranslate(pRegion, -screen_x, -screen_y);
 #endif
     
-    REGION_UNINIT (pScreen, &clippedRec);
+    RegionUninit(&clippedRec);
 }
 
 #if DAMAGE_DEBUG_ENABLE
@@ -314,13 +314,13 @@ damageDamageBox (DrawablePtr pDrawable, BoxPtr pBox, int subWindowMode)
 {
     RegionRec	region;
 
-    REGION_INIT (pDrawable->pScreen, &region, pBox, 1);
+    RegionInit(&region, pBox, 1);
 #if DAMAGE_DEBUG_ENABLE
     _damageDamageRegion (pDrawable, &region, TRUE, subWindowMode, where);
 #else
     damageDamageRegion (pDrawable, &region, TRUE, subWindowMode);
 #endif
-    REGION_UNINIT (pDrawable->pScreen, &region);
+    RegionUninit(&region);
 }
 
 static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
@@ -489,7 +489,7 @@ damageDestroyClip(GCPtr pGC)
 
 #define checkGCDamage(d,g)	(getDrawableDamage(d) && \
 				 (!g->pCompositeClip ||\
-				  REGION_NOTEMPTY(d->pScreen, \
+				  RegionNotEmpty(\
 						  g->pCompositeClip)))
 
 #ifdef RENDER
@@ -503,7 +503,7 @@ damageDestroyClip(GCPtr pGC)
     }
     
 #define checkPictureDamage(p)	(getDrawableDamage(p->pDrawable) && \
-				 REGION_NOTEMPTY(pScreen, p->pCompositeClip))
+				 RegionNotEmpty(p->pCompositeClip))
 
 static void
 damageComposite (CARD8      op,
@@ -1615,9 +1615,9 @@ damageCopyWindow(WindowPtr	pWindow,
 	 * The region comes in source relative, but the damage occurs
 	 * at the destination location.  Translate back and forth.
 	 */
-	REGION_TRANSLATE (pScreen, prgnSrc, dx, dy);
+	RegionTranslate(prgnSrc, dx, dy);
 	damageDamageRegion (&pWindow->drawable, prgnSrc, FALSE, -1);
-	REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
+	RegionTranslate(prgnSrc, -dx, -dy);
     }
     unwrap (pScrPriv, pScreen, CopyWindow);
     (*pScreen->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
@@ -1820,7 +1820,7 @@ DamageCreate (DamageReportFunc  damageReport,
 	return 0;
     pDamage->pNext = 0;
     pDamage->pNextWin = 0;
-    REGION_NULL(pScreen, &pDamage->damage);
+    RegionNull(&pDamage->damage);
     
     pDamage->damageLevel = damageLevel;
     pDamage->isInternal = isInternal;
@@ -1909,7 +1909,7 @@ DamageDestroy (DamagePtr    pDamage)
 {
     if (pDamage->damageDestroy)
 	(*pDamage->damageDestroy) (pDamage, pDamage->closure);
-    REGION_UNINIT (pDamage->pDrawable->pScreen, &pDamage->damage);
+    RegionUninit(&pDamage->damage);
     xfree (pDamage);
 }
 
@@ -1921,7 +1921,7 @@ DamageSubtract (DamagePtr	    pDamage,
     RegionRec	pixmapClip;
     DrawablePtr	pDrawable = pDamage->pDrawable;
     
-    REGION_SUBTRACT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pRegion);
+    RegionSubtract(&pDamage->damage, &pDamage->damage, pRegion);
     if (pDrawable)
     {
 	if (pDrawable->type == DRAWABLE_WINDOW)
@@ -1934,22 +1934,22 @@ DamageSubtract (DamagePtr	    pDamage,
 	    box.y1 = pDrawable->y;
 	    box.x2 = pDrawable->x + pDrawable->width;
 	    box.y2 = pDrawable->y + pDrawable->height;
-	    REGION_INIT (pDrawable->pScreen, &pixmapClip, &box, 1);
+	    RegionInit(&pixmapClip, &box, 1);
 	    pClip = &pixmapClip;
 	}
-	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, pDrawable->x, pDrawable->y);
-	REGION_INTERSECT (pDrawable->pScreen, &pDamage->damage, &pDamage->damage, pClip);
-	REGION_TRANSLATE (pDrawable->pScreen, &pDamage->damage, -pDrawable->x, -pDrawable->y);
+	RegionTranslate(&pDamage->damage, pDrawable->x, pDrawable->y);
+	RegionIntersect(&pDamage->damage, &pDamage->damage, pClip);
+	RegionTranslate(&pDamage->damage, -pDrawable->x, -pDrawable->y);
 	if (pDrawable->type != DRAWABLE_WINDOW)
-	    REGION_UNINIT(pDrawable->pScreen, &pixmapClip);
+	    RegionUninit(&pixmapClip);
     }
-    return REGION_NOTEMPTY (pDrawable->pScreen, &pDamage->damage);
+    return RegionNotEmpty(&pDamage->damage);
 }
 
 void
 DamageEmpty (DamagePtr	    pDamage)
 {
-    REGION_EMPTY (pDamage->pDrawable->pScreen, &pDamage->damage);
+    RegionEmpty(&pDamage->damage);
 }
 
 RegionPtr
diff --git a/nx-X11/programs/Xserver/os/Imakefile b/nx-X11/programs/Xserver/os/Imakefile
index 18bb9804d..5245b7841 100644
--- a/nx-X11/programs/Xserver/os/Imakefile
+++ b/nx-X11/programs/Xserver/os/Imakefile
@@ -158,7 +158,8 @@ BOOTSTRAPCFLAGS =
 		  $(RANDOM_DEFINES) $(BUGMSG) $(XTRANS_FAILDEFINES) $(NX_DEFINES)
        INCLUDES = -I. -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) \
 		  -I$(SERVERSRC)/Xext -I$(SERVERSRC)/render \
-		  -I$(TOP)/lib/Xau Krb5Includes $(NX_INCLUDES)
+		  -I$(TOP)/lib/Xau Krb5Includes $(NX_INCLUDES) \
+		  `pkg-config --cflags-only-I pixman-1`
  DEPEND_DEFINES = $(DBM_DEFINES) $(XDMCP_DEFINES) $(EXT_DEFINES) \
 		  $(TRANS_INCLUDES) $(CONNECTION_FLAGS) $(GETPEER_DEFINES) \
 		  DependDefines
diff --git a/nx-X11/programs/Xserver/os/oscolor.c b/nx-X11/programs/Xserver/os/oscolor.c
index e8692a92c..a8b01b4b9 100644
--- a/nx-X11/programs/Xserver/os/oscolor.c
+++ b/nx-X11/programs/Xserver/os/oscolor.c
@@ -98,8 +98,8 @@ int rgb_dbm = 0;
 #endif
 
 extern void CopyISOLatin1Lowered(
-    unsigned char * /*dest*/,
-    unsigned char * /*source*/,
+    char * /*dest*/,
+    const char * /*source*/,
     int /*length*/);
 
 int
@@ -191,8 +191,8 @@ typedef struct _dbEntry {
 
 
 extern void CopyISOLatin1Lowered(
-    unsigned char * /*dest*/,
-    unsigned char * /*source*/,
+    char * /*dest*/,
+    const char * /*source*/,
     int /*length*/);
 
 static dbEntryPtr hashTab[HASHSIZE];
@@ -354,7 +354,7 @@ lookup(char *name, int len, Bool create)
   char         *str = name;
 
   if (!(name = (char*)ALLOCATE_LOCAL(len +1))) return NULL;
-  CopyISOLatin1Lowered((unsigned char *)name, (unsigned char *)str, len);
+  CopyISOLatin1Lowered(name, str, len);
   name[len] = '\0';
 
   for(str = name; *str; str++) {
diff --git a/nx-X11/programs/Xserver/randr/Imakefile b/nx-X11/programs/Xserver/randr/Imakefile
index 19f8143e4..7f920aece 100644
--- a/nx-X11/programs/Xserver/randr/Imakefile
+++ b/nx-X11/programs/Xserver/randr/Imakefile
@@ -23,7 +23,9 @@ XCOMM $XFree86: xc/programs/Xserver/randr/Imakefile,v 1.1 2001/05/23 03:29:44 ke
 
    INCLUDES = -I../include -I../mi \
 		-I../fb -I../hw/kdrive -I$(EXTINCSRC) -I$(XINCLUDESRC) \
-		-I../render
+		-I../render \
+		`pkg-config --cflags-only-I pixman-1`
+
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
     DEFINES = -DNXAGENT_SERVER
diff --git a/nx-X11/programs/Xserver/record/Imakefile b/nx-X11/programs/Xserver/record/Imakefile
index 4d4bf6a73..c24cbb0d9 100644
--- a/nx-X11/programs/Xserver/record/Imakefile
+++ b/nx-X11/programs/Xserver/record/Imakefile
@@ -16,7 +16,7 @@ XCOMM $XFree86: xc/programs/Xserver/record/Imakefile,v 1.12 2001/11/02 23:29:34
 #endif
        SRCS = record.c set.c
        OBJS = record.o set.o
-   INCLUDES = -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/Xext
+   INCLUDES = -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/Xext `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../dix/llib-ldix.ln
     DEFINES = -DNDEBUG
 
diff --git a/nx-X11/programs/Xserver/render/Imakefile b/nx-X11/programs/Xserver/render/Imakefile
index 1331b1fb4..23f9476ea 100644
--- a/nx-X11/programs/Xserver/render/Imakefile
+++ b/nx-X11/programs/Xserver/render/Imakefile
@@ -29,7 +29,8 @@ XCOMM $XFree86: xc/programs/Xserver/render/Imakefile,v 1.10 2002/11/23 02:38:15
 
    INCLUDES = -I. -I../include -I../mi \
                 -I../fb -I../hw/kdrive -I$(EXTINCSRC) -I$(XINCLUDESRC) \
-                -I../Xext
+                -I../Xext \
+                `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
 NormalLibraryTarget(render,$(OBJS))
diff --git a/nx-X11/programs/Xserver/render/glyph.c b/nx-X11/programs/Xserver/render/glyph.c
index 900cf9844..f15b199b5 100644
--- a/nx-X11/programs/Xserver/render/glyph.c
+++ b/nx-X11/programs/Xserver/render/glyph.c
@@ -43,11 +43,7 @@
 #include "picturestr.h"
 #include "glyphstr.h"
 
-#if HAVE_STDINT_H
 #include <stdint.h>
-#elif !defined(UINT32_MAX)
-#define UINT32_MAX 0xffffffffU
-#endif
 
 /*
  * From Knuth -- a good choice for hash/rehash values is p, p-2 where
diff --git a/nx-X11/programs/Xserver/render/mipict.c b/nx-X11/programs/Xserver/render/mipict.c
index cf9c27f01..ae7cf5a6d 100644
--- a/nx-X11/programs/Xserver/render/mipict.c
+++ b/nx-X11/programs/Xserver/render/mipict.c
@@ -48,7 +48,7 @@ void
 miDestroyPicture (PicturePtr pPicture)
 {
     if (pPicture->freeCompClip)
-	REGION_DESTROY(pPicture->pDrawable->pScreen, pPicture->pCompositeClip);
+	RegionDestroy(pPicture->pCompositeClip);
 }
 
 void
@@ -65,7 +65,7 @@ miDestroyPictureClip (PicturePtr pPicture)
 	 * we know we'll never have a list of rectangles, since ChangeClip
 	 * immediately turns them into a region
 	 */
-	REGION_DESTROY(pPicture->pDrawable->pScreen, pPicture->clientClip);
+	RegionDestroy(pPicture->clientClip);
 	break;
     }
     pPicture->clientClip = NULL;
@@ -86,7 +86,7 @@ miChangePictureClip (PicturePtr    pPicture,
     switch (type) {
     case CT_PIXMAP:
 	/* convert the pixmap to a region */
-	clientClip = (void *) BITMAP_TO_REGION(pScreen, (PixmapPtr) value);
+	clientClip = (void *) BitmapToRegion(pScreen, (PixmapPtr) value);
 	if (!clientClip)
 	    return BadAlloc;
 	clientClipType = CT_REGION;
@@ -101,7 +101,7 @@ miChangePictureClip (PicturePtr    pPicture,
 	clientClipType = CT_NONE;
 	break;
     default:
-	clientClip = (void *) RECTS_TO_REGION(pScreen, n,
+	clientClip = (void *) RegionFromRects(n,
 					       (xRectangle *) value,
 					       type);
 	if (!clientClip)
@@ -162,7 +162,7 @@ miValidatePicture (PicturePtr pPicture,
 	    if (pPicture->clientClipType == CT_NONE)
 	    {
 		if (freeCompClip)
-		    REGION_DESTROY(pScreen, pPicture->pCompositeClip);
+		    RegionDestroy(pPicture->pCompositeClip);
 		pPicture->pCompositeClip = pregWin;
 		pPicture->freeCompClip = freeTmpClip;
 	    }
@@ -177,30 +177,30 @@ miValidatePicture (PicturePtr pPicture,
 		 * clip. if neither is real, create a new region.
 		 */
 
-		REGION_TRANSLATE(pScreen, pPicture->clientClip,
+		RegionTranslate(pPicture->clientClip,
 				 pDrawable->x + pPicture->clipOrigin.x,
 				 pDrawable->y + pPicture->clipOrigin.y);
 
 		if (freeCompClip)
 		{
-		    REGION_INTERSECT(pScreen, pPicture->pCompositeClip,
+		    RegionIntersect(pPicture->pCompositeClip,
 				     pregWin, pPicture->clientClip);
 		    if (freeTmpClip)
-			REGION_DESTROY(pScreen, pregWin);
+			RegionDestroy(pregWin);
 		}
 		else if (freeTmpClip)
 		{
-		    REGION_INTERSECT(pScreen, pregWin, pregWin, pPicture->clientClip);
+		    RegionIntersect(pregWin, pregWin, pPicture->clientClip);
 		    pPicture->pCompositeClip = pregWin;
 		}
 		else
 		{
-		    pPicture->pCompositeClip = REGION_CREATE(pScreen, NullBox, 0);
-		    REGION_INTERSECT(pScreen, pPicture->pCompositeClip,
+		    pPicture->pCompositeClip = RegionCreate(NullBox, 0);
+		    RegionIntersect(pPicture->pCompositeClip,
 				     pregWin, pPicture->clientClip);
 		}
 		pPicture->freeCompClip = TRUE;
-		REGION_TRANSLATE(pScreen, pPicture->clientClip,
+		RegionTranslate(pPicture->clientClip,
 				 -(pDrawable->x + pPicture->clipOrigin.x),
 				 -(pDrawable->y + pPicture->clipOrigin.y));
 	    }
@@ -218,31 +218,31 @@ miValidatePicture (PicturePtr pPicture,
 
 	    if (pPicture->freeCompClip)
 	    {
-		REGION_RESET(pScreen, pPicture->pCompositeClip, &pixbounds);
+		RegionReset(pPicture->pCompositeClip, &pixbounds);
 	    }
 	    else
 	    {
 		pPicture->freeCompClip = TRUE;
-		pPicture->pCompositeClip = REGION_CREATE(pScreen, &pixbounds, 1);
+		pPicture->pCompositeClip = RegionCreate(&pixbounds, 1);
 	    }
 
 	    if (pPicture->clientClipType == CT_REGION)
 	    {
 		if(pDrawable->x || pDrawable->y) {
-		    REGION_TRANSLATE(pScreen, pPicture->clientClip,
+		    RegionTranslate(pPicture->clientClip,
 				     pDrawable->x + pPicture->clipOrigin.x, 
 				     pDrawable->y + pPicture->clipOrigin.y);
-		    REGION_INTERSECT(pScreen, pPicture->pCompositeClip,
+		    RegionIntersect(pPicture->pCompositeClip,
 				     pPicture->pCompositeClip, pPicture->clientClip);
-		    REGION_TRANSLATE(pScreen, pPicture->clientClip,
+		    RegionTranslate(pPicture->clientClip,
 				     -(pDrawable->x + pPicture->clipOrigin.x), 
 				     -(pDrawable->y + pPicture->clipOrigin.y));
 		} else {
-		    REGION_TRANSLATE(pScreen, pPicture->pCompositeClip,
+		    RegionTranslate(pPicture->pCompositeClip,
 				     -pPicture->clipOrigin.x, -pPicture->clipOrigin.y);
-		    REGION_INTERSECT(pScreen, pPicture->pCompositeClip,
+		    RegionIntersect(pPicture->pCompositeClip,
 				     pPicture->pCompositeClip, pPicture->clientClip);
-		    REGION_TRANSLATE(pScreen, pPicture->pCompositeClip,
+		    RegionTranslate(pPicture->pCompositeClip,
 				     pPicture->clipOrigin.x, pPicture->clipOrigin.y);
 		}
 	    }
@@ -274,11 +274,11 @@ miClipPictureReg (RegionPtr	pRegion,
 		  int		dx,
 		  int		dy)
 {
-    if (REGION_NUM_RECTS(pRegion) == 1 &&
-	REGION_NUM_RECTS(pClip) == 1)
+    if (RegionNumRects(pRegion) == 1 &&
+	RegionNumRects(pClip) == 1)
     {
-	BoxPtr  pRbox = REGION_RECTS(pRegion);
-	BoxPtr  pCbox = REGION_RECTS(pClip);
+	BoxPtr  pRbox = RegionRects(pRegion);
+	BoxPtr  pCbox = RegionRects(pClip);
 	int	v;
 
 	if (pRbox->x1 < (v = pCbox->x1 + dx))
@@ -292,21 +292,21 @@ miClipPictureReg (RegionPtr	pRegion,
 	if (pRbox->x1 >= pRbox->x2 ||
 	    pRbox->y1 >= pRbox->y2)
 	{
-	    REGION_EMPTY(pScreen, pRegion);
+	    RegionEmpty(pRegion);
 	}
     }
-    else if (!REGION_NOTEMPTY (pScreen, pClip))
+    else if (!RegionNotEmpty(pClip))
 	return FALSE;
     else
     {
 	if (dx || dy)
-	    REGION_TRANSLATE(pScreen, pRegion, -dx, -dy);
-	if (!REGION_INTERSECT (pScreen, pRegion, pRegion, pClip))
+	    RegionTranslate(pRegion, -dx, -dy);
+	if (!RegionIntersect(pRegion, pRegion, pClip))
 	    return FALSE;
 	if (dx || dy)
-	    REGION_TRANSLATE(pScreen, pRegion, dx, dy);
+	    RegionTranslate(pRegion, dx, dy);
     }
-    return REGION_NOTEMPTY(pScreen, pRegion);
+    return RegionNotEmpty(pRegion);
 }
 		  
 static __inline Bool
@@ -322,13 +322,13 @@ miClipPictureSrc (RegionPtr	pRegion,
     {
 	if (pPicture->clientClipType != CT_NONE)
 	{
-	    REGION_TRANSLATE(pScreen, pRegion, 
+	    RegionTranslate(pRegion,
 			     dx - pPicture->clipOrigin.x,
 			     dy - pPicture->clipOrigin.y);
-	    if (!REGION_INTERSECT (pScreen, pRegion, pRegion, 
+	    if (!RegionIntersect(pRegion, pRegion,
 				   (RegionPtr) pPicture->clientClip))
 		return FALSE;
-	    REGION_TRANSLATE(pScreen, pRegion, 
+	    RegionTranslate(pRegion,
 			     - (dx - pPicture->clipOrigin.x),
 			     - (dy - pPicture->clipOrigin.y));
 	}
@@ -432,13 +432,13 @@ miComputeCompositeRegion (RegionPtr	pRegion,
     if (pRegion->extents.x1 >= pRegion->extents.x2 ||
 	pRegion->extents.y1 >= pRegion->extents.y2)
     {
-	REGION_EMPTY (pDst->pDrawable->pScreen, pRegion);
+	RegionEmpty(pRegion);
 	return FALSE;
     }
     /* clip against dst */
     if (!miClipPictureReg (pRegion, pDst->pCompositeClip, 0, 0))
     {
-	REGION_UNINIT (pScreen, pRegion);
+	RegionUninit(pRegion);
 	return FALSE;
     }
     if (pDst->alphaMap)
@@ -447,14 +447,14 @@ miComputeCompositeRegion (RegionPtr	pRegion,
 			       -pDst->alphaOrigin.x,
 			       -pDst->alphaOrigin.y))
 	{
-	    REGION_UNINIT (pScreen, pRegion);
+	    RegionUninit(pRegion);
 	    return FALSE;
 	}
     }
     /* clip against src */
     if (!miClipPictureSrc (pRegion, pSrc, xDst - xSrc, yDst - ySrc))
     {
-	REGION_UNINIT (pScreen, pRegion);
+	RegionUninit(pRegion);
 	return FALSE;
     }
     if (pSrc->alphaMap)
@@ -463,7 +463,7 @@ miComputeCompositeRegion (RegionPtr	pRegion,
 			       xDst - (xSrc + pSrc->alphaOrigin.x),
 			       yDst - (ySrc + pSrc->alphaOrigin.y)))
 	{
-	    REGION_UNINIT (pScreen, pRegion);
+	    RegionUninit(pRegion);
 	    return FALSE;
 	}
     }
@@ -472,7 +472,7 @@ miComputeCompositeRegion (RegionPtr	pRegion,
     {
 	if (!miClipPictureSrc (pRegion, pMask, xDst - xMask, yDst - yMask))
 	{
-	    REGION_UNINIT (pScreen, pRegion);
+	    RegionUninit(pRegion);
 	    return FALSE;
 	}	
 	if (pMask->alphaMap)
@@ -481,7 +481,7 @@ miComputeCompositeRegion (RegionPtr	pRegion,
 				   xDst - (xMask + pMask->alphaOrigin.x),
 				   yDst - (yMask + pMask->alphaOrigin.y)))
 	    {
-		REGION_UNINIT (pScreen, pRegion);
+		RegionUninit(pRegion);
 		return FALSE;
 	    }
 	}
diff --git a/nx-X11/programs/Xserver/render/mirect.c b/nx-X11/programs/Xserver/render/mirect.c
index c4aeb9aba..3ce7a7f4c 100644
--- a/nx-X11/programs/Xserver/render/mirect.c
+++ b/nx-X11/programs/Xserver/render/mirect.c
@@ -65,8 +65,8 @@ miColorRects (PicturePtr    pDst,
 	tmpval[4] = pDst->clipOrigin.y - yoff;
 	mask |= GCClipXOrigin|GCClipYOrigin;
 	
-	pClip = REGION_CREATE (pScreen, NULL, 1);
-	REGION_COPY (pScreen, pClip,
+	pClip = RegionCreate(NULL, 1);
+	RegionCopy(pClip,
 		     (RegionPtr) pClipPict->clientClip);
 	(*pGC->funcs->ChangeClip) (pGC, CT_REGION, pClip, 0);
     }
diff --git a/nx-X11/programs/Xserver/render/picture.c b/nx-X11/programs/Xserver/render/picture.c
index 754d468bb..5d8496610 100644
--- a/nx-X11/programs/Xserver/render/picture.c
+++ b/nx-X11/programs/Xserver/render/picture.c
@@ -1390,7 +1390,7 @@ SetPictureClipRects (PicturePtr	pPicture,
     RegionPtr		clientClip;
     int			result;
 
-    clientClip = RECTS_TO_REGION(pScreen,
+    clientClip = RegionFromRects(
 				 nRect, rects, CT_UNSORTED);
     if (!clientClip)
 	return BadAlloc;
@@ -1421,14 +1421,14 @@ SetPictureClipRegion (PicturePtr    pPicture,
     if (pRegion)
     {
         type = CT_REGION;
-        clientClip = REGION_CREATE (pScreen,
-                                    REGION_EXTENTS(pScreen, pRegion),
-                                    REGION_NUM_RECTS(pRegion));
+        clientClip = RegionCreate(
+                                    RegionExtents(pRegion),
+                                    RegionNumRects(pRegion));
         if (!clientClip)
             return BadAlloc;
-        if (!REGION_COPY (pSCreen, clientClip, pRegion))
+        if (!RegionCopy(clientClip, pRegion))
         {
-            REGION_DESTROY (pScreen, clientClip);
+            RegionDestroy(clientClip);
             return BadAlloc;
         }
     }
@@ -1538,9 +1538,9 @@ CopyPicture (PicturePtr	pSrc,
 		    RegionPtr clientClip;
 		    RegionPtr srcClientClip = (RegionPtr)pSrc->clientClip;
 
-		    clientClip = REGION_CREATE(pSrc->pDrawable->pScreen,
-			REGION_EXTENTS(pSrc->pDrawable->pScreen, srcClientClip),
-			REGION_NUM_RECTS(srcClientClip));
+		    clientClip = RegionCreate(
+			RegionExtents(srcClientClip),
+			RegionNumRects(srcClientClip));
 		    (*ps->ChangePictureClip)(pDst, CT_REGION, clientClip, 0);
 		}
 		break;
diff --git a/nx-X11/programs/Xserver/xfixes/Imakefile b/nx-X11/programs/Xserver/xfixes/Imakefile
index e467ed149..84f7c6f16 100755
--- a/nx-X11/programs/Xserver/xfixes/Imakefile
+++ b/nx-X11/programs/Xserver/xfixes/Imakefile
@@ -5,7 +5,8 @@
        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
 
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index cb9e0de9a..0b1865cf0 100755
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -43,20 +43,20 @@ 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,7 +84,7 @@ 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, (void *) pRegion))
@@ -127,7 +127,7 @@ 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;
@@ -229,7 +229,7 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
     
     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;
@@ -278,7 +278,7 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
     
     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;
@@ -353,15 +353,15 @@ ProcXFixesSetRegion (ClientPtr client)
 	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);
 }
 
@@ -387,7 +387,7 @@ ProcXFixesCopyRegion (ClientPtr client)
     VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
     
-    if (!REGION_COPY(pScreen, pDestination, pSource))
+    if (!RegionCopy(pDestination, pSource))
 	return BadAlloc;
 
     return(client->noClientException);
@@ -420,15 +420,15 @@ ProcXFixesCombineRegion (ClientPtr client)
     
     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;
     }
@@ -477,7 +477,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)
@@ -511,7 +511,7 @@ ProcXFixesTranslateRegion (ClientPtr client)
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
     VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
 
-    REGION_TRANSLATE(pScreen, pRegion, stuff->dx, stuff->dy);
+    RegionTranslate(pRegion, stuff->dx, stuff->dy);
     return (client->noClientException);
 }
 
@@ -539,7 +539,7 @@ ProcXFixesRegionExtents (ClientPtr client)
     VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
 
-    REGION_RESET (0, pDestination, REGION_EXTENTS (0, pSource));
+    RegionReset(pDestination, RegionExtents(pSource));
 
     return (client->noClientException);
 }
@@ -571,9 +571,9 @@ ProcXFixesFetchRegion (ClientPtr client)
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
     VERIFY_REGION(pRegion, stuff->region, client, SecurityReadAccess);
 
-    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) +
 		    nBox * sizeof (xRectangle));
@@ -716,7 +716,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 +739,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);
@@ -818,8 +818,8 @@ ProcXFixesExpandRegion (ClientPtr client)
     VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
     VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
     
-    nBoxes = REGION_NUM_RECTS(pSource);
-    pSrc = REGION_RECTS(pSource);
+    nBoxes = RegionNumRects(pSource);
+    pSrc = RegionRects(pSource);
     if (nBoxes)
     {
 	pTmp = xalloc (nBoxes * sizeof (BoxRec));
@@ -832,12 +832,12 @@ 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);
 	}
     }
     if (ret == Success) 
diff --git a/nx-X11/programs/Xserver/xkb/Imakefile b/nx-X11/programs/Xserver/xkb/Imakefile
index 2ac6fe32d..e63ca4462 100644
--- a/nx-X11/programs/Xserver/xkb/Imakefile
+++ b/nx-X11/programs/Xserver/xkb/Imakefile
@@ -51,7 +51,8 @@ XF86INCLUDES = -I$(XF86COMSRC) -I$(XF86OSSRC)
 	    XKBMisc.o XKBMAlloc.o XKBAlloc.o XKBGAlloc.o \
 	    $(XKBXI_OBJS) $(DDX_OBJS)
    INCLUDES = -I../include -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/Xext \
-	      -I$(SERVERSRC)/mi $(XF86INCLUDES)
+	      -I$(SERVERSRC)/mi $(XF86INCLUDES) \
+	      `pkg-config --cflags-only-I pixman-1`
    LINTLIBS = ../dix/llib-ldix.ln ../os/llib-los.ln
 
 DEFINES = -DXKB_IN_SERVER $(EXTRA_ALLOC_DEFINES) $(XKB_DDXDEFS) $(NX_DEFINES)
diff --git a/nx-X11/programs/Xserver/xkb/ddxFakeMtn.c b/nx-X11/programs/Xserver/xkb/ddxFakeMtn.c
index 33fa49ae7..7f096683b 100644
--- a/nx-X11/programs/Xserver/xkb/ddxFakeMtn.c
+++ b/nx-X11/programs/Xserver/xkb/ddxFakeMtn.c
@@ -64,12 +64,12 @@ ScreenPtr	   pScreen, oldScreen;
 	BoxRec box;
 	int i;
 
-	if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+	if(!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
 							    oldX, oldY, &box)) {
 	    FOR_NSCREENS(i) {
 		if(i == pScreen->myNum)
 		    continue;
-		if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i],
+		if(RegionContainsPoint(&XineramaScreenRegions[i],
 				   oldX, oldY, &box)) {
 		    pScreen = screenInfo.screens[i];
 		    break;
@@ -85,12 +85,12 @@ ScreenPtr	   pScreen, oldScreen;
 	     oldY=  y;
 	else oldY+= y;
 
-	if(!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
+	if(!RegionContainsPoint(&XineramaScreenRegions[pScreen->myNum],
 							    oldX, oldY, &box)) {
 	    FOR_NSCREENS(i) {
 		if(i == pScreen->myNum)
 		    continue;
-		if(POINT_IN_REGION(pScreen, &XineramaScreenRegions[i],
+		if(RegionContainsPoint(&XineramaScreenRegions[i],
 				   oldX, oldY, &box)) {
 		    pScreen = screenInfo.screens[i];
 		    break;