Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 889 insertions, 0 deletions

diff --git a/nx-X11/lib/Xrender/Xrender.c b/nx-X11/lib/Xrender/Xrender.c
new file mode 100644
index 000000000..8d8aeb979
--- /dev/null
+++ b/nx-X11/lib/Xrender/Xrender.c
@@ -0,0 +1,889 @@
+/*
+ *
+ * Copyright © 2000 SuSE, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of SuSE not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  SuSE makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author:  Keith Packard, SuSE, Inc.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xrenderint.h"
+
+XRenderExtInfo XRenderExtensionInfo;
+char XRenderExtensionName[] = RENDER_NAME;
+
+static int XRenderCloseDisplay (Display *dpy, XExtCodes *codes);
+
+/*
+ * XRenderExtFindDisplay - look for a display in this extension; keeps a
+ * cache of the most-recently used for efficiency. (Replaces
+ * XextFindDisplay.)
+ */
+static XRenderExtDisplayInfo *
+XRenderExtFindDisplay (XRenderExtInfo *extinfo, 
+                       Display        *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    /*
+     * see if this was the most recently accessed display
+     */
+    if ((dpyinfo = extinfo->cur) && dpyinfo->display == dpy) 
+        return dpyinfo;
+
+    /*
+     * look for display in list
+     */
+    _XLockMutex(_Xglobal_lock);
+    for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) {
+        if (dpyinfo->display == dpy) {
+            extinfo->cur = dpyinfo;     /* cache most recently used */
+            _XUnlockMutex(_Xglobal_lock);
+            return dpyinfo;
+        }
+    }
+    _XUnlockMutex(_Xglobal_lock);
+
+    return NULL;
+}
+
+/*
+ * If the server is missing support for any of the required depths on
+ * any screen, tell the application that Render is not present.
+ */
+
+#define DEPTH_MASK(d)	(1 << ((d) - 1))
+    
+/*
+ * Render requires support for depth 1, 4, 8, 24 and 32 pixmaps
+ */
+
+#define REQUIRED_DEPTHS	(DEPTH_MASK(1) | \
+			 DEPTH_MASK(4) | \
+			 DEPTH_MASK(8) | \
+			 DEPTH_MASK(24) | \
+			 DEPTH_MASK(32))
+    
+typedef struct _DepthCheckRec {
+    struct _DepthCheckRec *next;
+    Display *dpy;
+    CARD32  missing;
+    unsigned long serial;
+} DepthCheckRec, *DepthCheckPtr;
+
+static DepthCheckPtr	depthChecks;
+
+static int
+XRenderDepthCheckErrorHandler (Display *dpy, XErrorEvent *evt)
+{
+    if (evt->request_code == X_CreatePixmap && evt->error_code == BadValue)
+    {
+	DepthCheckPtr	d;
+	_XLockMutex(_Xglobal_lock);
+	for (d = depthChecks; d; d = d->next)
+	    if (d->dpy == dpy)
+	    {
+		if ((long) (evt->serial - d->serial) >= 0)
+		    d->missing |= DEPTH_MASK(evt->resourceid);
+		break;
+	    }
+	_XUnlockMutex (_Xglobal_lock);
+    }
+    return 0;
+}
+
+static Bool
+XRenderHasDepths (Display *dpy)
+{
+    int	s;
+
+    for (s = 0; s < ScreenCount (dpy); s++)
+    {
+	CARD32		    depths = 0;
+	CARD32		    missing;
+	Screen		    *scr = ScreenOfDisplay (dpy, s);
+	int		    d;
+
+	for (d = 0; d < scr->ndepths; d++)
+	    depths |= DEPTH_MASK(scr->depths[d].depth);
+	missing = ~depths & REQUIRED_DEPTHS;
+	if (missing)
+	{
+	    DepthCheckRec   dc, **dp;
+	    XErrorHandler   previousHandler;
+
+	    /*
+	     * Ok, this is ugly.  It should be sufficient at this
+	     * point to just return False, but Xinerama is broken at
+	     * this point and only advertises depths which have an
+	     * associated visual.  Of course, the other depths still
+	     * work, but the only way to find out is to try them.
+	     */
+	    dc.dpy = dpy;
+	    dc.missing = 0;
+	    dc.serial = XNextRequest (dpy);
+	    _XLockMutex(_Xglobal_lock);
+	    dc.next = depthChecks;
+	    depthChecks = &dc;
+	    _XUnlockMutex (_Xglobal_lock);
+	    /*
+	     * I suspect this is not really thread safe, but Xlib doesn't
+	     * provide a lot of options here
+	     */
+	    previousHandler = XSetErrorHandler (XRenderDepthCheckErrorHandler);
+	    /*
+	     * Try each missing depth and see if pixmap creation succeeds
+	     */
+	    for (d = 1; d <= 32; d++)
+		/* don't check depth 1 == Xcursor recurses... */
+		if ((missing & DEPTH_MASK(d)) && d != 1)
+		{
+		    Pixmap  p;
+		    p = XCreatePixmap (dpy, RootWindow (dpy, s), 1, 1, d);
+		    XFreePixmap (dpy, p);
+		}
+	    XSync (dpy, False);
+	    XSetErrorHandler (previousHandler);
+	    /*
+	     * Unhook from the list of depth check records
+	     */
+	    _XLockMutex(_Xglobal_lock);
+	    for (dp = &depthChecks; *dp; dp = &(*dp)->next)
+	    {
+		if (*dp == &dc)
+		{
+		    *dp = dc.next;
+		    break;
+		}
+	    }
+	    _XUnlockMutex (_Xglobal_lock);
+	    if (dc.missing)
+		return False;
+	}
+    }
+    return True;
+}
+
+/*
+ * XRenderExtAddDisplay - add a display to this extension. (Replaces
+ * XextAddDisplay)
+ */
+static XRenderExtDisplayInfo *
+XRenderExtAddDisplay (XRenderExtInfo *extinfo,
+                      Display        *dpy,
+                      char           *ext_name)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    dpyinfo = (XRenderExtDisplayInfo *) Xmalloc (sizeof (XRenderExtDisplayInfo));
+    if (!dpyinfo) return NULL;
+    dpyinfo->display = dpy;
+    dpyinfo->info = NULL;
+
+    if (XRenderHasDepths (dpy))
+	dpyinfo->codes = XInitExtension (dpy, ext_name);
+    else
+	dpyinfo->codes = NULL;
+
+    /*
+     * if the server has the extension, then we can initialize the 
+     * appropriate function vectors
+     */
+    if (dpyinfo->codes) {
+        XESetCloseDisplay (dpy, dpyinfo->codes->extension, 
+                           XRenderCloseDisplay);
+    } else {
+	/* The server doesn't have this extension.
+	 * Use a private Xlib-internal extension to hang the close_display
+	 * hook on so that the "cache" (extinfo->cur) is properly cleaned.
+	 * (XBUG 7955)
+	 */
+	XExtCodes *codes = XAddExtension(dpy);
+	if (!codes) {
+	    XFree(dpyinfo);
+	    return NULL;
+	}
+        XESetCloseDisplay (dpy, codes->extension, XRenderCloseDisplay);
+    }
+
+    /*
+     * now, chain it onto the list
+     */
+    _XLockMutex(_Xglobal_lock);
+    dpyinfo->next = extinfo->head;
+    extinfo->head = dpyinfo;
+    extinfo->cur = dpyinfo;
+    extinfo->ndisplays++;
+    _XUnlockMutex(_Xglobal_lock);
+    return dpyinfo;
+}
+
+
+/*
+ * XRenderExtRemoveDisplay - remove the indicated display from the
+ * extension object. (Replaces XextRemoveDisplay.)
+ */
+static int 
+XRenderExtRemoveDisplay (XRenderExtInfo *extinfo, Display *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo, *prev;
+
+    /*
+     * locate this display and its back link so that it can be removed
+     */
+    _XLockMutex(_Xglobal_lock);
+    prev = NULL;
+    for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) {
+	if (dpyinfo->display == dpy) break;
+	prev = dpyinfo;
+    }
+    if (!dpyinfo) {
+	_XUnlockMutex(_Xglobal_lock);
+	return 0;		/* hmm, actually an error */
+    }
+
+    /*
+     * remove the display from the list; handles going to zero
+     */
+    if (prev)
+	prev->next = dpyinfo->next;
+    else
+	extinfo->head = dpyinfo->next;
+
+    extinfo->ndisplays--;
+    if (dpyinfo == extinfo->cur) extinfo->cur = NULL;  /* flush cache */
+    _XUnlockMutex(_Xglobal_lock);
+
+    Xfree ((char *) dpyinfo);
+    return 1;
+}
+
+
+
+XRenderExtDisplayInfo *
+XRenderFindDisplay (Display *dpy)
+{
+    XRenderExtDisplayInfo *dpyinfo;
+
+    dpyinfo = XRenderExtFindDisplay (&XRenderExtensionInfo, dpy);
+    if (!dpyinfo)
+	dpyinfo = XRenderExtAddDisplay (&XRenderExtensionInfo, dpy, 
+                                        XRenderExtensionName);
+    return dpyinfo;
+}
+
+static int
+XRenderCloseDisplay (Display *dpy, XExtCodes *codes)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    if (info->info) XFree (info->info);
+    
+    return XRenderExtRemoveDisplay (&XRenderExtensionInfo, dpy);
+}
+    
+/****************************************************************************
+ *                                                                          *
+ *			    Render public interfaces                        *
+ *                                                                          *
+ ****************************************************************************/
+
+Bool XRenderQueryExtension (Display *dpy, int *event_basep, int *error_basep)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+
+    if (RenderHasExtension(info)) {
+	*event_basep = info->codes->first_event;
+	*error_basep = info->codes->first_error;
+	return True;
+    } else {
+	return False;
+    }
+}
+
+
+Status XRenderQueryVersion (Display *dpy,
+			    int	    *major_versionp,
+			    int	    *minor_versionp)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return 0;
+
+    if (!XRenderQueryFormats (dpy))
+	return 0;
+    
+    xri = info->info; 
+    *major_versionp = xri->major_version;
+    *minor_versionp = xri->minor_version;
+    return 1;
+}
+
+static XRenderPictFormat *
+_XRenderFindFormat (XRenderInfo *xri, PictFormat format)
+{
+    int	nf;
+    
+    for (nf = 0; nf < xri->nformat; nf++)
+	if (xri->format[nf].id == format)
+	    return &xri->format[nf];
+    return 0;
+}
+
+static Visual *
+_XRenderFindVisual (Display *dpy, VisualID vid)
+{
+    return _XVIDtoVisual (dpy, vid);
+}
+
+typedef struct _renderVersionState {
+    unsigned long   version_seq;
+    Bool	    error;
+    int		    major_version;
+    int		    minor_version;
+    
+} _XrenderVersionState;
+
+static Bool
+_XRenderVersionHandler (Display	    *dpy,
+			xReply	    *rep,
+			char	    *buf,
+			int	    len,
+			XPointer    data)
+{
+    xRenderQueryVersionReply	replbuf;
+    xRenderQueryVersionReply	*repl;
+    _XrenderVersionState	*state = (_XrenderVersionState *) data;
+
+    if (dpy->last_request_read != state->version_seq)
+	return False;
+    if (rep->generic.type == X_Error)
+    {
+	state->error = True;
+	return False;
+    }
+    repl = (xRenderQueryVersionReply *)
+	_XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len,
+		     (SIZEOF(xRenderQueryVersionReply) - SIZEOF(xReply)) >> 2,
+			True);
+    state->major_version = repl->majorVersion;
+    state->minor_version = repl->minorVersion;
+    return True;
+}
+
+Status
+XRenderQueryFormats (Display *dpy)
+{
+    XRenderExtDisplayInfo		*info = XRenderFindDisplay (dpy);
+    _XAsyncHandler		async;
+    _XrenderVersionState	async_state;
+    xRenderQueryVersionReq	*vreq;
+    xRenderQueryPictFormatsReply rep;
+    xRenderQueryPictFormatsReq  *req;
+    XRenderInfo			*xri;
+    XRenderPictFormat		*format;
+    XRenderScreen		*screen;
+    XRenderDepth		*depth;
+    XRenderVisual		*visual;
+    xPictFormInfo		*xFormat;
+    xPictScreen			*xScreen;
+    xPictDepth			*xDepth;
+    xPictVisual			*xVisual;
+    CARD32			*xSubpixel;
+    void			*xData;
+    int				nf, ns, nd, nv;
+    int				rlength;
+    int				nbytes;
+    
+    RenderCheckExtension (dpy, info, 0);
+    LockDisplay (dpy);
+    if (info->info)
+    {
+	UnlockDisplay (dpy);
+	return 1;
+    }
+    GetReq (RenderQueryVersion, vreq);
+    vreq->reqType = info->codes->major_opcode;
+    vreq->renderReqType = X_RenderQueryVersion;
+    vreq->majorVersion = RENDER_MAJOR;
+    vreq->minorVersion = RENDER_MINOR;
+    
+    async_state.version_seq = dpy->request;
+    async_state.error = False;
+    async.next = dpy->async_handlers;
+    async.handler = _XRenderVersionHandler;
+    async.data = (XPointer) &async_state;
+    dpy->async_handlers = &async;
+    
+    GetReq (RenderQueryPictFormats, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderQueryPictFormats;
+    
+    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) 
+    {
+	DeqAsyncHandler (dpy, &async);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+    DeqAsyncHandler (dpy, &async);
+    if (async_state.error)
+    {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return 0;
+    }
+    /*
+     * Check for the lack of sub-pixel data
+     */
+    if (async_state.major_version == 0 && async_state.minor_version < 6)
+	rep.numSubpixel = 0;
+	
+    xri = (XRenderInfo *) Xmalloc (sizeof (XRenderInfo) +
+				   rep.numFormats * sizeof (XRenderPictFormat) +
+				   rep.numScreens * sizeof (XRenderScreen) +
+				   rep.numDepths * sizeof (XRenderDepth) +
+				   rep.numVisuals * sizeof (XRenderVisual));
+    xri->major_version = async_state.major_version;
+    xri->minor_version = async_state.minor_version;
+    xri->format = (XRenderPictFormat *) (xri + 1);
+    xri->nformat = rep.numFormats;
+    xri->screen = (XRenderScreen *) (xri->format + rep.numFormats);
+    xri->nscreen = rep.numScreens;
+    xri->depth = (XRenderDepth *) (xri->screen + rep.numScreens);
+    xri->ndepth = rep.numDepths;
+    xri->visual = (XRenderVisual *) (xri->depth + rep.numDepths);
+    xri->nvisual = rep.numVisuals;
+    rlength = (rep.numFormats * sizeof (xPictFormInfo) +
+	       rep.numScreens * sizeof (xPictScreen) +
+	       rep.numDepths * sizeof (xPictDepth) +
+	       rep.numVisuals * sizeof (xPictVisual) +
+	       rep.numSubpixel * 4);
+    xData = (void *) Xmalloc (rlength);
+    nbytes = (int) rep.length << 2;
+    
+    if (!xri || !xData || nbytes < rlength)
+    {
+	if (xri) Xfree (xri);
+	if (xData) Xfree (xData);
+	_XEatData (dpy, nbytes);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+    _XRead (dpy, (char *) xData, rlength);
+    format = xri->format;
+    xFormat = (xPictFormInfo *) xData;
+    for (nf = 0; nf < rep.numFormats; nf++)
+    {
+	format->id = xFormat->id;
+	format->type = xFormat->type;
+	format->depth = xFormat->depth;
+	format->direct.red = xFormat->direct.red;
+	format->direct.redMask = xFormat->direct.redMask;
+	format->direct.green = xFormat->direct.green;
+	format->direct.greenMask = xFormat->direct.greenMask;
+	format->direct.blue = xFormat->direct.blue;
+	format->direct.blueMask = xFormat->direct.blueMask;
+	format->direct.alpha = xFormat->direct.alpha;
+	format->direct.alphaMask = xFormat->direct.alphaMask;
+	format->colormap = xFormat->colormap;
+	format++;
+	xFormat++;
+    }
+    xScreen = (xPictScreen *) xFormat;
+    screen = xri->screen;
+    depth = xri->depth;
+    visual = xri->visual;
+    for (ns = 0; ns < xri->nscreen; ns++)
+    {
+	screen->depths = depth;
+	screen->ndepths = xScreen->nDepth;
+	screen->fallback = _XRenderFindFormat (xri, xScreen->fallback);
+	screen->subpixel = SubPixelUnknown;
+	xDepth = (xPictDepth *) (xScreen + 1);
+	for (nd = 0; nd < screen->ndepths; nd++)
+	{
+	    depth->depth = xDepth->depth;
+	    depth->nvisuals = xDepth->nPictVisuals;
+	    depth->visuals = visual;
+	    xVisual = (xPictVisual *) (xDepth + 1);
+	    for (nv = 0; nv < depth->nvisuals; nv++)
+	    {
+		visual->visual = _XRenderFindVisual (dpy, xVisual->visual);
+		visual->format = _XRenderFindFormat (xri, xVisual->format);
+		visual++;
+		xVisual++;
+	    }
+	    depth++;
+	    xDepth = (xPictDepth *) xVisual;
+	}
+	screen++;
+	xScreen = (xPictScreen *) xDepth;	    
+    }
+    xSubpixel = (CARD32 *) xScreen;
+    screen = xri->screen;
+    for (ns = 0; ns < rep.numSubpixel; ns++)
+    {
+	screen->subpixel = *xSubpixel;
+	xSubpixel++;
+	screen++;
+    }
+    info->info = xri;
+    /*
+     * Skip any extra data
+     */
+    if (nbytes > rlength)
+	_XEatData (dpy, (unsigned long) (nbytes - rlength));
+    
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    Xfree (xData);
+    return 1;
+}
+
+int
+XRenderQuerySubpixelOrder (Display *dpy, int screen)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return SubPixelUnknown;
+
+    if (!XRenderQueryFormats (dpy))
+	return SubPixelUnknown;
+
+    xri = info->info;
+    return xri->screen[screen].subpixel;
+}
+
+Bool
+XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    XRenderInfo	    *xri;
+
+    if (!RenderHasExtension (info))
+	return False;
+
+    if (!XRenderQueryFormats (dpy))
+	return False;
+
+    xri = info->info;
+    xri->screen[screen].subpixel = subpixel;
+    return True;
+}
+
+XRenderPictFormat *
+XRenderFindVisualFormat (Display *dpy, _Xconst Visual *visual)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    int		    nv;
+    XRenderInfo	    *xri;
+    XRenderVisual   *xrv;
+    
+    RenderCheckExtension (dpy, info, 0);
+    if (!XRenderQueryFormats (dpy))
+        return 0;
+    xri = info->info;
+    for (nv = 0, xrv = xri->visual; nv < xri->nvisual; nv++, xrv++)
+	if (xrv->visual == visual)
+	    return xrv->format;
+    return 0;
+}
+
+XRenderPictFormat *
+XRenderFindFormat (Display		*dpy,
+		   unsigned long	mask,
+		   _Xconst XRenderPictFormat	*template,
+		   int			count)
+{
+    XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy);
+    int		    nf;
+    XRenderInfo     *xri;
+    
+    RenderCheckExtension (dpy, info, 0);
+    if (!XRenderQueryFormats (dpy))
+	return 0;
+    xri = info->info;
+    for (nf = 0; nf < xri->nformat; nf++)
+    {
+	if (mask & PictFormatID)
+	    if (template->id != xri->format[nf].id)
+		continue;
+	if (mask & PictFormatType)
+	if (template->type != xri->format[nf].type)
+		continue;
+	if (mask & PictFormatDepth)
+	    if (template->depth != xri->format[nf].depth)
+		continue;
+	if (mask & PictFormatRed)
+	    if (template->direct.red != xri->format[nf].direct.red)
+		continue;
+	if (mask & PictFormatRedMask)
+	    if (template->direct.redMask != xri->format[nf].direct.redMask)
+		continue;
+	if (mask & PictFormatGreen)
+	    if (template->direct.green != xri->format[nf].direct.green)
+		continue;
+	if (mask & PictFormatGreenMask)
+	    if (template->direct.greenMask != xri->format[nf].direct.greenMask)
+		continue;
+	if (mask & PictFormatBlue)
+	    if (template->direct.blue != xri->format[nf].direct.blue)
+		continue;
+	if (mask & PictFormatBlueMask)
+	    if (template->direct.blueMask != xri->format[nf].direct.blueMask)
+		continue;
+	if (mask & PictFormatAlpha)
+	    if (template->direct.alpha != xri->format[nf].direct.alpha)
+		continue;
+	if (mask & PictFormatAlphaMask)
+	    if (template->direct.alphaMask != xri->format[nf].direct.alphaMask)
+		continue;
+	if (mask & PictFormatColormap)
+	    if (template->colormap != xri->format[nf].colormap)
+		continue;
+	if (count-- == 0)
+	    return &xri->format[nf];
+    }
+    return 0;
+}
+
+XRenderPictFormat *
+XRenderFindStandardFormat (Display  *dpy,
+			   int	    format)
+{
+    static struct {
+	XRenderPictFormat   templ;
+	unsigned long	    mask;
+    } standardFormats[PictStandardNUM] = {
+	/* PictStandardARGB32 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		32,			    /* depth */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.redMask */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blueMask */
+		    24,			    /* direct.alpha */
+		    0xff,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRed |
+	    PictFormatRedMask |
+	    PictFormatGreen |
+	    PictFormatGreenMask |
+	    PictFormatBlue |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardRGB24 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		24,			    /* depth */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.redMask */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x00,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRed |
+	    PictFormatRedMask |
+	    PictFormatGreen |
+	    PictFormatGreenMask |
+	    PictFormatBlue |
+	    PictFormatBlueMask |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA8 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		8,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0xff,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA4 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		4,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x0f,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+	/* PictStandardA1 */
+	{
+	    {
+		0,			    /* id */
+		PictTypeDirect,		    /* type */
+		1,			    /* depth */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.redMask */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.greenMask */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blueMask */
+		    0,			    /* direct.alpha */
+		    0x01,		    /* direct.alphaMask */
+		},
+		0,			    /* colormap */
+	    },
+	    PictFormatType | 
+	    PictFormatDepth |
+	    PictFormatRedMask |
+	    PictFormatGreenMask |
+	    PictFormatBlueMask |
+	    PictFormatAlpha |
+	    PictFormatAlphaMask,
+	},
+    };
+
+    if (0 <= format && format < PictStandardNUM)
+	return XRenderFindFormat (dpy, 
+				  standardFormats[format].mask,
+				  &standardFormats[format].templ,
+				  0);
+    return 0;
+}
+
+XIndexValue *
+XRenderQueryPictIndexValues(Display			*dpy,
+			    _Xconst XRenderPictFormat	*format,
+			    int				*num)
+{
+    XRenderExtDisplayInfo			*info = XRenderFindDisplay (dpy);
+    xRenderQueryPictIndexValuesReq	*req;
+    xRenderQueryPictIndexValuesReply	rep;
+    XIndexValue				*values;
+    int					nbytes, nread, rlength, i;
+
+    RenderCheckExtension (dpy, info, 0);
+
+    LockDisplay (dpy);
+    GetReq (RenderQueryPictIndexValues, req);
+    req->reqType = info->codes->major_opcode;
+    req->renderReqType = X_RenderQueryPictIndexValues;
+    req->format = format->id;
+    if (!_XReply (dpy, (xReply *) &rep, 0, xFalse))
+    {
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+
+    /* request data length */
+    nbytes = (long)rep.length << 2;
+    /* bytes of actual data in the request */
+    nread = rep.numIndexValues * SIZEOF (xIndexValue);
+    /* size of array returned to application */
+    rlength = rep.numIndexValues * sizeof (XIndexValue);
+
+    /* allocate returned data */
+    values = (XIndexValue *)Xmalloc (rlength);
+    if (!values)
+    {
+	_XEatData (dpy, nbytes);
+	UnlockDisplay (dpy);
+	SyncHandle ();
+	return 0;
+    }
+
+    /* read the values one at a time and convert */
+    *num = rep.numIndexValues;
+    for(i = 0; i < rep.numIndexValues; i++)
+    {
+	xIndexValue value;
+	
+	_XRead (dpy, (char *) &value, SIZEOF (xIndexValue));
+	values[i].pixel = value.pixel;
+	values[i].red = value.red;
+	values[i].green = value.green;
+	values[i].blue = value.blue;
+	values[i].alpha = value.alpha;
+    }
+    /* skip any padding */
+    if(nbytes > nread)
+    {
+	_XEatData (dpy, (unsigned long) (nbytes - nread));
+    }
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    return values;
+}