Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 1315 insertions, 0 deletions

diff --git a/xorg-server/hw/dmx/dmxpict.c b/xorg-server/hw/dmx/dmxpict.c
new file mode 100644
index 000000000..37dfa10ac
--- /dev/null
+++ b/xorg-server/hw/dmx/dmxpict.c
@@ -0,0 +1,1315 @@
+/*
+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kem@redhat.com>
+ *
+ */
+
+/** \file
+ *  Provide support for the RENDER extension (version 0.8).
+ */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxsync.h"
+#include "dmxpict.h"
+#include "dmxwindow.h"
+#include "dmxpixmap.h"
+
+#include "fb.h"
+#include "pixmapstr.h"
+#include "dixstruct.h"
+
+#include <X11/extensions/render.h>
+#include <X11/extensions/renderproto.h>
+#include "picture.h"
+#include "picturestr.h"
+#include "mipict.h"
+#include "fbpict.h"
+
+
+extern int RenderErrBase;
+extern int (*ProcRenderVector[RenderNumberRequests])(ClientPtr);
+
+static int (*dmxSaveRenderVector[RenderNumberRequests])(ClientPtr);
+
+
+static int dmxProcRenderCreateGlyphSet(ClientPtr client);
+static int dmxProcRenderFreeGlyphSet(ClientPtr client);
+static int dmxProcRenderAddGlyphs(ClientPtr client);
+static int dmxProcRenderFreeGlyphs(ClientPtr client);
+static int dmxProcRenderCompositeGlyphs(ClientPtr client);
+static int dmxProcRenderSetPictureTransform(ClientPtr client);
+static int dmxProcRenderSetPictureFilter(ClientPtr client);
+#if 0
+/* FIXME: Not (yet) supported */
+static int dmxProcRenderCreateCursor(ClientPtr client);
+static int dmxProcRenderCreateAnimCursor(ClientPtr client);
+#endif
+
+/** Catch errors that might occur when allocating Glyph Sets.  Errors
+ *  are saved in dmxGlyphLastError for later handling. */
+static int dmxGlyphLastError;
+static int dmxGlyphErrorHandler(Display *dpy, XErrorEvent *ev)
+{
+    dmxGlyphLastError = ev->error_code;
+    return 0;
+}
+
+
+/** Initialize the Proc Vector for the RENDER extension.  The functions
+ *  here cannot be handled by the mi layer RENDER hooks either because
+ *  the required information is no longer available when it reaches the
+ *  mi layer or no mi layer hooks exist.  This function is called from
+ *  InitOutput() since it should be initialized only once per server
+ *  generation. */
+void dmxInitRender(void)
+{
+    int i;
+
+    for (i = 0; i < RenderNumberRequests; i++)
+        dmxSaveRenderVector[i] = ProcRenderVector[i];
+
+    ProcRenderVector[X_RenderCreateGlyphSet]
+	= dmxProcRenderCreateGlyphSet;
+    ProcRenderVector[X_RenderFreeGlyphSet]
+	= dmxProcRenderFreeGlyphSet;
+    ProcRenderVector[X_RenderAddGlyphs]
+	= dmxProcRenderAddGlyphs;
+    ProcRenderVector[X_RenderFreeGlyphs]
+	= dmxProcRenderFreeGlyphs;
+    ProcRenderVector[X_RenderCompositeGlyphs8]
+	= dmxProcRenderCompositeGlyphs;
+    ProcRenderVector[X_RenderCompositeGlyphs16]
+	= dmxProcRenderCompositeGlyphs;
+    ProcRenderVector[X_RenderCompositeGlyphs32]
+	= dmxProcRenderCompositeGlyphs;
+    ProcRenderVector[X_RenderSetPictureTransform]
+	= dmxProcRenderSetPictureTransform;
+    ProcRenderVector[X_RenderSetPictureFilter]
+	= dmxProcRenderSetPictureFilter;
+}
+
+/** Reset the Proc Vector for the RENDER extension back to the original
+ *  functions.  This function is called from dmxCloseScreen() during the
+ *  server reset (only for screen #0). */
+void dmxResetRender(void)
+{
+    int i;
+
+    for (i = 0; i < RenderNumberRequests; i++)
+        ProcRenderVector[i] = dmxSaveRenderVector[i];
+}
+
+/** Initialize the RENDER extension, allocate the picture privates and
+ *  wrap mi function hooks.  If the shadow frame buffer is used, then
+ *  call the appropriate fb initialization function. */
+Bool dmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats)
+{
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps;
+
+    /* The shadow framebuffer only relies on FB to be initialized */
+    if (dmxShadowFB) return fbPictureInit(pScreen, formats, nformats);
+
+    if (!miPictureInit(pScreen, formats, nformats))
+	return FALSE;
+
+    if (!dixRequestPrivate(dmxPictPrivateKey, sizeof(dmxPictPrivRec)))
+	return FALSE;
+
+    ps = GetPictureScreen(pScreen);
+
+    DMX_WRAP(CreatePicture,      dmxCreatePicture,      dmxScreen, ps);
+    DMX_WRAP(DestroyPicture,     dmxDestroyPicture,     dmxScreen, ps);
+
+    DMX_WRAP(ChangePictureClip,  dmxChangePictureClip,  dmxScreen, ps);
+    DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps);
+
+    DMX_WRAP(ChangePicture,      dmxChangePicture,      dmxScreen, ps);
+    DMX_WRAP(ValidatePicture,    dmxValidatePicture,    dmxScreen, ps);
+
+    DMX_WRAP(Composite,          dmxComposite,          dmxScreen, ps);
+    DMX_WRAP(Glyphs,             dmxGlyphs,             dmxScreen, ps);
+    DMX_WRAP(CompositeRects,     dmxCompositeRects,     dmxScreen, ps);
+
+    DMX_WRAP(Trapezoids,         dmxTrapezoids,         dmxScreen, ps);
+    DMX_WRAP(Triangles,          dmxTriangles,          dmxScreen, ps);
+    DMX_WRAP(TriStrip,           dmxTriStrip,           dmxScreen, ps);
+    DMX_WRAP(TriFan,             dmxTriFan,             dmxScreen, ps);
+
+    return TRUE;
+}
+
+
+/** Find the appropriate format on the requested screen given the
+ *  internal format requested.  The list of formats is searched
+ *  sequentially as the XRenderFindFormat() function does not always
+ *  find the appropriate format when a specific format is requested. */
+static XRenderPictFormat *dmxFindFormat(DMXScreenInfo *dmxScreen,
+					PictFormatPtr pFmt)
+{
+    XRenderPictFormat *pFormat = NULL;
+    int                i       = 0;
+
+    if (!pFmt || !dmxScreen->beDisplay) return pFormat;
+
+    while (1) {
+	pFormat = XRenderFindFormat(dmxScreen->beDisplay, 0, 0, i++);
+	if (!pFormat) break;
+
+	if (pFormat->type             != pFmt->type)             continue;
+	if (pFormat->depth            != pFmt->depth)            continue;
+	if (pFormat->direct.red       != pFmt->direct.red)       continue;
+	if (pFormat->direct.redMask   != pFmt->direct.redMask)   continue;
+	if (pFormat->direct.green     != pFmt->direct.green)     continue;
+	if (pFormat->direct.greenMask != pFmt->direct.greenMask) continue;
+	if (pFormat->direct.blue      != pFmt->direct.blue)      continue;
+	if (pFormat->direct.blueMask  != pFmt->direct.blueMask)  continue;
+	if (pFormat->direct.alpha     != pFmt->direct.alpha)     continue;
+	if (pFormat->direct.alphaMask != pFmt->direct.alphaMask) continue;
+
+	/* We have a match! */
+	break;
+    }
+
+    return pFormat;
+}
+
+/** Free \a glyphSet on back-end screen number \a idx. */
+Bool dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet)
+{
+    dmxGlyphPrivPtr  glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+    int              idx       = pScreen->myNum;
+    DMXScreenInfo   *dmxScreen = &dmxScreens[idx];
+
+    if (glyphPriv->glyphSets[idx]) {
+	XRenderFreeGlyphSet(dmxScreen->beDisplay, glyphPriv->glyphSets[idx]);
+	glyphPriv->glyphSets[idx] = (GlyphSet)0;
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+/** Create \a glyphSet on the backend screen number \a idx. */
+int dmxBECreateGlyphSet(int idx, GlyphSetPtr glyphSet)
+{
+    XRenderPictFormat *pFormat;
+    DMXScreenInfo     *dmxScreen = &dmxScreens[idx];
+    dmxGlyphPrivPtr    glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+    PictFormatPtr      pFmt      = glyphSet->format;
+    int              (*oldErrorHandler)(Display *, XErrorEvent *);
+
+    pFormat = dmxFindFormat(dmxScreen, pFmt);
+    if (!pFormat) {
+	return BadMatch;
+    }
+
+    dmxGlyphLastError = 0;
+    oldErrorHandler = XSetErrorHandler(dmxGlyphErrorHandler);
+
+    /* Catch when this fails */
+    glyphPriv->glyphSets[idx]
+	= XRenderCreateGlyphSet(dmxScreen->beDisplay, pFormat);
+
+    XSetErrorHandler(oldErrorHandler);
+
+    if (dmxGlyphLastError) {
+	return dmxGlyphLastError;
+    }
+
+    return Success;
+}
+
+/** Create a Glyph Set on each screen.  Save the glyphset ID from each
+ *  screen in the Glyph Set's private structure.  Fail if the format
+ *  requested is not available or if the Glyph Set cannot be created on
+ *  the screen. */
+static int dmxProcRenderCreateGlyphSet(ClientPtr client)
+{
+    int  ret;
+    REQUEST(xRenderCreateGlyphSetReq);
+
+    ret = dmxSaveRenderVector[stuff->renderReqType](client);
+
+    if (ret == Success) {
+	GlyphSetPtr        glyphSet;
+	dmxGlyphPrivPtr    glyphPriv;
+	int                i;
+
+	/* Look up glyphSet that was just created ???? */
+	/* Store glyphsets from backends in glyphSet->devPrivate ????? */
+	/* Make sure we handle all errors here!! */
+	
+	glyphSet = SecurityLookupIDByType(client, stuff->gsid, GlyphSetType,
+					  DixDestroyAccess);
+	glyphPriv = xalloc(sizeof(dmxGlyphPrivRec));
+	if (!glyphPriv) return BadAlloc;
+        glyphPriv->glyphSets = NULL;
+        MAXSCREENSALLOC_RETURN(glyphPriv->glyphSets, BadAlloc);
+	DMX_SET_GLYPH_PRIV(glyphSet, glyphPriv);
+
+	for (i = 0; i < dmxNumScreens; i++) {
+	    DMXScreenInfo *dmxScreen = &dmxScreens[i];
+	    int beret;
+
+	    if (!dmxScreen->beDisplay) {
+		glyphPriv->glyphSets[i] = 0;
+		continue;
+	    }
+
+	    if ((beret = dmxBECreateGlyphSet(i, glyphSet)) != Success) {
+		int  j;
+
+		/* Free the glyph sets we've allocated thus far */
+		for (j = 0; j < i; j++)
+		    dmxBEFreeGlyphSet(screenInfo.screens[j], glyphSet);
+
+		/* Free the resource created by render */
+		FreeResource(stuff->gsid, RT_NONE);
+
+		return beret;
+	    }
+	}
+    }
+
+    return ret;
+}
+
+/** Free the previously allocated Glyph Sets for each screen. */
+static int dmxProcRenderFreeGlyphSet(ClientPtr client)
+{
+    GlyphSetPtr  glyphSet;
+    REQUEST(xRenderFreeGlyphSetReq);
+
+    REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
+    glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType,
+				      DixDestroyAccess);
+
+    if (glyphSet && glyphSet->refcnt == 1) {
+	dmxGlyphPrivPtr  glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+	int              i;
+
+	for (i = 0; i < dmxNumScreens; i++) {
+	    DMXScreenInfo *dmxScreen = &dmxScreens[i];
+	    
+	    if (dmxScreen->beDisplay) {
+		if (dmxBEFreeGlyphSet(screenInfo.screens[i], glyphSet))
+		    dmxSync(dmxScreen, FALSE);
+	    }
+	}
+
+        MAXSCREENSFREE(glyphPriv->glyphSets);
+	xfree(glyphPriv);
+	DMX_SET_GLYPH_PRIV(glyphSet, NULL);
+    }
+
+    return dmxSaveRenderVector[stuff->renderReqType](client);
+}
+
+/** Add glyphs to the Glyph Set on each screen. */
+static int dmxProcRenderAddGlyphs(ClientPtr client)
+{
+    int  ret;
+    REQUEST(xRenderAddGlyphsReq);
+
+    ret = dmxSaveRenderVector[stuff->renderReqType](client);
+
+    if (ret == Success) {
+	GlyphSetPtr      glyphSet;
+	dmxGlyphPrivPtr  glyphPriv;
+	int              i;
+	int              nglyphs;
+	CARD32          *gids;
+	Glyph           *gidsCopy;
+	xGlyphInfo      *gi;
+	CARD8           *bits;
+	int              nbytes;
+
+	glyphSet = SecurityLookupIDByType(client, stuff->glyphset,
+					  GlyphSetType, DixReadAccess);
+	glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+
+	nglyphs = stuff->nglyphs;
+	gids = (CARD32 *)(stuff + 1);
+	gi = (xGlyphInfo *)(gids + nglyphs);
+	bits = (CARD8 *)(gi + nglyphs);
+	nbytes = ((stuff->length << 2) -
+		  sizeof(xRenderAddGlyphsReq) -
+		  (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs);
+
+        gidsCopy = xalloc(sizeof(*gidsCopy) * nglyphs);
+        for (i = 0; i < nglyphs; i++) gidsCopy[i] = gids[i];
+
+	/* FIXME: Will this ever fail? */
+	for (i = 0; i < dmxNumScreens; i++) {
+	    DMXScreenInfo *dmxScreen = &dmxScreens[i];
+
+	    if (dmxScreen->beDisplay) {
+		XRenderAddGlyphs(dmxScreen->beDisplay,
+				 glyphPriv->glyphSets[i],
+				 gidsCopy,
+				 (XGlyphInfo *)gi,
+				 nglyphs,
+				 (char *)bits,
+				 nbytes);
+		dmxSync(dmxScreen, FALSE);
+	    }
+	}
+        xfree(gidsCopy);
+    }
+
+    return ret;
+}
+
+/** Free glyphs from the Glyph Set for each screen. */
+static int dmxProcRenderFreeGlyphs(ClientPtr client)
+{
+    GlyphSetPtr  glyphSet;
+    REQUEST(xRenderFreeGlyphsReq);
+
+    REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
+    glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType,
+				      DixWriteAccess);
+
+    if (glyphSet) {
+	dmxGlyphPrivPtr  glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+	int              i;
+	int              nglyphs;
+	Glyph           *gids;
+
+	nglyphs = ((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)) >> 2;
+	if (nglyphs) {
+            gids    = xalloc(sizeof(*gids) * nglyphs);
+            for (i = 0; i < nglyphs; i++)
+                gids[i] = ((CARD32 *)(stuff + 1))[i];
+            
+	    for (i = 0; i < dmxNumScreens; i++) {
+		DMXScreenInfo *dmxScreen = &dmxScreens[i];
+
+		if (dmxScreen->beDisplay) {
+		    XRenderFreeGlyphs(dmxScreen->beDisplay,
+				      glyphPriv->glyphSets[i], gids, nglyphs);
+		    dmxSync(dmxScreen, FALSE);
+		}
+	    }
+            xfree(gids);
+	}
+    }
+
+    return dmxSaveRenderVector[stuff->renderReqType](client);
+}
+
+/** Composite glyphs on each screen into the requested picture.  If
+ *  either the src or dest picture has not been allocated due to lazy
+ *  window creation, this request will gracefully return. */
+static int dmxProcRenderCompositeGlyphs(ClientPtr client)
+{
+    int  ret;
+    REQUEST(xRenderCompositeGlyphsReq);
+
+    ret = dmxSaveRenderVector[stuff->renderReqType](client);
+
+    /* For the following to work with PanoramiX, it assumes that Render
+     * wraps the ProcRenderVector after dmxRenderInit has been called.
+     */
+    if (ret == Success) {
+	PicturePtr         pSrc;
+	dmxPictPrivPtr     pSrcPriv;
+	PicturePtr         pDst;
+	dmxPictPrivPtr     pDstPriv;
+	PictFormatPtr      pFmt;
+	XRenderPictFormat *pFormat;
+	int                size;
+
+	int                scrnNum;
+	DMXScreenInfo     *dmxScreen;
+
+	CARD8             *buffer;
+	CARD8             *end;
+	int                space;
+
+	int                nglyph;
+	char              *glyphs;
+	char              *curGlyph;
+
+	xGlyphElt         *elt;
+	int                nelt;
+	XGlyphElt8        *elts;
+	XGlyphElt8        *curElt;
+
+	GlyphSetPtr        glyphSet;
+	dmxGlyphPrivPtr    glyphPriv;
+
+	pSrc = SecurityLookupIDByType(client, stuff->src, PictureType,
+				      DixReadAccess);
+	pSrcPriv = DMX_GET_PICT_PRIV(pSrc);
+	if (!pSrcPriv->pict)
+	    return ret;
+
+	pDst = SecurityLookupIDByType(client, stuff->dst, PictureType,
+				      DixWriteAccess);
+	pDstPriv = DMX_GET_PICT_PRIV(pDst);
+	if (!pDstPriv->pict)
+	    return ret;
+
+	scrnNum = pDst->pDrawable->pScreen->myNum;
+	dmxScreen = &dmxScreens[scrnNum];
+
+	/* Note: If the back-end display has been detached, then it
+	 * should not be possible to reach here since the pSrcPriv->pict
+	 * and pDstPriv->pict will have already been set to 0.
+	 */
+	if (!dmxScreen->beDisplay)
+	    return ret;
+
+	if (stuff->maskFormat)
+	    pFmt = SecurityLookupIDByType(client, stuff->maskFormat,
+					  PictFormatType, DixReadAccess);
+	else
+	    pFmt = NULL;
+
+	pFormat = dmxFindFormat(dmxScreen, pFmt);
+
+	switch (stuff->renderReqType) {
+	case X_RenderCompositeGlyphs8:  size = sizeof(CARD8);  break;
+	case X_RenderCompositeGlyphs16: size = sizeof(CARD16); break;
+	case X_RenderCompositeGlyphs32: size = sizeof(CARD32); break;
+        default:                        return BadPictOp; /* Can't happen */
+	}
+
+	buffer = (CARD8 *)(stuff + 1);
+	end = (CARD8 *)stuff + (stuff->length << 2);
+	nelt = 0;
+	nglyph = 0;
+	while (buffer + sizeof(xGlyphElt) < end) {
+	    elt = (xGlyphElt *)buffer;
+	    buffer += sizeof(xGlyphElt);
+
+	    if (elt->len == 0xff) {
+		buffer += 4;
+	    } else {
+		nelt++;
+		nglyph += elt->len;
+		space = size * elt->len;
+		if (space & 3) space += 4 - (space & 3);
+		buffer += space;
+	    }
+	}
+
+	/* The following only works for Render version > 0.2 */
+
+	/* All of the XGlyphElt* structure sizes are identical */
+	elts = xalloc(nelt * sizeof(XGlyphElt8));
+	if (!elts)
+	    return BadAlloc;
+
+	glyphs = xalloc(nglyph * size);
+	if (!glyphs) {
+	    xfree(elts);
+	    return BadAlloc;
+	}
+
+	buffer = (CARD8 *)(stuff + 1);
+	end = (CARD8 *)stuff + (stuff->length << 2);
+	curGlyph = glyphs;
+	curElt = elts;
+
+	glyphSet = SecurityLookupIDByType(client, stuff->glyphset,
+					  GlyphSetType, DixReadAccess);
+	glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+
+	while (buffer + sizeof(xGlyphElt) < end) {
+	    elt = (xGlyphElt *)buffer;
+	    buffer += sizeof(xGlyphElt);
+
+	    if (elt->len == 0xff) {
+		glyphSet = SecurityLookupIDByType(client,
+						  *((CARD32 *)buffer),
+						  GlyphSetType,
+						  DixReadAccess);
+		glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
+		buffer += 4;
+	    } else {
+		curElt->glyphset = glyphPriv->glyphSets[scrnNum];
+		curElt->xOff = elt->deltax;
+		curElt->yOff = elt->deltay;
+		curElt->nchars = elt->len;
+		curElt->chars = curGlyph;
+
+		memcpy(curGlyph, buffer, size*elt->len);
+		curGlyph += size * elt->len;
+
+		curElt++;
+
+		space = size * elt->len;
+		if (space & 3) space += 4 - (space & 3);
+		buffer += space;
+	    }
+	}
+
+	switch (stuff->renderReqType) {
+	case X_RenderCompositeGlyphs8:
+	    XRenderCompositeText8(dmxScreen->beDisplay, stuff->op,
+				  pSrcPriv->pict, pDstPriv->pict,
+				  pFormat,
+				  stuff->xSrc, stuff->ySrc,
+				  0, 0, elts, nelt);
+	    break;
+	case X_RenderCompositeGlyphs16:
+	    XRenderCompositeText16(dmxScreen->beDisplay, stuff->op,
+				   pSrcPriv->pict, pDstPriv->pict,
+				   pFormat,
+				   stuff->xSrc, stuff->ySrc,
+				   0, 0, (XGlyphElt16 *)elts, nelt);
+	    break;
+	case X_RenderCompositeGlyphs32:
+	    XRenderCompositeText32(dmxScreen->beDisplay, stuff->op,
+				   pSrcPriv->pict, pDstPriv->pict,
+				   pFormat,
+				   stuff->xSrc, stuff->ySrc,
+				   0, 0, (XGlyphElt32 *)elts, nelt);
+	    break;
+	}
+
+	dmxSync(dmxScreen, FALSE);
+
+	xfree(elts);
+	xfree(glyphs);
+    }
+
+    return ret;
+}
+
+/** Set the picture transform on each screen. */
+static int dmxProcRenderSetPictureTransform(ClientPtr client)
+{
+    DMXScreenInfo  *dmxScreen;
+    PicturePtr      pPicture;
+    dmxPictPrivPtr  pPictPriv;
+    XTransform      xform;
+    REQUEST(xRenderSetPictureTransformReq);
+
+    REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess,
+		   RenderErrBase + BadPicture);
+
+    /* For the following to work with PanoramiX, it assumes that Render
+     * wraps the ProcRenderVector after dmxRenderInit has been called.
+     */
+    dmxScreen = &dmxScreens[pPicture->pDrawable->pScreen->myNum];
+    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    if (pPictPriv->pict) {
+	xform.matrix[0][0] = stuff->transform.matrix11;
+	xform.matrix[0][1] = stuff->transform.matrix12;
+	xform.matrix[0][2] = stuff->transform.matrix13;
+	xform.matrix[1][0] = stuff->transform.matrix21;
+	xform.matrix[1][1] = stuff->transform.matrix22;
+	xform.matrix[1][2] = stuff->transform.matrix23;
+	xform.matrix[2][0] = stuff->transform.matrix31;
+	xform.matrix[2][1] = stuff->transform.matrix32;
+	xform.matrix[2][2] = stuff->transform.matrix33;
+
+	XRenderSetPictureTransform(dmxScreen->beDisplay,
+				   pPictPriv->pict,
+				   &xform);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    return dmxSaveRenderVector[stuff->renderReqType](client);
+}
+
+/** Set the picture filter on each screen. */
+static int dmxProcRenderSetPictureFilter(ClientPtr client)
+{
+    DMXScreenInfo  *dmxScreen;
+    PicturePtr      pPicture;
+    dmxPictPrivPtr  pPictPriv;
+    char           *filter;
+    XFixed         *params;
+    int             nparams;
+    REQUEST(xRenderSetPictureFilterReq);
+
+    REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess,
+		   RenderErrBase + BadPicture);
+
+    /* For the following to work with PanoramiX, it assumes that Render
+     * wraps the ProcRenderVector after dmxRenderInit has been called.
+     */
+    dmxScreen = &dmxScreens[pPicture->pDrawable->pScreen->myNum];
+    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    if (pPictPriv->pict) {
+	filter  = (char *)(stuff + 1);
+	params  = (XFixed *)(filter + ((stuff->nbytes + 3) & ~3));
+	nparams = ((XFixed *)stuff + client->req_len) - params;
+
+	XRenderSetPictureFilter(dmxScreen->beDisplay,
+				pPictPriv->pict,
+				filter,
+				params,
+				nparams);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    return dmxSaveRenderVector[stuff->renderReqType](client);
+}
+
+
+/** Create a picture on the appropriate screen.  This is the actual
+ *  function that creates the picture.  However, if the associated
+ *  window has not yet been created due to lazy window creation, then
+ *  delay the picture creation until the window is mapped. */
+static Picture dmxDoCreatePicture(PicturePtr pPicture)
+{
+    DrawablePtr               pDraw     = pPicture->pDrawable;
+    ScreenPtr                 pScreen   = pDraw->pScreen;
+    DMXScreenInfo            *dmxScreen = &dmxScreens[pScreen->myNum];
+    XRenderPictFormat        *pFormat;
+    Drawable                  draw;
+
+    if (pPicture->pDrawable->type == DRAWABLE_WINDOW) {
+	dmxWinPrivPtr  pWinPriv = DMX_GET_WINDOW_PRIV((WindowPtr)(pDraw));
+
+	if (!(draw = pWinPriv->window)) {
+	    /* Window has not been created yet due to the window
+	     * optimization.  Delay picture creation until window is
+	     * mapped.
+	     */
+	    pWinPriv->hasPict = TRUE;
+	    return 0;
+	}
+    } else {
+	dmxPixPrivPtr  pPixPriv = DMX_GET_PIXMAP_PRIV((PixmapPtr)(pDraw));
+
+	if (!(draw = pPixPriv->pixmap)) {
+	    /* FIXME: Zero width/height pixmap?? */
+	    return 0;
+	}
+    }
+
+    /* This should not be reached if the back-end display has been
+     * detached because the pWinPriv->window or the pPixPriv->pixmap
+     * will be NULL; however, we add it here for completeness
+     */
+    if (!dmxScreen->beDisplay)
+	return 0;
+
+    pFormat = dmxFindFormat(dmxScreen, pPicture->pFormat);
+
+    return XRenderCreatePicture(dmxScreen->beDisplay, draw, pFormat, 0, 0);
+}
+
+/** Create a list of pictures.  This function is called by
+ *  dmxCreateAndRealizeWindow() during the lazy window creation
+ *  realization process.  It creates the entire list of pictures that
+ *  are associated with the given window. */
+void dmxCreatePictureList(WindowPtr pWindow)
+{
+    PicturePtr  pPicture = GetPictureWindow(pWindow);
+
+    while (pPicture) {
+	dmxPictPrivPtr  pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+	/* Create the picture for this window */
+	pPictPriv->pict = dmxDoCreatePicture(pPicture);
+
+	/* ValidatePicture takes care of the state changes */
+
+	pPicture = pPicture->pNext;
+    }
+}
+
+/** Create \a pPicture on the backend. */
+int dmxBECreatePicture(PicturePtr pPicture)
+{
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    /* Create picutre on BE */
+    pPictPriv->pict = dmxDoCreatePicture(pPicture);
+
+    /* Flush changes to the backend server */
+    dmxValidatePicture(pPicture, (1 << (CPLastBit+1)) - 1);
+
+    return Success;
+}
+
+/** Create a picture.  This function handles the CreatePicture
+ *  unwrapping/wrapping and calls dmxDoCreatePicture to actually create
+ *  the picture on the appropriate screen.  */
+int dmxCreatePicture(PicturePtr pPicture)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+    int               ret       = Success;
+
+    DMX_UNWRAP(CreatePicture, dmxScreen, ps);
+#if 1
+    if (ps->CreatePicture)
+	ret = ps->CreatePicture(pPicture);
+#endif
+
+    /* Create picture on back-end server */
+    pPictPriv->pict      = dmxDoCreatePicture(pPicture);
+    pPictPriv->savedMask = 0;
+
+    DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps);
+
+    return ret;
+}
+
+/** Destroy \a pPicture on the back-end server. */
+Bool dmxBEFreePicture(PicturePtr pPicture)
+{
+    ScreenPtr      pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
+    dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    if (pPictPriv->pict) {
+	XRenderFreePicture(dmxScreen->beDisplay, pPictPriv->pict);
+	pPictPriv->pict = (Picture)0;
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+/** Destroy a list of pictures that are associated with the window that
+ *  is being destroyed.  This function is called by #dmxDestroyWindow().
+ *  */
+Bool dmxDestroyPictureList(WindowPtr pWindow)
+{
+    PicturePtr  pPicture = GetPictureWindow(pWindow);
+    Bool        ret      = FALSE;
+
+    while (pPicture) {
+	ret |= dmxBEFreePicture(pPicture);
+	pPicture = pPicture->pNext;
+    }
+
+    return ret;
+}
+
+/** Destroy a picture.  This function calls the wrapped function that
+ *  frees the resources in the DMX server associated with this
+ *  picture. */
+void dmxDestroyPicture(PicturePtr pPicture)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+
+    DMX_UNWRAP(DestroyPicture, dmxScreen, ps);
+
+    /* Destroy picture on back-end server */
+    if (dmxBEFreePicture(pPicture))
+	dmxSync(dmxScreen, FALSE);
+
+#if 1
+    if (ps->DestroyPicture)
+	ps->DestroyPicture(pPicture);
+#endif
+    DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps);
+}
+
+/** Change the picture's list of clip rectangles. */
+int dmxChangePictureClip(PicturePtr pPicture, int clipType,
+			 pointer value, int n)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    DMX_UNWRAP(ChangePictureClip, dmxScreen, ps);
+#if 1
+    if (ps->ChangePictureClip)
+	ps->ChangePictureClip(pPicture, clipType, value, n);
+#endif
+
+    /* Change picture clip rects on back-end server */
+    if (pPictPriv->pict) {
+	/* The clip has already been changed into a region by the mi
+	 * routine called above.
+	 */
+	if (clipType == CT_NONE) {
+	    /* Disable clipping, show all */
+	    XFixesSetPictureClipRegion(dmxScreen->beDisplay,
+				       pPictPriv->pict, 0, 0, None);
+	} else if (pPicture->clientClip) {
+	    RegionPtr   pClip = pPicture->clientClip;
+	    BoxPtr      pBox  = REGION_RECTS(pClip);
+	    int         nBox  = REGION_NUM_RECTS(pClip);
+	    XRectangle *pRects;
+	    XRectangle *pRect;
+	    int         nRects;
+
+	    nRects = nBox;
+	    pRects = pRect = xalloc(nRects * sizeof(*pRect));
+
+	    while (nBox--) {
+		pRect->x      = pBox->x1;
+		pRect->y      = pBox->y1;
+		pRect->width  = pBox->x2 - pBox->x1;
+		pRect->height = pBox->y2 - pBox->y1;
+		pBox++;
+		pRect++;
+	    }
+
+	    XRenderSetPictureClipRectangles(dmxScreen->beDisplay,
+					    pPictPriv->pict,
+					    0, 0,
+					    pRects,
+					    nRects);
+	    xfree(pRects);
+	} else {
+	    XRenderSetPictureClipRectangles(dmxScreen->beDisplay,
+					    pPictPriv->pict,
+					    0, 0, NULL, 0);
+	}
+	dmxSync(dmxScreen, FALSE);
+    } else {
+	/* FIXME: Handle saving clip region when offscreen */
+    }
+
+    DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps);
+    
+    return Success;
+}
+
+/** Destroy the picture's list of clip rectangles. */
+void dmxDestroyPictureClip(PicturePtr pPicture)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    DMX_UNWRAP(DestroyPictureClip, dmxScreen, ps);
+#if 1
+    if (ps->DestroyPictureClip)
+	ps->DestroyPictureClip(pPicture);
+#endif
+
+    /* Destroy picture clip rects on back-end server */
+    if (pPictPriv->pict) {
+	XRenderSetPictureClipRectangles(dmxScreen->beDisplay,
+					pPictPriv->pict,
+					0, 0, NULL, 0);
+	dmxSync(dmxScreen, FALSE);
+    } else {
+	/* FIXME: Handle destroying clip region when offscreen */
+    }
+
+    DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps);
+}
+
+/** Change the attributes of the pictures.  If the picture has not yet
+ *  been created due to lazy window creation, save the mask so that it
+ *  can be used to appropriately initialize the picture's attributes
+ *  when it is created later. */
+void dmxChangePicture(PicturePtr pPicture, Mask mask)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    DMX_UNWRAP(ChangePicture, dmxScreen, ps);
+#if 1
+    if (ps->ChangePicture)
+	ps->ChangePicture(pPicture, mask);
+#endif
+
+    /* Picture attribute changes are handled in ValidatePicture */
+    pPictPriv->savedMask |= mask;
+
+    DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps);
+}
+
+/** Validate the picture's attributes before rendering to it.  Update
+ *  any picture attributes that have been changed by one of the higher
+ *  layers. */
+void dmxValidatePicture(PicturePtr pPicture, Mask mask)
+{
+    ScreenPtr         pScreen   = pPicture->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pPicture);
+
+    DMX_UNWRAP(ValidatePicture, dmxScreen, ps);
+
+    /* Change picture attributes on back-end server */
+    if (pPictPriv->pict) {
+	XRenderPictureAttributes  attribs;
+
+	if (mask & CPRepeat) {
+	    attribs.repeat = pPicture->repeatType;
+	}
+	if (mask & CPAlphaMap) {
+	    if (pPicture->alphaMap) {
+		dmxPictPrivPtr  pAlphaPriv;
+		pAlphaPriv = DMX_GET_PICT_PRIV(pPicture->alphaMap);
+		if (pAlphaPriv->pict) {
+		    attribs.alpha_map = pAlphaPriv->pict;
+		} else {
+		    /* FIXME: alpha picture drawable has not been created?? */
+		    return; /* or should this be: attribs.alpha_map = None; */
+		}
+	    } else {
+		attribs.alpha_map = None;
+	    }
+	}
+	if (mask & CPAlphaXOrigin)
+	    attribs.alpha_x_origin = pPicture->alphaOrigin.x;
+	if (mask & CPAlphaYOrigin)
+	    attribs.alpha_y_origin = pPicture->alphaOrigin.y;
+	if (mask & CPClipXOrigin)
+	    attribs.clip_x_origin = pPicture->clipOrigin.x;
+	if (mask & CPClipYOrigin)
+	    attribs.clip_y_origin = pPicture->clipOrigin.y;
+	if (mask & CPClipMask)
+	    mask &= ~CPClipMask; /* Handled in ChangePictureClip */
+	if (mask & CPGraphicsExposure)
+	    attribs.graphics_exposures = pPicture->graphicsExposures;
+	if (mask & CPSubwindowMode)
+	    attribs.subwindow_mode = pPicture->subWindowMode;
+	if (mask & CPPolyEdge)
+	    attribs.poly_edge = pPicture->polyEdge;
+	if (mask & CPPolyMode)
+	    attribs.poly_mode = pPicture->polyMode;
+	if (mask & CPDither)
+	    attribs.dither = pPicture->dither;
+	if (mask & CPComponentAlpha)
+	    attribs.component_alpha = pPicture->componentAlpha;
+
+	XRenderChangePicture(dmxScreen->beDisplay, pPictPriv->pict,
+			     mask, &attribs);
+	dmxSync(dmxScreen, FALSE);
+    } else {
+	pPictPriv->savedMask |= mask;
+    }
+
+#if 1
+    if (ps->ValidatePicture)
+	ps->ValidatePicture(pPicture, mask);
+#endif
+
+    DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps);
+}
+
+/** Composite a picture on the appropriate screen by combining the
+ *  specified rectangle of the transformed src and mask operands with
+ *  the specified rectangle of the dst using op as the compositing
+ *  operator.  For a complete description see the protocol document of
+ *  the RENDER library. */
+void dmxComposite(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;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pSrcPriv  = DMX_GET_PICT_PRIV(pSrc);
+    dmxPictPrivPtr    pMaskPriv = NULL;
+    dmxPictPrivPtr    pDstPriv  = DMX_GET_PICT_PRIV(pDst);
+
+    if (pMask) pMaskPriv = DMX_GET_PICT_PRIV(pMask);
+
+    DMX_UNWRAP(Composite, dmxScreen, ps);
+#if 0
+    if (ps->Composite)
+	ps->Composite(op, pSrc, pMask, pDst,
+		      xSrc, ySrc, xMask, yMask, xDst, yDst,
+		      width, height);
+#endif
+
+    /* Composite on back-end server */
+    if (pSrcPriv->pict && pDstPriv->pict &&
+	((pMaskPriv && pMaskPriv->pict) || !pMaskPriv)) {
+	XRenderComposite(dmxScreen->beDisplay,
+			 op,
+			 pSrcPriv->pict,
+			 pMaskPriv ? pMaskPriv->pict : None,
+			 pDstPriv->pict,
+			 xSrc, ySrc,
+			 xMask, yMask,
+			 xDst, yDst,
+			 width, height);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+
+    DMX_WRAP(Composite, dmxComposite, dmxScreen, ps);
+}
+
+/** Null function to catch when/if RENDER calls lower level mi hooks.
+ *  Compositing glyphs is handled by dmxProcRenderCompositeGlyphs().
+ *  This function should never be called. */
+void dmxGlyphs(CARD8 op,
+	       PicturePtr pSrc, PicturePtr pDst,
+	       PictFormatPtr maskFormat,
+	       INT16 xSrc, INT16 ySrc,
+	       int nlists, GlyphListPtr lists, GlyphPtr *glyphs)
+{
+    /* This won't work, so we need to wrap ProcRenderCompositeGlyphs */
+}
+
+/** Fill a rectangle on the appropriate screen by combining the color
+ *  with the dest picture in the area specified by the list of
+ *  rectangles.  For a complete description see the protocol document of
+ *  the RENDER library. */
+void dmxCompositeRects(CARD8 op,
+		       PicturePtr pDst,
+		       xRenderColor *color,
+		       int nRect, xRectangle *rects)
+{
+    ScreenPtr         pScreen   = pDst->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pPictPriv = DMX_GET_PICT_PRIV(pDst);
+
+    DMX_UNWRAP(CompositeRects, dmxScreen, ps);
+#if 0
+    if (ps->CompositeRects)
+	ps->CompositeRects(op, pDst, color, nRect, rects);
+#endif
+
+    /* CompositeRects on back-end server */
+    if (pPictPriv->pict) {
+	XRenderFillRectangles(dmxScreen->beDisplay,
+			      op,
+			      pPictPriv->pict,
+			      (XRenderColor *)color,
+			      (XRectangle *)rects,
+			      nRect);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps);
+}
+
+/** Indexed color visuals are not yet supported. */
+Bool dmxInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat)
+{
+    return TRUE;
+}
+
+/** Indexed color visuals are not yet supported. */
+void dmxCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat)
+{
+}
+
+/** Indexed color visuals are not yet supported. */
+void dmxUpdateIndexed(ScreenPtr pScreen, PictFormatPtr pFormat,
+		      int ndef, xColorItem *pdef)
+{
+}
+
+/** Composite a list of trapezoids on the appropriate screen.  For a
+ *  complete description see the protocol document of the RENDER
+ *  library. */
+void dmxTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+		   PictFormatPtr maskFormat,
+		   INT16 xSrc, INT16 ySrc,
+		   int ntrap, xTrapezoid *traps)
+{
+    ScreenPtr         pScreen   = pDst->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pSrcPriv  = DMX_GET_PICT_PRIV(pSrc);
+    dmxPictPrivPtr    pDstPriv  = DMX_GET_PICT_PRIV(pDst);
+
+    DMX_UNWRAP(Trapezoids, dmxScreen, ps);
+#if 0
+    if (ps->Trapezoids)
+	ps->Trapezoids(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntrap, *traps);
+#endif
+
+    /* Draw trapezoids on back-end server */
+    if (pDstPriv->pict) {
+	XRenderPictFormat *pFormat;
+
+	pFormat = dmxFindFormat(dmxScreen, maskFormat);
+	if (!pFormat) {
+	    /* FIXME: Error! */
+	}
+
+	XRenderCompositeTrapezoids(dmxScreen->beDisplay,
+				   op,
+				   pSrcPriv->pict,
+				   pDstPriv->pict,
+				   pFormat,
+				   xSrc, ySrc,
+				   (XTrapezoid *)traps,
+				   ntrap);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    DMX_WRAP(Trapezoids, dmxTrapezoids, dmxScreen, ps);
+}
+
+/** Composite a list of triangles on the appropriate screen.  For a
+ *  complete description see the protocol document of the RENDER
+ *  library. */
+void dmxTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+		  PictFormatPtr maskFormat,
+		  INT16 xSrc, INT16 ySrc,
+		  int ntri, xTriangle *tris)
+{
+    ScreenPtr         pScreen   = pDst->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pSrcPriv  = DMX_GET_PICT_PRIV(pSrc);
+    dmxPictPrivPtr    pDstPriv  = DMX_GET_PICT_PRIV(pDst);
+
+    DMX_UNWRAP(Triangles, dmxScreen, ps);
+#if 0
+    if (ps->Triangles)
+	ps->Triangles(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, *tris);
+#endif
+
+    /* Draw trapezoids on back-end server */
+    if (pDstPriv->pict) {
+	XRenderPictFormat *pFormat;
+
+	pFormat = dmxFindFormat(dmxScreen, maskFormat);
+	if (!pFormat) {
+	    /* FIXME: Error! */
+	}
+
+	XRenderCompositeTriangles(dmxScreen->beDisplay,
+				  op,
+				  pSrcPriv->pict,
+				  pDstPriv->pict,
+				  pFormat,
+				  xSrc, ySrc,
+				  (XTriangle *)tris,
+				  ntri);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    DMX_WRAP(Triangles, dmxTriangles, dmxScreen, ps);
+}
+
+/** Composite a triangle strip on the appropriate screen.  For a
+ *  complete description see the protocol document of the RENDER
+ *  library. */
+void dmxTriStrip(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+		 PictFormatPtr maskFormat,
+		 INT16 xSrc, INT16 ySrc,
+		 int npoint, xPointFixed *points)
+{
+    ScreenPtr         pScreen   = pDst->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pSrcPriv  = DMX_GET_PICT_PRIV(pSrc);
+    dmxPictPrivPtr    pDstPriv  = DMX_GET_PICT_PRIV(pDst);
+
+    DMX_UNWRAP(TriStrip, dmxScreen, ps);
+#if 0
+    if (ps->TriStrip)
+	ps->TriStrip(op, pSrc, pDst, maskFormat, xSrc, ySrc, npoint, *points);
+#endif
+
+    /* Draw trapezoids on back-end server */
+    if (pDstPriv->pict) {
+	XRenderPictFormat *pFormat;
+
+	pFormat = dmxFindFormat(dmxScreen, maskFormat);
+	if (!pFormat) {
+	    /* FIXME: Error! */
+	}
+
+	XRenderCompositeTriStrip(dmxScreen->beDisplay,
+				 op,
+				 pSrcPriv->pict,
+				 pDstPriv->pict,
+				 pFormat,
+				 xSrc, ySrc,
+				 (XPointFixed *)points,
+				 npoint);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    DMX_WRAP(TriStrip, dmxTriStrip, dmxScreen, ps);
+}
+
+/** Composite a triangle fan on the appropriate screen.  For a complete
+ *  description see the protocol document of the RENDER library. */
+void dmxTriFan(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+	       PictFormatPtr maskFormat,
+	       INT16 xSrc, INT16 ySrc,
+	       int npoint, xPointFixed *points)
+{
+    ScreenPtr         pScreen   = pDst->pDrawable->pScreen;
+    DMXScreenInfo    *dmxScreen = &dmxScreens[pScreen->myNum];
+    PictureScreenPtr  ps        = GetPictureScreen(pScreen);
+    dmxPictPrivPtr    pSrcPriv  = DMX_GET_PICT_PRIV(pSrc);
+    dmxPictPrivPtr    pDstPriv  = DMX_GET_PICT_PRIV(pDst);
+
+    DMX_UNWRAP(TriFan, dmxScreen, ps);
+#if 0
+    if (ps->TriFan)
+	ps->TriFan(op, pSrc, pDst, maskFormat, xSrc, ySrc, npoint, *points);
+#endif
+
+    /* Draw trapezoids on back-end server */
+    if (pDstPriv->pict) {
+	XRenderPictFormat *pFormat;
+
+	pFormat = dmxFindFormat(dmxScreen, maskFormat);
+	if (!pFormat) {
+	    /* FIXME: Error! */
+	}
+
+	XRenderCompositeTriFan(dmxScreen->beDisplay,
+			       op,
+			       pSrcPriv->pict,
+			       pDstPriv->pict,
+			       pFormat,
+			       xSrc, ySrc,
+			       (XPointFixed *)points,
+			       npoint);
+	dmxSync(dmxScreen, FALSE);
+    }
+
+    DMX_WRAP(TriFan, dmxTriFan, dmxScreen, ps);
+}