An experimental pseudocolor emulation layer. Not fully completed, currently

    only works for 16bpp.

2 files changed, 2350 insertions, 0 deletions

diff --git a/fb/fbpseudocolor.c b/fb/fbpseudocolor.c
new file mode 100644
index 000000000..c06233692
--- /dev/null
+++ b/fb/fbpseudocolor.c
@@ -0,0 +1,2330 @@
+#include "X.h"
+#include "Xproto.h"
+#include "scrnintstr.h"
+#include "colormapst.h"
+#include "resource.h"
+#include "font.h"
+#include "dixfontstr.h"
+#include "fontstruct.h"
+#include "micmap.h"
+#include "fb.h"
+#include "fbpseudocolor.h"
+
+static Bool xxCreateGC(GCPtr pGC);
+static void xxValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
+static void xxDestroyGC(GCPtr pGC);
+static void xxChangeGC (GCPtr pGC, unsigned long   mask);
+static void xxCopyGC (GCPtr pGCSrc, unsigned long   mask, GCPtr pGCDst);
+static void xxChangeClip (GCPtr pGC, int type, pointer pvalue, int nrects);
+
+static void xxCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
+static void xxDestroyClip(GCPtr pGC);
+static void xxFillSpans(DrawablePtr pDraw, GC *pGC, int nInit,
+			DDXPointPtr pptInit, int *pwidthInit, int fSorted);
+static void xxSetSpans(DrawablePtr pDraw, GCPtr	pGC, char *pcharsrc,
+		       DDXPointPtr pptInit, int	*pwidthInit, int nspans,
+		       int fSorted);
+static void xxPutImage(DrawablePtr pDraw, GCPtr	pGC, int depth, int x, int y,
+		       int w, int h,int	leftPad, int format, char *pImage);
+static RegionPtr xxCopyPlane(DrawablePtr pSrc,
+			     DrawablePtr pDst, GCPtr pGC,int srcx, int srcy,
+			     int width, int height, int	dstx, int dsty,
+			     unsigned long bitPlane);
+static void xxPolyPoint(DrawablePtr pDraw, GCPtr pGC, int mode, int npt,
+			xPoint *pptInit);
+static void xxPolylines(DrawablePtr pDraw, GCPtr pGC, int mode,
+			int npt, DDXPointPtr pptInit);
+static void xxPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg,
+			  xSegment *pSeg);
+static void xxPolyRectangle(DrawablePtr  pDraw, GCPtr pGC, int nRects,
+			    xRectangle  *pRects);
+static void xxPolyArc( DrawablePtr pDraw, GCPtr	pGC, int narcs, xArc *parcs);
+static void xxFillPolygon(DrawablePtr pDraw, GCPtr pGC, int shape,
+			  int mode, int count, DDXPointPtr pptInit);
+static void xxPolyFillRect(DrawablePtr pDraw, GCPtr pGC, int nRectsInit, 
+			   xRectangle *pRectsInit);
+static RegionPtr xxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GC *pGC,
+			    int srcx, int srcy, int width, int height,
+			    int dstx, int dsty);
+static void xxPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs,
+			  xArc *parcs);
+static int xxPolyText8(DrawablePtr pDraw, GCPtr	pGC, int x, int	y, int count,
+		       char *chars);
+static int xxPolyText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
+			int count, unsigned short *chars);
+static void xxImageText8(DrawablePtr pDraw, GCPtr pGC, int x, 
+			 int y, int count, char	*chars);
+static void xxImageText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
+			  int count, unsigned short *chars);
+static void xxImageGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int x, int y,
+			    unsigned int nglyph, CharInfoPtr *ppci,
+			    pointer pglyphBase);
+static void xxPolyGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int x, int y,
+			   unsigned int nglyph, CharInfoPtr *ppci,
+			   pointer pglyphBase);
+static void xxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDraw,
+			 int	dx, int dy, int xOrg, int yOrg);
+static void
+xxComposite (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
+	     INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
+	     INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
+static void
+xxGlyphs (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+	  PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist,
+	  GlyphListPtr list, GlyphPtr *glyphs);
+
+
+typedef struct _xxCmapPrivRec {
+    CARD32* cmap;
+    ColormapPtr pmap;
+    Bool dirty;
+    struct _xxCmapPrivRec *next;
+} xxCmapPrivRec, *xxCmapPrivPtr;
+
+
+typedef struct {
+    CloseScreenProcPtr		CloseScreen;
+    CreateScreenResourcesProcPtr CreateScreenResources;
+    CreateWindowProcPtr		CreateWindow;
+    CopyWindowProcPtr		CopyWindow;
+    PaintWindowProcPtr		PaintWindowBackground;
+    PaintWindowProcPtr		PaintWindowBorder;
+    WindowExposuresProcPtr	WindowExposures;
+    CreateGCProcPtr		CreateGC;
+    CreateColormapProcPtr	CreateColormap;
+    DestroyColormapProcPtr	DestroyColormap;
+    InstallColormapProcPtr	InstallColormap;
+    UninstallColormapProcPtr	UninstallColormap;
+    ListInstalledColormapsProcPtr ListInstalledColormaps;
+    StoreColorsProcPtr		StoreColors;
+#ifdef RENDER
+    CompositeProcPtr		Composite;
+    GlyphsProcPtr		Glyphs;
+#endif    
+    PixmapPtr			pPixmap;
+    char *			addr;
+    pointer			pBits;
+    RegionRec			region;
+    VisualPtr			bVisual;
+    RegionRec			bRegion;
+    int				myDepth;
+    int				depth;
+    ColormapPtr			baseCmap;
+    ColormapPtr*		InstalledCmaps;
+    xxCmapPrivPtr		Cmaps;
+    int				numInstalledColormaps;
+    int				colormapDirty;
+    xxSyncFunc			sync;
+} xxScrPrivRec, *xxScrPrivPtr;
+
+#define xxGetScrPriv(s)	((xxScrPrivPtr) \
+				 (xxScrPrivateIndex != -1) \
+                          ? (s)->devPrivates[xxScrPrivateIndex].ptr\
+				: NULL)
+#define xxScrPriv(s)     xxScrPrivPtr pScrPriv = xxGetScrPriv(s)
+
+#define xxGetCmapPriv(s) ((xxCmapPrivPtr) \
+                          (s)->devPrivates[xxColormapPrivateIndex].ptr)
+#define xxCmapPriv(s)    xxCmapPrivPtr pCmapPriv = xxGetCmapPriv(s);
+
+typedef struct _xxGCPriv {
+    GCOps   *ops;
+    GCFuncs *funcs;
+} xxGCPrivRec, *xxGCPrivPtr;
+
+#define xxGetGCPriv(pGC) ((xxGCPrivPtr) \
+				      (pGC)->devPrivates[xxGCPrivateIndex].ptr)
+#define xxGCPriv(pGC)   xxGCPrivPtr  pGCPriv = xxGetGCPriv(pGC)
+
+int xxScrPrivateIndex = -1;
+int xxGCPrivateIndex;
+int xxColormapPrivateIndex = -1;
+int xxGeneration;
+
+
+#define wrap(priv,real,mem,func) {\
+    priv->mem = real->mem; \
+    real->mem = func; \
+}
+
+#define unwrap(priv,real,mem) {\
+    real->mem = priv->mem; \
+}
+
+#define MARK_DIRTY (1 << 31)
+
+#define MAX_NUM_XX_INSTALLED_CMAPS 255
+/* #define DEBUG  */
+#ifdef DEBUG
+# define DBG ErrorF
+# define DBG_ARGS(x) ErrorF x
+# 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("x1: %hi x2: %hi y1: %hi y2: %hi\n", \
+             box->x1,box->x2,box->y1,box->y2);\
+          }\
+       } else { \
+             box = &(rec.extents); \
+	     ErrorF("x1: %hi x2: %hi y1: %hi y2: %hi\n", \
+             box->x1,box->x2,box->y1,box->y2);\
+       } \
+}
+#else
+# define DBG(x)
+# define DBG_ARGS(x)
+# define PRINT_RECTS(rec)
+#endif
+
+#if 0
+static void xxCopyPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
+				    xxCmapPrivPtr pCmapPriv);
+static void xxUpdateFb(ScreenPtr pScreen);
+
+
+static void
+xxUpdateWindowImmediately(WindowPtr pWin)
+{
+    xxScrPriv(pWin->drawable.pScreen);
+    xxCmapPrivPtr pCmapPriv;
+    ColormapPtr pmap;
+	    
+    pmap = (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
+    
+    if (pmap && (pCmapPriv = xxGetCmapPriv(pmap)) != (pointer)-1) {
+	xxCopyPseudocolorRegion(pWin->drawable.pScreen,
+				&pScrPriv->region, pCmapPriv);
+    }
+}
+#else
+# define xxUpdateWindowImmediately(x)
+#endif
+
+static ColormapPtr
+xxGetBaseColormap(ScreenPtr pScreen)
+{
+    xxScrPriv(pScreen);
+    DepthPtr pDepth = pScreen->allowedDepths;
+    int i,j,k;
+    ColormapPtr pDefMap
+	=  (ColormapPtr) LookupIDByType(pScreen->defColormap,RT_COLORMAP);
+    ColormapPtr cmap = NULL;
+    VisualPtr pVisual = NULL;
+	
+    for (i = 0; i < pScreen->numDepths; i++, pDepth++)
+	if (pDepth->depth == pScrPriv->depth) {
+	    for (j = 0; j < pDepth->numVids; j++) {
+		if (pDefMap->pVisual->vid == pDepth->vids[j]
+		    && pDefMap->pVisual->class == TrueColor) {
+		    cmap = pDefMap;
+		    break;
+		}
+		if (!pVisual) {
+		    for (k = 0; k < pScreen->numVisuals; k++) {
+			if (pScreen->visuals[k].class == TrueColor
+			    && pScreen->visuals[k].vid
+			    == pDepth->vids[j]) {
+			    pVisual = &pScreen->visuals[k];
+			    break;
+			}
+		    }
+		}
+	    }
+	    if (cmap)
+		break;
+	}
+	    
+    if (!cmap) {
+	CreateColormap(FakeClientID(0),pScreen,pVisual,&cmap,AllocNone,0);
+    }
+    
+    return cmap;
+}
+
+static Bool
+xxCreateScreenResources(ScreenPtr pScreen)
+{
+    PixmapPtr		pPix;
+    xxScrPriv(pScreen);
+    Bool		ret;
+    PixmapPtr		pPixmap;
+    BoxRec		box;
+    int			depth = pScrPriv->myDepth;
+    pointer		pBits;
+    
+    unwrap (pScrPriv,pScreen, CreateScreenResources);
+    ret = pScreen->CreateScreenResources(pScreen);
+    wrap(pScrPriv,pScreen,CreateScreenResources,xxCreateScreenResources);
+
+    if (!ret) return FALSE;
+    
+    pScrPriv->pBits = NULL;
+    if (pScrPriv->addr)
+	pBits = pScrPriv->addr;
+    else
+	pBits = xalloc(pScreen->width * pScreen->height
+		       * (BitsPerPixel(depth) >> 3));
+    if (!pBits) return FALSE;
+    
+    pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, depth);
+    if (!pPixmap) {
+	xfree(pBits);
+	return FALSE;
+    }
+    if (!(*pScreen->ModifyPixmapHeader)(pPixmap, pScreen->width,
+					pScreen->height, depth,
+					BitsPerPixel(depth),
+					PixmapBytePad(pScreen->width, depth),
+					pBits)) {
+	xfree(pBits);
+	return FALSE;
+    }
+    if (pScreen->rootDepth == pScrPriv->myDepth) {
+	pPix = (PixmapPtr)pScreen->devPrivate;    
+	if (!(*pScreen->ModifyPixmapHeader)(pPix, 0,0, pScrPriv->depth,
+					    BitsPerPixel(pScrPriv->depth),
+					    PixmapBytePad(pScreen->width,
+							  pScrPriv->depth),
+					    0)) {
+	    xfree(pBits);
+	    return FALSE;
+	}
+    }
+
+    pScrPriv->baseCmap = xxGetBaseColormap(pScreen);
+    
+    pScrPriv->pBits = pBits;
+    pScrPriv->pPixmap = pPixmap;
+    box.x1 = 0;
+    box.y1 = 0;
+    box.x2 = pScreen->width;
+    box.y2 = pScreen->height;
+    REGION_NULL(pScreen, &pScrPriv->region);
+    REGION_INIT(pScreen, &pScrPriv->bRegion, &box, 0);
+    
+    return TRUE;
+}
+
+static Bool
+xxCloseScreen (int iScreen, ScreenPtr pScreen)
+{
+    xxScrPriv(pScreen);
+    Bool		ret;
+
+    (*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);
+    
+    unwrap (pScrPriv,pScreen, CloseScreen);
+    ret = pScreen->CloseScreen(iScreen,pScreen);
+
+    xfree(pScrPriv->pBits);
+    xfree(pScrPriv->InstalledCmaps);
+    xfree(pScrPriv);
+    
+    return TRUE;
+}
+
+static Bool
+xxMyVisual(ScreenPtr pScreen, VisualID vid)
+{
+    xxScrPriv(pScreen);
+    DepthPtr pDepth = pScreen->allowedDepths;
+    int i,j;
+    
+    for (i = 0; i < pScreen->numDepths; i++, pDepth++)
+	if (pDepth->depth == pScrPriv->myDepth) {
+	    for (j = 0; j < pDepth->numVids; j++) {
+		if (vid == pDepth->vids[j]) {
+		    return TRUE;
+		}
+	    }
+	}
+    return FALSE;
+}
+
+static Bool
+xxInitColormapDummy(ColormapPtr pmap, int index)
+{
+    return TRUE;
+}
+
+static Bool
+xxInitColormapPrivate(ColormapPtr pmap)
+{
+    xxScrPriv(pmap->pScreen);
+    xxCmapPrivPtr	pCmapPriv;
+    pointer		cmap;
+
+    pmap->devPrivates[xxColormapPrivateIndex].ptr = (pointer) -1;
+    
+    if (xxMyVisual(pmap->pScreen,pmap->pVisual->vid)) {
+	DBG("CreateColormap\n");
+	pCmapPriv = (xxCmapPrivPtr) xalloc (sizeof (xxCmapPrivRec));
+	if (!pCmapPriv)
+	    return FALSE;
+	pmap->devPrivates[xxColormapPrivateIndex].ptr = (pointer) pCmapPriv;
+	cmap = xalloc(sizeof (CARD32) * (1 << pScrPriv->myDepth));
+	if (!cmap)
+	return FALSE;
+
+	memset(cmap,0,sizeof (CARD32) * (1 << pScrPriv->myDepth));
+	
+	pCmapPriv->cmap = cmap;
+	pCmapPriv->dirty = FALSE;
+	pCmapPriv->pmap = pmap;
+	pCmapPriv->next = pScrPriv->Cmaps;
+	pScrPriv->Cmaps = pCmapPriv;
+    }
+    return TRUE;
+}
+
+
+static Bool
+xxCreateColormap(ColormapPtr pmap)
+{
+    xxScrPriv(pmap->pScreen);
+    Bool		ret;
+    
+    if (!xxInitColormapPrivate(pmap)) return FALSE;
+    
+    unwrap(pScrPriv,pmap->pScreen, CreateColormap);
+    ret = pmap->pScreen->CreateColormap(pmap);
+    wrap(pScrPriv,pmap->pScreen,CreateColormap,xxCreateColormap);
+    
+    return ret;
+}
+
+static int
+xxCmapInstalled(ColormapPtr pmap)
+{
+    xxScrPriv(pmap->pScreen);
+    int i;
+    
+    for (i = 0; i < pScrPriv->numInstalledColormaps; i++)
+	if (pScrPriv->InstalledCmaps[i] == pmap)
+	    break;
+	if (i == pScrPriv->numInstalledColormaps) /* not installed */
+	    return -1;
+	return i;
+}
+
+static void
+xxInstalledCmapDelete(ScreenPtr pScreen, int num)
+{
+    xxScrPriv(pScreen);
+    int i;
+
+    pScrPriv->numInstalledColormaps--;
+    
+    for (i = num; i < pScrPriv->numInstalledColormaps; i++)
+	pScrPriv->InstalledCmaps[i] = pScrPriv->InstalledCmaps[i+1];
+}
+
+static void
+xxDestroyColormap(ColormapPtr pmap)
+{
+    xxScrPriv(pmap->pScreen);
+    xxCmapPriv(pmap);
+
+    if (pCmapPriv != (pointer) -1) {
+	xxCmapPrivPtr tmpCmapPriv = pScrPriv->Cmaps;
+	xxCmapPrivPtr *prevCmapPriv = &pScrPriv->Cmaps;
+	int n;
+	
+	DBG("DestroyColormap\n");
+
+	if ((n = xxCmapInstalled(pmap)) != -1)
+	    xxInstalledCmapDelete(pmap->pScreen,n);
+
+	while (tmpCmapPriv) {
+	    if (tmpCmapPriv->pmap == pmap) {
+		*prevCmapPriv = tmpCmapPriv->next;
+		break;
+	    }
+	    prevCmapPriv = &tmpCmapPriv->next;
+	    tmpCmapPriv = tmpCmapPriv->next;
+	}
+	
+	xfree(pCmapPriv->cmap);
+	xfree(pCmapPriv);
+    }
+
+    unwrap(pScrPriv,pmap->pScreen, DestroyColormap);
+    pmap->pScreen->DestroyColormap(pmap);
+    wrap(pScrPriv,pmap->pScreen,DestroyColormap,xxDestroyColormap);
+}
+
+#define Shift(v,d)  ((d) < 0 ? ((v) >> (-d)) : ((v) << (d)))
+
+static int
+xxComputeCmapShift (unsigned long mask)
+{
+    int	shift;
+    unsigned long   bit;
+    
+    shift = 16;
+    bit = 0x80000000;
+    while (!(mask & bit))
+    {
+	shift--;
+	bit >>= 1;
+    }
+    return shift;
+}
+
+static void
+xxStoreColors(ColormapPtr pmap, int nColors, xColorItem *pColors)
+{
+    xxScrPriv(pmap->pScreen);
+    xxCmapPriv(pmap);
+
+    if (pCmapPriv != (pointer) -1) {
+
+	xColorItem	*expanddefs;
+	int		i;
+	VisualPtr	bVisual;
+	int		rs, gs, bs;
+
+	if (nColors == 0) return;
+
+	DBG("StoreColors\n");
+	
+	expanddefs = ALLOCATE_LOCAL(sizeof(xColorItem)
+				    * (1 <<  pScrPriv->myDepth));
+	if (!expanddefs) return;
+	
+	bVisual = pScrPriv->bVisual;
+
+	DBG("StoreColors\n");
+
+	rs = xxComputeCmapShift(bVisual->redMask);
+	gs = xxComputeCmapShift(bVisual->greenMask);
+	bs = xxComputeCmapShift(bVisual->blueMask);
+	
+	if ((pmap->pVisual->class | DynamicClass) == DirectColor) {
+	    nColors = miExpandDirectColors(pmap, nColors, pColors, expanddefs);
+	    pColors = expanddefs;
+	}
+
+	for (i = 0; i < nColors; i++) {
+	    DBG_ARGS(("index: %i r 0x%x g 0x%x b 0x%x\n", pColors->pixel,
+		   pColors->red, pColors->green, pColors->blue));
+	    pCmapPriv->cmap[pColors->pixel] = MARK_DIRTY
+		| (Shift(pColors->red, rs) & bVisual->redMask)
+		| (Shift(pColors->green, gs) & bVisual->greenMask)
+		| (Shift(pColors->blue, bs)  & bVisual->blueMask);
+	    pColors++;
+	}
+
+	DEALLOCATE_LOCAL(expanddefs);
+
+	pCmapPriv->dirty = TRUE;
+	pScrPriv->colormapDirty = TRUE;
+	
+	return;
+    }
+    
+    unwrap(pScrPriv,pmap->pScreen, StoreColors);
+    pmap->pScreen->StoreColors(pmap,nColors,pColors);
+    wrap(pScrPriv,pmap->pScreen,StoreColors,xxStoreColors);
+}
+
+static void
+xxInstallColormap(ColormapPtr pmap)
+{
+    int i;
+    xxScrPriv(pmap->pScreen);
+    xxCmapPriv(pmap);
+    
+    if (pCmapPriv != (pointer) -1) {
+	Pixel		*pixels;
+	xrgb		*colors;
+	int		i;
+	VisualPtr	pVisual;
+	xColorItem	*defs;
+
+	DBG("InstallColormap\n");
+
+	if (xxCmapInstalled(pmap) != -1)
+	    return;
+
+	if (!pScrPriv->numInstalledColormaps) {
+	    unwrap(pScrPriv,pmap->pScreen, InstallColormap);
+	    pmap->pScreen->InstallColormap(pScrPriv->baseCmap);
+	    wrap(pScrPriv,pmap->pScreen,InstallColormap,xxInstallColormap);
+	}
+	    
+	pixels = ALLOCATE_LOCAL(sizeof(Pixel) * (1 <<  pScrPriv->myDepth));
+	colors = ALLOCATE_LOCAL(sizeof(xrgb) * (1 <<  pScrPriv->myDepth));
+	defs = ALLOCATE_LOCAL(sizeof(xColorItem) * (1 << pScrPriv->myDepth));
+	
+	if (!pixels || !colors)
+	    return;
+
+	/* if we have more than max installed delete the oldest */
+	if (pScrPriv->numInstalledColormaps == MAX_NUM_XX_INSTALLED_CMAPS)
+	    xxInstalledCmapDelete(pmap->pScreen,0);
+	
+	pScrPriv->InstalledCmaps[pScrPriv->numInstalledColormaps] = pmap;
+	pScrPriv->numInstalledColormaps++;
+	
+	pVisual = pScrPriv->bVisual;
+	
+	for (i = 0; i < (1 <<  pScrPriv->myDepth); i++)
+	    pixels[i] = i;
+	
+	QueryColors (pmap, (1 << pScrPriv->myDepth), pixels, colors);
+
+	for (i = 0; i < (1 <<  pScrPriv->myDepth); i++) {
+	    defs[i].pixel = pixels[i];
+            defs[i].red = colors[i].red;
+            defs[i].green = colors[i].green;
+            defs[i].blue = colors[i].blue;
+            defs[i].flags =  DoRed|DoGreen|DoBlue;
+        }
+	xxStoreColors(pmap,(1 <<  pScrPriv->myDepth),defs);
+
+	DEALLOCATE_LOCAL(pixels);
+	DEALLOCATE_LOCAL(colors);
+	DEALLOCATE_LOCAL(defs);
+
+	return;
+    } 
+
+    for (i = pScrPriv->numInstalledColormaps; i ; i--)
+	WalkTree(pmap->pScreen, TellLostMap,
+		 (char *)&pScrPriv->InstalledCmaps[i-1]->mid);
+    
+    pScrPriv->numInstalledColormaps = 0;
+     
+    unwrap(pScrPriv,pmap->pScreen, InstallColormap);
+    pmap->pScreen->InstallColormap(pmap);
+    wrap(pScrPriv,pmap->pScreen,InstallColormap,xxInstallColormap);
+}
+
+static void
+xxUninstallColormap(ColormapPtr pmap)
+{
+    xxScrPriv(pmap->pScreen);
+    xxCmapPriv(pmap);
+
+    if (pCmapPriv != (pointer) -1) {
+	int num;
+	
+	if ((num = xxCmapInstalled(pmap)) == -1)
+	    return;
+	
+	DBG("UninstallColormap\n");
+	xxInstalledCmapDelete(pmap->pScreen,num);
+
+	return;
+    } 
+    
+    unwrap(pScrPriv,pmap->pScreen, UninstallColormap);
+    pmap->pScreen->UninstallColormap(pmap);
+    wrap(pScrPriv,pmap->pScreen,UninstallColormap,xxUninstallColormap);
+	
+}
+
+static int
+xxListInstalledColormaps(ScreenPtr pScreen, Colormap *pCmapIds)
+{
+    int			n,i;
+    xxScrPriv(pScreen);
+
+    unwrap(pScrPriv,pScreen, ListInstalledColormaps);
+    n = pScreen->ListInstalledColormaps(pScreen, pCmapIds);
+    wrap (pScrPriv,pScreen,ListInstalledColormaps,xxListInstalledColormaps);
+
+    pCmapIds += n;
+
+    for (i = 0; i < pScrPriv->numInstalledColormaps; i++) {
+	*pCmapIds++ = pScrPriv->InstalledCmaps[i]->mid;
+	n++;
+    }
+
+    return n;
+}
+
+static Bool
+xxCreateWindow(WindowPtr pWin)
+{
+    xxScrPriv(pWin->drawable.pScreen);
+    
+    if (pWin->drawable.class != InputOutput
+	|| pScrPriv->myDepth != pWin->drawable.depth) {
+	Bool ret;
+	DBG("CreateWindow NoPseudo\n");
+	unwrap (pScrPriv, pWin->drawable.pScreen, CreateWindow);
+	ret = pWin->drawable.pScreen->CreateWindow(pWin);
+	wrap(pScrPriv, pWin->drawable.pScreen, CreateWindow, xxCreateWindow);
+
+	return ret;
+    }
+    
+    DBG("CreateWindow\n");
+
+    pWin->devPrivates[fbWinPrivateIndex].ptr = (pointer) pScrPriv->pPixmap;
+    PRINT_RECTS(pScrPriv->region);
+	if (!pWin->parent) {
+	REGION_EMPTY (pWin->drawable.pScreen, &pScrPriv->region);
+    }
+    PRINT_RECTS(pScrPriv->region);
+    
+    return TRUE;
+}
+
+static void
+xxWalkChildren(WindowPtr pWin, RegionPtr pReg, PixmapPtr pPixmap)
+{
+    
+    WindowPtr		pCurWin = pWin;
+    
+    do {
+	if (fbGetWindowPixmap(pCurWin) == pPixmap) {
+	    DBG("WalkWindow Add\n");
+	    REGION_UNION(pWin->drawable.pScreen,pReg,pReg,
+			 &pCurWin->borderClip);
+	} else {
+	    DBG("WalkWindow Sub\n");
+	    REGION_SUBTRACT(pWin->drawable.pScreen,pReg,pReg,
+			    &pCurWin->borderClip);
+	}
+	if (pCurWin->lastChild)
+	    xxWalkChildren(pCurWin->lastChild,pReg, pPixmap);
+    } while ((pCurWin = pCurWin->prevSib));
+}
+
+static void
+xxPickMyWindows(WindowPtr pWin, RegionPtr pRgn)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    xxScrPriv(pScreen);
+
+    if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
+	REGION_UNION(pWin->drawable.pScreen,pRgn,pRgn,&pWin->borderClip);
+    }
+    if (pWin->lastChild)
+	xxWalkChildren(pWin->lastChild,pRgn,pScrPriv->pPixmap);
+}
+
+static void
+xxCopyWindow(WindowPtr	pWin,
+	     DDXPointRec	ptOldOrg,
+	     RegionPtr	prgnSrc)
+{
+    ScreenPtr		pScreen = pWin->drawable.pScreen;
+    xxScrPriv(pScreen);
+    RegionRec		rgn;
+    RegionRec		rgn_new;
+    int			dx, dy;
+    PixmapPtr pPixmap = fbGetWindowPixmap(pWin);
+
+    DBG("xxCopyWindow\n");
+
+    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);
+
+    REGION_NULL(pScreen, &rgn);
+    xxPickMyWindows(pWin,&rgn);
+
+    unwrap (pScrPriv, pScreen, CopyWindow);
+    pWin->devPrivates[fbWinPrivateIndex].ptr = fbGetScreenPixmap(pScreen);
+    pScreen->CopyWindow(pWin, ptOldOrg, prgnSrc);
+    pWin->devPrivates[fbWinPrivateIndex].ptr = pPixmap;
+    wrap(pScrPriv, pScreen, CopyWindow, xxCopyWindow);
+
+    REGION_INTERSECT(pScreen,&rgn,&rgn,&rgn_new);
+    if (REGION_NOTEMPTY (pScreen,&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);
+    }
+#if 1
+    REGION_UNINIT(pScreen,&rgn_new);
+    REGION_UNINIT(pScreen,&rgn);
+#endif
+}
+
+static void
+xxWindowExposures (WindowPtr	pWin,
+			  RegionPtr	prgn,
+			  RegionPtr	other_exposed)
+{
+    xxScrPriv(pWin->drawable.pScreen);
+
+    if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
+	DBG("WindowExposures\n");
+	PRINT_RECTS(pScrPriv->region);
+	REGION_UNION(pWin->drawable.pScreen,&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,
+		     &pScrPriv->region,
+		     prgn);
+	PRINT_RECTS(pScrPriv->region);
+    }
+    unwrap (pScrPriv, pWin->drawable.pScreen, WindowExposures);
+    pWin->drawable.pScreen->WindowExposures(pWin, prgn, other_exposed);
+    wrap(pScrPriv, pWin->drawable.pScreen, WindowExposures, xxWindowExposures);
+}
+
+static void
+xxPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
+{
+    xxScrPriv(pWin->drawable.pScreen);
+    RegionRec		rgni;
+
+    DBG("xxPaintWindow\n");
+
+    REGION_NULL (pWin->drawable.pScreen, &rgni);
+#if 0
+    REGION_UNION (pWin->drawable.pScreen, &rgni, &rgni, &pWin->borderClip);
+    REGION_INTERSECT(pWin->drawable.pScreen, &rgni, &rgni, pRegion);
+#else
+    REGION_UNION (pWin->drawable.pScreen, &rgni, &rgni, pRegion);
+#endif
+    switch (what) {
+    case PW_BORDER:
+	REGION_SUBTRACT (pWin->drawable.pScreen, &rgni, &rgni, &pWin->winSize);
+	if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
+	    DBG("PaintWindowBorder\n");
+	    REGION_UNION (pWin->drawable.pScreen, &pScrPriv->region,
+			  &pScrPriv->region, &rgni);
+	} else {
+	    DBG("PaintWindowBorder NoOverlay\n");
+	    REGION_SUBTRACT (pWin->drawable.pScreen, &pScrPriv->region,
+			     &pScrPriv->region, &rgni);	
+	}
+	unwrap (pScrPriv, pWin->drawable.pScreen, PaintWindowBorder);
+	pWin->drawable.pScreen->PaintWindowBorder (pWin, pRegion, what);
+	wrap(pScrPriv, pWin->drawable.pScreen, PaintWindowBorder,
+	     xxPaintWindow);	
+	break;
+    case PW_BACKGROUND:
+	switch (pWin->backgroundState) {
+	case None:
+	    break;
+	default:
+	    REGION_INTERSECT (pWin->drawable.pScreen, &rgni,
+			      &rgni,&pWin->winSize);
+	    if (fbGetWindowPixmap(pWin) == pScrPriv->pPixmap) {
+		DBG("PaintWindowBackground\n");
+		REGION_UNION (pWin->drawable.pScreen, &pScrPriv->region,
+			      &pScrPriv->region, &rgni);
+	    } else {
+		DBG("PaintWindowBackground NoOverlay\n");
+		REGION_SUBTRACT (pWin->drawable.pScreen, &pScrPriv->region,
+				 &pScrPriv->region, &rgni);	
+	    }
+	    break;
+	}
+	
+	unwrap (pScrPriv, pWin->drawable.pScreen, PaintWindowBackground);
+	pWin->drawable.pScreen->PaintWindowBackground (pWin, pRegion, what);
+	wrap(pScrPriv, pWin->drawable.pScreen, PaintWindowBackground,
+	     xxPaintWindow);
+	break;
+    }
+    PRINT_RECTS(rgni);
+    PRINT_RECTS(pScrPriv->region);
+#if 1
+    REGION_UNINIT(pWin->drawable.pScreen,&rgni);
+#endif
+}
+
+static void
+xxCopyPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
+			xxCmapPrivPtr pCmapPriv)
+{
+    xxScrPriv(pScreen);
+    CARD32		mask = (1 << pScrPriv->myDepth) - 1;
+    int			num = REGION_NUM_RECTS(pReg);
+    BoxPtr		pbox = REGION_RECTS(pReg);
+    int			width, height;
+    CARD8		*src;
+    CARD16		*dst, *dst_base;
+    int			dst_stride;
+    register CARD32	*cmap = pCmapPriv->cmap;
+    register CARD8      *s;
+    register CARD16     *d;
+    int w;
+
+    dst_base = (CARD16*) ((PixmapPtr)pScreen->devPrivate)->devPrivate.ptr;
+    dst_stride = (int)((PixmapPtr)pScreen->devPrivate)->devKind
+	/ sizeof (CARD16);
+
+    while (num--) {
+	height = pbox->y2 - pbox->y1;
+	width = pbox->x2 - pbox->x1;
+	
+	src = (unsigned char *) pScrPriv->pBits
+	    + (pbox->y1 * pScreen->width) + pbox->x1;
+	dst = dst_base + (pbox->y1 * dst_stride) + pbox->x1;
+	while (height--) {
+	    w = width;
+	    s = src;
+	    d = dst;
+
+	    while(w--) {
+		*(d++) = (CARD16)*(cmap + ((*(s++)) & mask));
+	    }
+	    src += pScreen->width;
+	    dst += dst_stride;
+	}
+	pbox++;
+    }
+}
+
+static void
+xxUpdateCmapPseudocolorRegion(ScreenPtr pScreen, RegionPtr pReg,
+			xxCmapPrivPtr pCmapPriv)
+{
+    xxScrPriv(pScreen);
+    CARD32		mask = (1 << pScrPriv->myDepth) - 1;
+    int			num = REGION_NUM_RECTS(pReg);
+    BoxPtr		pbox = REGION_RECTS(pReg);
+    int			width, height;
+    CARD8		*src;
+    CARD16		*dst, *dst_base;
+    int			dst_stride;
+    register CARD32	val;
+    register CARD32	*cmap = pCmapPriv->cmap;
+    register CARD8      *s;
+    register CARD16     *d;
+    int w;
+
+    dst_base = (CARD16*) ((PixmapPtr)pScreen->devPrivate)->devPrivate.ptr;
+    dst_stride = (int)((PixmapPtr)pScreen->devPrivate)->devKind
+	/ sizeof (CARD16);
+
+    while (num--) {
+
+	height = pbox->y2 - pbox->y1;
+	width = pbox->x2 - pbox->x1;
+	
+	src = (unsigned char *) pScrPriv->pBits
+	    + (pbox->y1 * pScreen->width) + pbox->x1;
+	dst = dst_base + (pbox->y1 * dst_stride) + pbox->x1;
+	while (height--) {
+	    w = width;
+	    s = src;
+	    d = dst;
+	    while(w--) {
+		val = *(cmap + ((*(s++)) & mask));
+      		if (val & MARK_DIRTY) {
+		    *d = (CARD16) val;
+		}
+		d++;
+	    }
+	    src += pScreen->width;
+	    dst += dst_stride;
+	}
+	pbox++;
+    }
+}
+
+static void
+xxGetWindowRegion(WindowPtr pWin,RegionPtr winreg)
+{
+    REGION_NULL(pWin->drawable.pScreen,winreg);
+    /* get visible part of the border ...Argh */
+    REGION_SUBTRACT(pWin->drawable.pScreen,winreg,&pWin->borderSize,
+		    &pWin->winSize);
+    REGION_INTERSECT(pWin->drawable.pScreen,winreg,winreg,
+		     &pWin->borderClip);
+    /* add window interior excluding children */
+    REGION_UNION(pWin->drawable.pScreen,winreg,winreg,
+		 &pWin->clipList);
+}
+
+static int
+xxUpdateRegion(WindowPtr pWin, pointer unused)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    xxScrPriv(pScreen);
+    ColormapPtr pmap = (pointer) -1;
+    RegionRec		winreg, rgni;
+    
+    if (pScrPriv->myDepth == pWin->drawable.depth) {
+	xxCmapPrivPtr pCmapPriv = (pointer)-1;
+	xxGetWindowRegion(pWin,&winreg);
+
+	if (pScrPriv->colormapDirty) {
+
+	    pmap = (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
+	    if (!pmap)
+		goto CONTINUE; /* return ? */
+
+	    pCmapPriv = xxGetCmapPriv(pmap);
+	    if (pCmapPriv == (pointer) -1)
+		return WT_WALKCHILDREN;
+	    if (!pCmapPriv->dirty)
+		goto CONTINUE;
+
+	    REGION_NULL (pScreen, &rgni);
+	    /* This will be taken care of when damaged regions are updated */
+	    REGION_SUBTRACT(pScreen, &rgni, &winreg, &pScrPriv->region);
+	    if (REGION_NOTEMPTY (pScreen,&rgni))
+		xxUpdateCmapPseudocolorRegion(pScreen,&rgni, pCmapPriv);
+	}
+    CONTINUE:
+
+	REGION_NULL (pScreen, &rgni);
+	REGION_INTERSECT (pScreen, &rgni, &winreg, &pScrPriv->region);
+	
+	if (REGION_NOTEMPTY (pScreen,&rgni)) {
+	    if (pmap == (pointer) -1) {
+		pmap =
+		    (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
+		if (!pmap) /* return ? */
+		    pmap = (ColormapPtr)LookupIDByType(pScreen->defColormap,
+						       RT_COLORMAP);
+		pCmapPriv = xxGetCmapPriv(pmap);
+	    }
+	    
+	    if (pCmapPriv != (pointer)-1)
+		xxCopyPseudocolorRegion(pScreen,&rgni, pCmapPriv);
+	    REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
+			    &rgni);
+	}
+#if 1
+	REGION_UNINIT(pScreen,&rgni);
+	REGION_UNINIT(pScreen,&winreg);
+#endif
+    }
+    return WT_WALKCHILDREN;
+}
+
+
+static void
+xxUpdateFb(ScreenPtr pScreen)
+{
+    xxScrPriv(pScreen);
+
+    DBG("Update FB\n");
+    PRINT_RECTS(pScrPriv->region);
+
+    if (pScrPriv->sync)
+	pScrPriv->sync(pScreen); /*@!@*/
+    
+    WalkTree(pScreen,xxUpdateRegion,NULL);
+#if 0
+    if (REGION_NOTEMPTY (pScreen,&pScrPriv->region)) {
+	ColormapPtr pmap = (pointer) -1;
+	xxCmapPrivPtr pCmapPriv;
+	
+	pmap = (ColormapPtr)LookupIDByType(pScreen->defColormap,
+					   RT_COLORMAP);
+	pCmapPriv = xxGetCmapPriv(pmap);
+	if (pCmapPriv != (pointer)-1)
+	    xxCopyPseudocolorRegion(pScreen,&pScrPriv->region, pCmapPriv);
+	REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
+			&pScrPriv->region);
+    }
+#endif
+    if (pScrPriv->colormapDirty) {
+	xxCmapPrivPtr pCmap = pScrPriv->Cmaps;
+
+	while (pCmap) {
+	    int j;
+
+	    if (pCmap->dirty) {
+		for (j = 0; j < (1 <<  pScrPriv->myDepth); j++) 
+		    pCmap->cmap[j] &= ~MARK_DIRTY;
+		pCmap->dirty = FALSE;
+	    }
+	    pCmap = pCmap->next;
+	}
+	pScrPriv->colormapDirty = FALSE;
+    }
+}
+
+static void
+xxBlockHandler (pointer	data,
+		OSTimePtr pTimeout,
+		pointer pRead)
+{
+    ScreenPtr	pScreen = (ScreenPtr) data;
+    xxScrPriv(pScreen);
+
+    if (REGION_NOTEMPTY (pScreen,&pScrPriv->region) || pScrPriv->colormapDirty)
+	xxUpdateFb (pScreen);
+}
+
+static void
+xxWakeupHandler (pointer data, int i, pointer LastSelectMask)
+{
+}
+
+Bool
+xxSetup(ScreenPtr pScreen, int myDepth, int baseDepth, char* addr, xxSyncFunc sync)
+{
+    xxScrPrivPtr	pScrPriv;
+    DepthPtr		pDepths;
+    ColormapPtr		pDefMap;
+    int i,j,k;
+    
+#ifdef RENDER
+    PictureScreenPtr	ps = GetPictureScreenIfSet(pScreen);
+#endif
+
+    if (xxGeneration != serverGeneration) {
+	xxScrPrivateIndex = AllocateScreenPrivateIndex ();
+	if (xxScrPrivateIndex == -1)
+	    return FALSE;
+	xxColormapPrivateIndex
+	    = AllocateColormapPrivateIndex (xxInitColormapDummy);
+	if (xxColormapPrivateIndex == -1)
+	    return FALSE;
+	xxGCPrivateIndex = AllocateGCPrivateIndex ();
+	if (xxGCPrivateIndex == -1)
+	    return FALSE;
+	xxGeneration = serverGeneration;
+    }
+
+    if (!AllocateGCPrivate (pScreen, xxGCPrivateIndex, sizeof (xxGCPrivRec)))
+	return FALSE;
+
+    pScrPriv = (xxScrPrivPtr) xalloc (sizeof (xxScrPrivRec));
+    if (!pScrPriv)
+	return FALSE;
+    
+    if (baseDepth)
+	pScrPriv->depth = baseDepth;
+    else {
+	pDepths = pScreen->allowedDepths;
+        for (i = 0; i < pScreen->numDepths; i++, pDepths++)
+	    if (pDepths->depth != myDepth)
+		pScrPriv->depth = pDepths->depth;
+    }
+    if (!pScrPriv->depth)
+	return FALSE;
+    
+    pDepths = pScreen->allowedDepths;
+    for (i = 0; i < pScreen->numDepths; i++, pDepths++)
+	if (pDepths->depth == pScrPriv->depth) {
+	    for (j = 0; i < pDepths->numVids; j++) {
+		for (k = 0; k < pScreen->numVisuals; k++) {
+		    if (pScreen->visuals[k].vid
+			== pDepths[i].vids[j]
+			&& pScreen->visuals[k].class == TrueColor) {
+			pScrPriv->bVisual =  &pScreen->visuals[k];
+			goto DONE;
+		    }
+		}
+	    }
+	}
+    
+ DONE:
+    if (!pScrPriv->bVisual)
+	return FALSE;
+
+    pScrPriv->myDepth = myDepth;
+    pScrPriv->numInstalledColormaps = 0;
+    pScrPriv->colormapDirty = FALSE;
+    pScrPriv->Cmaps = NULL;
+    pScrPriv->sync = sync;
+    
+    pScreen->maxInstalledCmaps += MAX_NUM_XX_INSTALLED_CMAPS;
+    pScrPriv->InstalledCmaps = xcalloc(MAX_NUM_XX_INSTALLED_CMAPS,
+				       sizeof(ColormapPtr));
+    if (!pScrPriv->InstalledCmaps)
+	return FALSE;
+
+    
+    if (!RegisterBlockAndWakeupHandlers (xxBlockHandler,
+					 xxWakeupHandler,
+					 (pointer) pScreen))
+	return FALSE;
+
+    wrap (pScrPriv, pScreen, CloseScreen, xxCloseScreen);
+    wrap (pScrPriv, pScreen, CreateScreenResources, xxCreateScreenResources);
+    wrap (pScrPriv, pScreen, CreateWindow, xxCreateWindow);
+    wrap (pScrPriv, pScreen, CopyWindow, xxCopyWindow);
+    wrap (pScrPriv, pScreen, PaintWindowBorder, xxPaintWindow);
+    wrap (pScrPriv, pScreen, PaintWindowBackground, xxPaintWindow);
+#if 0 /* can we leave this out even with backing store enabled ? */
+    wrap (pScrPriv, pScreen, WindowExposures, xxWindowExposures);
+#endif
+    wrap (pScrPriv, pScreen, CreateGC, xxCreateGC);
+    wrap (pScrPriv, pScreen, CreateColormap, xxCreateColormap);
+    wrap (pScrPriv, pScreen, DestroyColormap, xxDestroyColormap);
+    wrap (pScrPriv, pScreen, InstallColormap, xxInstallColormap);
+    wrap (pScrPriv, pScreen, UninstallColormap, xxUninstallColormap);
+    wrap (pScrPriv, pScreen, ListInstalledColormaps, xxListInstalledColormaps);
+    wrap (pScrPriv, pScreen, StoreColors, xxStoreColors);
+#ifdef RENDER
+    if (ps) {
+	wrap (pScrPriv, ps, Glyphs, xxGlyphs);
+	wrap (pScrPriv, ps, Composite, xxComposite);
+    }
+#endif
+    pScrPriv->addr = addr;
+    pScreen->devPrivates[xxScrPrivateIndex].ptr = (pointer) pScrPriv;
+
+    pDefMap = (ColormapPtr) LookupIDByType(pScreen->defColormap, RT_COLORMAP);
+    if (!xxInitColormapPrivate(pDefMap))
+	return FALSE;
+    
+    return TRUE;
+}
+
+GCFuncs xxGCFuncs = {
+    xxValidateGC, xxChangeGC, xxCopyGC, xxDestroyGC,
+    xxChangeClip, xxDestroyClip, xxCopyClip
+};
+
+GCOps xxGCOps = {
+    xxFillSpans, xxSetSpans, 
+    xxPutImage, xxCopyArea, 
+    xxCopyPlane, xxPolyPoint, 
+    xxPolylines, xxPolySegment, 
+    xxPolyRectangle, xxPolyArc, 
+    xxFillPolygon, xxPolyFillRect, 
+    xxPolyFillArc, xxPolyText8, 
+    xxPolyText16, xxImageText8, 
+    xxImageText16, xxImageGlyphBlt, 
+    xxPolyGlyphBlt, xxPushPixels,
+#ifdef NEED_LINEHELPER
+    NULL,
+#endif
+    {NULL}		/* devPrivate */
+};
+
+#define IS_VISIBLE(pDraw) (pDraw->type == DRAWABLE_WINDOW \
+	   && (fbGetWindowPixmap((WindowPtr) pDraw) == pScrPriv->pPixmap))
+
+#define TRANSLATE_BOX(box, pDraw) { \
+    box.x1 += pDraw->x; \
+    box.x2 += pDraw->x; \
+    box.y1 += pDraw->y; \
+    box.y2 += pDraw->y; \
+    }
+
+#define TRIM_BOX(box, pGC) { \
+    BoxPtr extents = &pGC->pCompositeClip->extents;\
+    if(box.x1 < extents->x1) box.x1 = extents->x1; \
+    if(box.x2 > extents->x2) box.x2 = extents->x2; \
+    if(box.y1 < extents->y1) box.y1 = extents->y1; \
+    if(box.y2 > extents->y2) box.y2 = extents->y2; \
+    }
+
+#define BOX_NOT_EMPTY(box) \
+    (((box.x2 - box.x1) > 0) && ((box.y2 - box.y1) > 0))
+
+
+#define _ADD_BOX(box,pGC) {\
+    if (BOX_NOT_EMPTY(box)) { \
+       RegionRec region; \
+       ScreenPtr pScreen = pGC->pScreen;\
+       REGION_INIT (pScreen, &region, &box, 1); \
+       REGION_INTERSECT(pScreen,&region,&region,\
+                                 (pGC)->pCompositeClip);\
+       if (REGION_NOTEMPTY(pScreen,&region)) { \
+           xxScrPriv(pScreen);\
+	   PRINT_RECTS(pScrPriv->region);\
+           REGION_UNION(pScreen,&pScrPriv->region,&pScrPriv->region,&region);\
+	   PRINT_RECTS(pScrPriv->region);\
+           REGION_UNINIT(pScreen,&region);\
+       }\
+   }\
+}
+
+#define TRANSLATE_AND_ADD_BOX(box,pGC) {\
+         TRANSLATE_BOX(box,pDraw); \
+         TRIM_BOX(box,pGC); \
+         _ADD_BOX(box,pGC); \
+}
+
+#define ADD_BOX(box,pGC) { \
+        TRIM_BOX(box,pGC); \
+        _ADD_BOX(box,pGC); \
+}
+
+#define XX_GC_FUNC_PROLOGUE(pGC) \
+    xxGCPriv(pGC); \
+    unwrap(pGCPriv, pGC, funcs); \
+    if (pGCPriv->ops) unwrap(pGCPriv, pGC, ops)
+
+#define XX_GC_FUNC_EPILOGUE(pGC) \
+    wrap(pGCPriv, pGC, funcs, &xxGCFuncs);  \
+    if (pGCPriv->ops) wrap(pGCPriv, pGC, ops, &xxGCOps)
+
+static Bool
+xxCreateGC(GCPtr pGC)
+{
+    ScreenPtr		pScreen = pGC->pScreen;
+    xxScrPriv(pScreen);
+    xxGCPriv(pGC);
+    Bool ret;
+
+    unwrap (pScrPriv, pScreen, CreateGC);
+    if((ret = (*pScreen->CreateGC) (pGC))) {
+	pGCPriv->ops = NULL;
+	pGCPriv->funcs = pGC->funcs;
+	pGC->funcs = &xxGCFuncs;
+    }
+    wrap (pScrPriv, pScreen, CreateGC, xxCreateGC);
+
+    return ret;
+}
+
+static void
+xxValidateGC(
+   GCPtr         pGC,
+   unsigned long changes,
+   DrawablePtr   pDraw 
+){
+    XX_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
+    if(pDraw->type == DRAWABLE_WINDOW)
+	pGCPriv->ops = pGC->ops;  /* just so it's not NULL */
+    else 
+	pGCPriv->ops = NULL;
+    XX_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+xxDestroyGC(GCPtr pGC)
+{
+    XX_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->DestroyGC)(pGC);
+    XX_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+xxChangeGC (
+    GCPtr	    pGC,
+    unsigned long   mask
+){
+    XX_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeGC) (pGC, mask);
+    XX_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+xxCopyGC (
+    GCPtr	    pGCSrc, 
+    unsigned long   mask,
+    GCPtr	    pGCDst
+){
+    XX_GC_FUNC_PROLOGUE (pGCDst);
+    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+    XX_GC_FUNC_EPILOGUE (pGCDst);
+}
+
+static void
+xxChangeClip (
+    GCPtr   pGC,
+    int		type,
+    pointer	pvalue,
+    int		nrects 
+){
+    XX_GC_FUNC_PROLOGUE (pGC);
+    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
+    XX_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+xxCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+    XX_GC_FUNC_PROLOGUE (pgcDst);
+    (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
+    XX_GC_FUNC_EPILOGUE (pgcDst);
+}
+
+static void
+xxDestroyClip(GCPtr pGC)
+{
+    XX_GC_FUNC_PROLOGUE (pGC);
+    (* pGC->funcs->DestroyClip)(pGC);
+    XX_GC_FUNC_EPILOGUE (pGC);
+}
+
+#define XX_GC_OP_PROLOGUE(pGC,pDraw) \
+    xxScrPriv(pDraw->pScreen); \
+    xxGCPriv(pGC);  \
+    GCFuncs *oldFuncs = pGC->funcs; \
+    unwrap(pGCPriv, pGC, funcs);  \
+    unwrap(pGCPriv, pGC, ops); \
+	
+#define XX_GC_OP_EPILOGUE(pGC,pDraw) \
+    wrap(pGCPriv, pGC, funcs, oldFuncs); \
+    wrap(pGCPriv, pGC, ops, &xxGCOps)
+
+static void
+xxFillSpans(
+    DrawablePtr pDraw,
+    GC		*pGC,
+    int		nInit,	
+    DDXPointPtr pptInit,	
+    int 	*pwidthInit,		
+    int 	fSorted 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);    
+
+    if(IS_VISIBLE(pDraw) && nInit) {
+	DDXPointPtr ppt = pptInit;
+	int *pwidth = pwidthInit;
+	int i = nInit;
+	BoxRec box;
+
+	DBG("FillSpans\n");
+	box.x1 = ppt->x;
+	box.x2 = box.x1 + *pwidth;
+	box.y2 = box.y1 = ppt->y;
+
+	while(--i) {
+	   ppt++;
+	   pwidthInit++;
+	   if(box.x1 > ppt->x) box.x1 = ppt->x;
+	   if(box.x2 < (ppt->x + *pwidth)) 
+		box.x2 = ppt->x + *pwidth;
+	   if(box.y1 > ppt->y) box.y1 = ppt->y;
+	   else if(box.y2 < ppt->y) box.y2 = ppt->y;
+	}
+
+	box.y2++;
+
+	(*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
+
+	
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    } else
+	(*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
+
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void
+xxSetSpans(
+    DrawablePtr		pDraw,
+    GCPtr		pGC,
+    char		*pcharsrc,
+    DDXPointPtr 	pptInit,
+    int			*pwidthInit,
+    int			nspans,
+    int			fSorted 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nspans) {
+	DDXPointPtr ppt = pptInit;
+	int *pwidth = pwidthInit;
+	int i = nspans;
+	BoxRec box;
+
+	DBG("SetSpans\n");
+	box.x1 = ppt->x;
+	box.x2 = box.x1 + *pwidth;
+	box.y2 = box.y1 = ppt->y;
+
+	while(--i) {
+	   ppt++;
+	   pwidth++;
+	   if(box.x1 > ppt->x) box.x1 = ppt->x;
+	   if(box.x2 < (ppt->x + *pwidth)) 
+		box.x2 = ppt->x + *pwidth;
+	   if(box.y1 > ppt->y) box.y1 = ppt->y;
+	   else if(box.y2 < ppt->y) box.y2 = ppt->y;
+	}
+
+	box.y2++;
+
+	(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit, 
+				pwidthInit, nspans, fSorted);
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    } else
+	(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit, 
+				pwidthInit, nspans, fSorted);
+
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void
+xxPutImage(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		depth, 
+    int x, int y, int w, int h,
+    int		leftPad,
+    int		format,
+    char 	*pImage 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h, 
+		leftPad, format, pImage);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+    if(IS_VISIBLE(pDraw)) {
+	BoxRec box;
+
+	DBG("PutImage\n");
+	box.x1 = x + pDraw->x;
+	box.x2 = box.x1 + w;
+	box.y1 = y + pDraw->y;
+	box.y2 = box.y1 + h;
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+static RegionPtr
+xxCopyArea(
+    DrawablePtr pSrc,
+    DrawablePtr pDst,
+    GC *pGC,
+    int srcx, int srcy,
+    int width, int height,
+    int dstx, int dsty 
+){
+    RegionPtr ret;
+    XX_GC_OP_PROLOGUE(pGC, pDst);
+    DBG("xxCopyArea\n");
+    ret = (*pGC->ops->CopyArea)(pSrc, pDst,
+            pGC, srcx, srcy, width, height, dstx, dsty);
+    XX_GC_OP_EPILOGUE(pGC, pDst);
+
+    if(IS_VISIBLE(pDst)) {
+	BoxRec box;
+
+	DBG("CopyArea\n");
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	ADD_BOX(box, pGC);
+    }
+
+    return ret;
+}
+
+static RegionPtr
+xxCopyPlane(
+    DrawablePtr	pSrc,
+    DrawablePtr	pDst,
+    GCPtr pGC,
+    int	srcx, int srcy,
+    int	width, int height,
+    int	dstx, int dsty,
+    unsigned long bitPlane 
+){
+    RegionPtr ret;
+    XX_GC_OP_PROLOGUE(pGC, pDst);
+    ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
+	       pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
+    XX_GC_OP_EPILOGUE(pGC, pDst);
+
+    if(IS_VISIBLE(pDst)) {
+	BoxRec box;
+
+	DBG("CopyPlane\n");
+	box.x1 = dstx + pDst->x;
+	box.x2 = box.x1 + width;
+	box.y1 = dsty + pDst->y;
+	box.y2 = box.y1 + height;
+
+	ADD_BOX(box, pGC);
+    }
+
+    return ret;
+}
+
+static void
+xxPolyPoint(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int mode,
+    int npt,
+    xPoint *pptInit 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && npt) {
+	BoxRec box;
+
+	DBG("PolyPoint\n");
+	box.x2 = box.x1 = pptInit->x;
+	box.y2 = box.y1 = pptInit->y;
+
+	/* this could be slow if the points were spread out */
+
+	while(--npt) {
+	   pptInit++;
+	   if(box.x1 > pptInit->x) box.x1 = pptInit->x;
+	   else if(box.x2 < pptInit->x) box.x2 = pptInit->x;
+	   if(box.y1 > pptInit->y) box.y1 = pptInit->y;
+	   else if(box.y2 < pptInit->y) box.y2 = pptInit->y;
+	}
+
+	box.x2++;
+	box.y2++;
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxPolylines(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		mode,		
+    int		npt,		
+    DDXPointPtr pptInit 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+
+    if(IS_VISIBLE(pDraw) && npt) {
+	BoxRec box;
+	int extra = pGC->lineWidth >> 1;
+
+	DBG("PolyLine\n");
+	box.x2 = box.x1 = pptInit->x;
+	box.y2 = box.y1 = pptInit->y;
+
+	if(npt > 1) {
+	   if(pGC->joinStyle == JoinMiter)
+		extra = 6 * pGC->lineWidth;
+	   else if(pGC->capStyle == CapProjecting)
+		extra = pGC->lineWidth;
+        }
+
+	if(mode == CoordModePrevious) {
+	   int x = box.x1;
+	   int y = box.y1;
+	   while(--npt) {
+		pptInit++;
+		x += pptInit->x;
+		y += pptInit->y;
+		if(box.x1 > x) box.x1 = x;
+		else if(box.x2 < x) box.x2 = x;
+		if(box.y1 > y) box.y1 = y;
+		else if(box.y2 < y) box.y2 = y;
+	    }
+	} else {
+	   while(--npt) {
+		pptInit++;
+		if(box.x1 > pptInit->x) box.x1 = pptInit->x;
+		else if(box.x2 < pptInit->x) box.x2 = pptInit->x;
+		if(box.y1 > pptInit->y) box.y1 = pptInit->y;
+		else if(box.y2 < pptInit->y) box.y2 = pptInit->y;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	if(extra) {
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    }
+}
+
+static void 
+xxPolySegment(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nseg,
+    xSegment	*pSeg
+    ){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nseg) {
+	BoxRec box;
+	int extra = pGC->lineWidth;
+
+	DBG("PolySegment\n");
+        if(pGC->capStyle != CapProjecting)	
+	   extra >>= 1;
+
+	if(pSeg->x2 > pSeg->x1) {
+	    box.x1 = pSeg->x1;
+	    box.x2 = pSeg->x2;
+	} else {
+	    box.x2 = pSeg->x1;
+	    box.x1 = pSeg->x2;
+	}
+
+	if(pSeg->y2 > pSeg->y1) {
+	    box.y1 = pSeg->y1;
+	    box.y2 = pSeg->y2;
+	} else {
+	    box.y2 = pSeg->y1;
+	    box.y1 = pSeg->y2;
+	}
+
+	while(--nseg) {
+	    pSeg++;
+	    if(pSeg->x2 > pSeg->x1) {
+		if(pSeg->x1 < box.x1) box.x1 = pSeg->x1;
+		if(pSeg->x2 > box.x2) box.x2 = pSeg->x2;
+	    } else {
+		if(pSeg->x2 < box.x1) box.x1 = pSeg->x2;
+		if(pSeg->x1 > box.x2) box.x2 = pSeg->x1;
+	    }
+	    if(pSeg->y2 > pSeg->y1) {
+		if(pSeg->y1 < box.y1) box.y1 = pSeg->y1;
+		if(pSeg->y2 > box.y2) box.y2 = pSeg->y2;
+	    } else {
+		if(pSeg->y2 < box.y1) box.y1 = pSeg->y2;
+		if(pSeg->y1 > box.y2) box.y2 = pSeg->y1;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	if(extra) {
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+	
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxPolyRectangle(
+    DrawablePtr  pDraw,
+    GCPtr        pGC,
+    int	         nRects,
+    xRectangle  *pRects 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyRectangle)(pDraw, pGC, nRects, pRects);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nRects) 
+    {
+	BoxRec box;
+	int offset1, offset2, offset3;
+
+	DBG("PolyRectangle\n");
+	offset2 = pGC->lineWidth;
+	if(!offset2) offset2 = 1;
+	offset1 = offset2 >> 1;
+	offset3 = offset2 - offset1;
+
+	while(nRects--) 
+	{
+	    box.x1 = pRects->x - offset1;
+	    box.y1 = pRects->y - offset1;
+	    box.x2 = box.x1 + pRects->width + offset2;
+	    box.y2 = box.y1 + offset2;		
+	    TRANSLATE_AND_ADD_BOX(box, pGC);
+	    box.x1 = pRects->x - offset1;
+	    box.y1 = pRects->y + offset3;
+	    box.x2 = box.x1 + offset2;
+	    box.y2 = box.y1 + pRects->height - offset2;		
+	    TRANSLATE_AND_ADD_BOX(box, pGC);
+	    box.x1 = pRects->x + pRects->width - offset1;
+	    box.y1 = pRects->y + offset3;
+	    box.x2 = box.x1 + offset2;
+	    box.y2 = box.y1 + pRects->height - offset2;		
+	    TRANSLATE_AND_ADD_BOX(box, pGC);
+	    box.x1 = pRects->x - offset1;
+	    box.y1 = pRects->y + pRects->height - offset1;
+	    box.x2 = box.x1 + pRects->width + offset2;
+	    box.y2 = box.y1 + offset2;		
+	    TRANSLATE_AND_ADD_BOX(box, pGC);
+
+	    pRects++;
+	}
+    }
+}
+
+static void
+xxPolyArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && narcs) {
+	int extra = pGC->lineWidth >> 1;
+	BoxRec box;
+
+	DBG("PolyArc\n");
+	box.x1 = parcs->x;
+	box.x2 = box.x1 + parcs->width;
+	box.y1 = parcs->y;
+	box.y2 = box.y1 + parcs->height;
+
+	/* should I break these up instead ? */
+
+	while(--narcs) {
+	   parcs++;
+	   if(box.x1 > parcs->x) box.x1 = parcs->x;
+	   if(box.x2 < (parcs->x + parcs->width))
+		box.x2 = parcs->x + parcs->width;
+	   if(box.y1 > parcs->y) box.y1 = parcs->y;
+	   if(box.y2 < (parcs->y + parcs->height))
+		box.y2 = parcs->y + parcs->height;
+        }
+
+	if(extra) {
+	   box.x1 -= extra;
+	   box.x2 += extra;
+	   box.y1 -= extra;
+	   box.y2 += extra;
+        }
+
+	box.x2++;
+	box.y2++;
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxFillPolygon(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		shape,
+    int		mode,
+    int		count,
+    DDXPointPtr	pptInit 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && (count > 2)) {
+	DDXPointPtr ppt = pptInit;
+	int i = count;
+	BoxRec box;
+
+	DBG("FillPolygon\n");
+	box.x2 = box.x1 = ppt->x;
+	box.y2 = box.y1 = ppt->y;
+
+	if(mode != CoordModeOrigin) {
+	   int x = box.x1;
+	   int y = box.y1;
+	   while(--i) {
+		ppt++;
+		x += ppt->x;
+		y += ppt->y;
+		if(box.x1 > x) box.x1 = x;
+		else if(box.x2 < x) box.x2 = x;
+		if(box.y1 > y) box.y1 = y;
+		else if(box.y2 < y) box.y2 = y;
+	    }
+	} else {
+	   while(--i) {
+		ppt++;
+		if(box.x1 > ppt->x) box.x1 = ppt->x;
+		else if(box.x2 < ppt->x) box.x2 = ppt->x;
+		if(box.y1 > ppt->y) box.y1 = ppt->y;
+		else if(box.y2 < ppt->y) box.y2 = ppt->y;
+	    }
+	}
+
+	box.x2++;
+	box.y2++;
+
+	(*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, pptInit);
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    } else
+	(*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, pptInit);
+
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void 
+xxPolyFillRect(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		nRectsInit, 
+    xRectangle	*pRectsInit 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nRectsInit) {
+	BoxRec box;
+	xRectangle *pRects = pRectsInit;
+	int nRects = nRectsInit;
+
+	DBG("PolyFillRect\n");
+	box.x1 = pRects->x;
+	box.x2 = box.x1 + pRects->width;
+	box.y1 = pRects->y;
+	box.y2 = box.y1 + pRects->height;
+
+	while(--nRects) {
+	    pRects++;
+	    if(box.x1 > pRects->x) box.x1 = pRects->x;
+	    if(box.x2 < (pRects->x + pRects->width))
+		box.x2 = pRects->x + pRects->width;
+	    if(box.y1 > pRects->y) box.y1 = pRects->y;
+	    if(box.y2 < (pRects->y + pRects->height))
+		box.y2 = pRects->y + pRects->height;
+	}
+
+	/* cfb messes with the pRectsInit so we have to do our
+	   calculations first */
+
+	(*pGC->ops->PolyFillRect)(pDraw, pGC, nRectsInit, pRectsInit);
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    } else
+	(*pGC->ops->PolyFillRect)(pDraw, pGC, nRectsInit, pRectsInit);
+
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+}
+
+static void
+xxPolyFillArc(
+    DrawablePtr	pDraw,
+    GCPtr	pGC,
+    int		narcs,
+    xArc	*parcs 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && narcs) {
+	BoxRec box;
+
+	DBG("PolyFillArc\n");
+	box.x1 = parcs->x;
+	box.x2 = box.x1 + parcs->width;
+	box.y1 = parcs->y;
+	box.y2 = box.y1 + parcs->height;
+
+	/* should I break these up instead ? */
+
+	while(--narcs) {
+	   parcs++;
+	   if(box.x1 > parcs->x) box.x1 = parcs->x;
+	   if(box.x2 < (parcs->x + parcs->width))
+		box.x2 = parcs->x + parcs->width;
+	   if(box.y1 > parcs->y) box.y1 = parcs->y;
+	   if(box.y2 < (parcs->y + parcs->height))
+		box.y2 = parcs->y + parcs->height;
+        }
+
+	TRANSLATE_AND_ADD_BOX(box, pGC);
+    }
+}
+
+static int
+xxPolyText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x, 
+    int 	y,
+    int 	count,
+    char	*chars 
+){
+    int width;
+
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    width = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    width -= x;
+
+    if(IS_VISIBLE(pDraw) && (width > 0)) {
+	BoxRec box;
+
+	DBG("PolyText8\n");
+	/* ugh */
+	box.x1 = pDraw->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	if(count > 1) {
+	   if(width > 0) box.x2 += width;
+	   else box.x1 += width;
+	}
+
+	box.y1 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	ADD_BOX(box,  pGC);
+    }
+
+    return (width + x);
+}
+
+static int
+xxPolyText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars 
+){
+    int width;
+
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    width = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    width -= x;
+
+    if(IS_VISIBLE(pDraw) && (width > 0)) {
+	BoxRec box;
+
+	DBG("PolyText16\n");
+	/* ugh */
+	box.x1 = pDraw->x + x + FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	if(count > 1) {
+	   if(width > 0) box.x2 += width;
+	   else box.x1 += width;
+	}
+
+	box.y1 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	ADD_BOX(box, pGC);
+    }
+
+    return (width + x);
+}
+
+static void
+xxImageText8(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x, 
+    int		y,
+    int 	count,
+    char	*chars 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && count) {
+	int top, bot, Min, Max;
+	BoxRec box;
+
+	DBG("ImageText8\n");
+	top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+	bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+	Min = count * FONTMINBOUNDS(pGC->font, characterWidth);
+	if(Min > 0) Min = 0;
+	Max = count * FONTMAXBOUNDS(pGC->font, characterWidth);	
+	if(Max < 0) Max = 0;
+
+	/* ugh */
+	box.x1 = pDraw->x + x + Min +
+		FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + Max + 
+		FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxImageText16(
+    DrawablePtr pDraw,
+    GCPtr	pGC,
+    int		x,
+    int		y,
+    int 	count,
+    unsigned short *chars 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && count) {
+	int top, bot, Min, Max;
+	BoxRec box;
+
+	DBG("ImageText16\n");
+	top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+	bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+	Min = count * FONTMINBOUNDS(pGC->font, characterWidth);
+	if(Min > 0) Min = 0;
+	Max = count * FONTMAXBOUNDS(pGC->font, characterWidth);	
+	if(Max < 0) Max = 0;
+
+	/* ugh */
+	box.x1 = pDraw->x + x + Min +
+		FONTMINBOUNDS(pGC->font, leftSideBearing);
+	box.x2 = pDraw->x + x + Max + 
+		FONTMAXBOUNDS(pGC->font, rightSideBearing);
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxImageGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, x, y, nglyph, 
+					ppci, pglyphBase);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nglyph) {
+	int top, bot, width = 0;
+	BoxRec box;
+
+	DBG("ImageGlyphBlt\n");
+	top = max(FONTMAXBOUNDS(pGC->font, ascent), FONTASCENT(pGC->font));
+	bot = max(FONTMAXBOUNDS(pGC->font, descent), FONTDESCENT(pGC->font));
+
+	box.x1 = ppci[0]->metrics.leftSideBearing;
+	if(box.x1 > 0) box.x1 = 0;
+	box.x2 = ppci[nglyph - 1]->metrics.rightSideBearing - 
+		ppci[nglyph - 1]->metrics.characterWidth;
+	if(box.x2 < 0) box.x2 = 0;
+
+	box.x2 += pDraw->x + x;
+	box.x1 += pDraw->x + x;
+	   
+	while(nglyph--) {
+	    width += (*ppci)->metrics.characterWidth;
+	    ppci++;
+	}
+
+	if(width > 0) 
+	   box.x2 += width;
+	else 
+	   box.x1 += width;
+
+	box.y1 = pDraw->y + y - top;
+	box.y2 = pDraw->y + y + bot;
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxPolyGlyphBlt(
+    DrawablePtr pDraw,
+    GCPtr pGC,
+    int x, int y,
+    unsigned int nglyph,
+    CharInfoPtr *ppci,
+    pointer pglyphBase 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, x, y, nglyph, 
+				ppci, pglyphBase);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw) && nglyph) {
+	BoxRec box;
+
+	DBG("PolyGlyphBlt\n");
+	/* ugh */
+	box.x1 = pDraw->x + x + ppci[0]->metrics.leftSideBearing;
+	box.x2 = pDraw->x + x + ppci[nglyph - 1]->metrics.rightSideBearing;
+
+	if(nglyph > 1) {
+	    int width = 0;
+
+	    while(--nglyph) { 
+		width += (*ppci)->metrics.characterWidth;
+		ppci++;
+	    }
+	
+	    if(width > 0) box.x2 += width;
+	    else box.x1 += width;
+	}
+
+	box.y1 = pDraw->y + y - FONTMAXBOUNDS(pGC->font, ascent);
+	box.y2 = pDraw->y + y + FONTMAXBOUNDS(pGC->font, descent);
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+static void
+xxPushPixels(
+    GCPtr	pGC,
+    PixmapPtr	pBitMap,
+    DrawablePtr pDraw,
+    int	dx, int dy, int xOrg, int yOrg 
+){
+    XX_GC_OP_PROLOGUE(pGC, pDraw);
+    (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
+    XX_GC_OP_EPILOGUE(pGC, pDraw);
+
+    if(IS_VISIBLE(pDraw)) {
+	BoxRec box;
+
+	DBG("PushPixels\n");
+	box.x1 = xOrg + pDraw->x;
+	box.x2 = box.x1 + dx;
+	box.y1 = yOrg + pDraw->y;
+	box.y2 = box.y1 + dy;
+
+	ADD_BOX(box, pGC);
+    }
+}
+
+
+#ifdef RENDER
+#define RENDER_MAKE_BOX(pDrawable,X,Y,W,H) { \
+    box.x1 = X + pDrawable->x; \
+    box.x2 = X + pDrawable->x + W; \
+    box.y1 = Y + pDrawable->y; \
+    box.y2 = Y + pDrawable->y + H; \
+}
+
+#define RENDER_ADD_BOX(pScreen,box) {\
+    if (BOX_NOT_EMPTY(box)) { \
+       RegionRec region; \
+       xxScrPriv(pScreen);\
+       ScreenPtr pScreen = pScreen;\
+       REGION_INIT (pScreen, &region, &box, 1); \
+       PRINT_RECTS(pScrPriv->region);\
+       REGION_UNION(pScreen,&pScrPriv->region,&pScrPriv->region,&region);\
+       PRINT_RECTS(pScrPriv->region);\
+       REGION_UNINIT(pScreen,&region);\
+   }\
+}
+
+static void
+xxComposite (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
+	     INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
+    INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
+{
+    ScreenPtr		pScreen = pDst->pDrawable->pScreen;
+    PictureScreenPtr	ps = GetPictureScreen(pScreen);
+    xxScrPriv(pScreen);
+    BoxRec		box;
+
+    unwrap (pScrPriv, ps, Composite);
+    (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask,
+		      xDst, yDst, width, height);
+    wrap (pScrPriv, ps, Composite, xxComposite);
+    if (pDst->pDrawable->type == DRAWABLE_WINDOW) {
+	RENDER_MAKE_BOX(pDst->pDrawable, xDst, yDst, width, height);
+	RENDER_ADD_BOX(pScreen,box);
+    }
+}
+
+
+static void
+xxGlyphs (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+	  PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist,
+	  GlyphListPtr list, GlyphPtr *glyphs)
+{
+    ScreenPtr		pScreen = pDst->pDrawable->pScreen;
+    PictureScreenPtr	ps = GetPictureScreen(pScreen);
+    xxScrPriv(pScreen);
+    int			x, y;
+    int			n;
+    GlyphPtr		glyph;
+    BoxRec		box;
+
+    unwrap (pScrPriv, ps, Glyphs);
+    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc,
+		   nlist, list, glyphs);
+    wrap (pScrPriv, ps, Glyphs, xxGlyphs);
+    if (pDst->pDrawable->type == DRAWABLE_WINDOW)
+    {
+	x = xSrc;
+	y = ySrc;
+	while (nlist--)
+	{
+	    x += list->xOff;
+	    y += list->yOff;
+	    n = list->len;
+	    while (n--)
+	    {
+		glyph = *glyphs++;
+		RENDER_MAKE_BOX(pDst->pDrawable,
+				x - glyph->info.x, y - glyph->info.y,
+				glyph->info.width, glyph->info.height);
+		RENDER_ADD_BOX(pScreen,box);
+		x += glyph->info.xOff;
+		y += glyph->info.yOff;
+	    }
+	    list++;
+	}
+    }
+}
+#endif
+
+void
+xxPrintVisuals(void)
+{
+    int k,i,j;
+    DepthPtr pDepth;
+    VisualPtr pVisual;
+
+    for (k = 0; k < screenInfo.numScreens; k++) {
+	ScreenPtr pScreen = screenInfo.screens[k];
+	
+	pDepth = pScreen->allowedDepths;
+	for (i = 0; i < pScreen->numDepths; i++, pDepth++)
+	    for (j = 0; j < pDepth->numVids; j++) {
+		ErrorF("depth: %i vid: 0x%lx\n",
+		       pDepth->depth, pDepth->vids[j]);
+	    }
+	
+	pVisual = pScreen->visuals;
+	for (i = 0; i < pScreen->numVisuals; i++, pVisual++)
+	    ErrorF("vid: 0x%x rm: 0x%lx gm: 0x%lx bm: 0x%lx\n",
+		   (unsigned int)pVisual->vid,
+		   pVisual->redMask,
+		   pVisual->greenMask,
+		   pVisual->blueMask);
+    }
+}
+
+
diff --git a/fb/fbpseudocolor.h b/fb/fbpseudocolor.h
new file mode 100644
index 000000000..64de71db8
--- /dev/null
+++ b/fb/fbpseudocolor.h
@@ -0,0 +1,20 @@
+#ifndef _FB_XX_H_
+# define  _FB_XX_H_
+
+typedef void (*xxSyncFunc)(ScreenPtr);
+extern Bool xxSetup(ScreenPtr pScreen, int myDepth,
+		    int baseDepth, char *addr, xxSyncFunc sync);
+extern void xxPrintVisuals(void);
+
+
+#endif /* _FB_XX_H_ */
+
+
+
+
+
+
+
+
+
+