EIC code displayed by LXR master/​include/​X11/​extensions/​Xrender.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-30 10:26:34

 /*
  *
  * 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.
  */
 
 /**
  * @file Xrender.h
  * @brief XRender library API.
  */
 
 #ifndef _XRENDER_H_
 #define _XRENDER_H_
 
 #include <X11/Xfuncproto.h>
 #include <X11/Xlib.h>
 #include <X11/Xosdefs.h>
 #include <X11/Xutil.h>
 
 #include <X11/extensions/render.h>
 
 /**
  * @mainpage libXrender API Documentation.
  *
  * Dummy text down here.
  */
 
 /**
  * The direct component of a PictFormat.
  *
  * It contains a binary description of the color format used by the Picture.
  *
  * * A Zero bit alphaMask is declared to have an opaque alpha everywhere.
  * * A Zero bit redMask, greenMask and blueMask is declared to have red, green,
  *   blue == 0 everywhere.
  * * If any of redMask, greenMask or blueMask are zero, all other masks are
  *   zero.
  */
 typedef struct {
     /** Red component binary displacement. */
     short red;
     /** Red component bit mask. */
     short redMask;
     /** Green component binary displacement. */
     short green;
     /** Green component bit mask. */
     short greenMask;
     /** Blue component binary displacement. */
     short blue;
     /** Blue component bit mask. */
     short blueMask;
     /** Alpha component binary displacement. */
     short alpha;
     /** Alpha component bit mask. */
     short alphaMask;
 } XRenderDirectFormat;
 
 /**
  * A Picture pixel format description.
  *
  * It describes the format used by the server to display colors.
  *
  * There are two types:
  * * Direct: Doesn't have a Colormap and the DirectFormat structure describes
  *   the pixel format.
  * * Indexed: Has a Colormap and it's DirectFormat structure is filled with
  *   zeros.
  */
 typedef struct {
     /** XID of this structure server instance. */
     PictFormat id;
     /** Color management type. */
     int type;
     /** Pixel bit depth. */
     int depth;
     /** Color component description. */
     XRenderDirectFormat direct;
     /** XID of the map of indexed colors on the server. */
     Colormap colormap;
 } XRenderPictFormat;
 
 /*< XRenderPictFormat template field masks.
  * @{
  */
 /** Include ID field. @hideinitializer */
 #define PictFormatID (1 << 0)
 /** Include Type field. @hideinitializer */
 #define PictFormatType (1 << 1)
 /** Include Depth field. @hideinitializer */
 #define PictFormatDepth (1 << 2)
 
 /*<--- XRenderPictFormat->direct fields. */
 /** Include Direct->Red field. @hideinitializer */
 #define PictFormatRed (1 << 3)
 /** Include Direct->RedMask field. @hideinitializer */
 #define PictFormatRedMask (1 << 4)
 /** Include Direct->Green field. @hideinitializer */
 #define PictFormatGreen (1 << 5)
 /** Include Direct->GreenMask field. @hideinitializer */
 #define PictFormatGreenMask (1 << 6)
 /** Include Direct->Blue field. @hideinitializer */
 #define PictFormatBlue (1 << 7)
 /** Include Direct->BlueMask field. @hideinitializer */
 #define PictFormatBlueMask (1 << 8)
 /** Include Direct->Alpha field. @hideinitializer */
 #define PictFormatAlpha (1 << 9)
 /** Include Direct->AlphaMask field. @hideinitializer */
 #define PictFormatAlphaMask (1 << 10)
 
 /** Include Colormap field. @hideinitializer */
 #define PictFormatColormap (1 << 11)
 /** @} */
 
 /**
  * Picture rendering attributes.
  */
 typedef struct _XRenderPictureAttributes {
     /** How to repeat the picture. */
     int repeat;
 
     /** A replacement alpha-map. Must be a pixmap-containing Picture. */
     Picture alpha_map;
     /** Horizontal displacement of the replacement alpha-map. */
     int alpha_x_origin;
     /** Vertical displacement of the replacement alpha-map. */
     int alpha_y_origin;
 
     /** Horizontal displacement of the clip mask. */
     int clip_x_origin;
     /** Vertical displacement of the clip mask. */
     int clip_y_origin;
     /** A r/w restriction to the drawable. */
     Pixmap clip_mask;
 
     /** Whether to receive GraphicsExpose events. @note Ignored field. */
     Bool graphics_exposures;
     /** How to clip pixels on subwindow overlap. */
     int subwindow_mode;
     /** Alpha mask generation mode. */
     int poly_edge;
     /** Alpha value rasterization mode. */
     int poly_mode;
     /** Dithering mode. @note Ignored field. */
     Atom dither;
     /** Treat alpha channels independently. */
     Bool component_alpha;
 } XRenderPictureAttributes;
 
 /** An alpha-blended color with premultiplied components.
  *
  *  Values are in the range from 0 to 65535 inclusive, scaled down to the right
  *  hardware values by the server. Colors must be premultiplied by alpha by the
  *  client in all cases but gradient operations.
  */
 typedef struct {
     /** Red color channel. */
     unsigned short red;
     /** Green color channel. */
     unsigned short green;
     /** Blue color channel. */
     unsigned short blue;
     /** Alpha color channel. */
     unsigned short alpha;
 } XRenderColor;
 
 /**
  * Glyph positioning and sizing information.
  *
  * A glyph is positioned by taking the requested position and substracting the
  * center offset.
  */
 typedef struct _XGlyphInfo {
     /** Glyph width. */
     unsigned short width;
     /** Glyph height. */
     unsigned short height;
 
     /** Horizontal Glyph center offset relative to the upper-left corner. */
     short x;
     /** Vertical Glyph center offset relative to the upper-left corner. */
     short y;
 
     /** Horizontal margin to the next Glyph. */
     short xOff;
     /** Vertical margin to the next Glyph. */
     short yOff;
 } XGlyphInfo;
 
 /*< Glyph Elements.
  *  Group of glyphs to be rendered.
  *  While selecting the right element type, you should use as a reference the
  *  largest identifier in Elt->glyphset.
  */
 /** @{ */
 
 /**
  * 8-bit Glyph Element.
  */
 typedef struct _XGlyphElt8 {
     /** Set of available glyphs. */
     GlyphSet glyphset;
 
     /** 8-bit glyph id array. */
     _Xconst char *chars;
     /** Glyph array size. */
     int nchars;
 
     /** Horizontal offset. */
     int xOff;
     /** Vertical offset. */
     int yOff;
 } XGlyphElt8;
 
 /**
  * 16-bit Glyph Element.
  */
 typedef struct _XGlyphElt16 {
     /** Set of available glyphs. */
     GlyphSet glyphset;
 
     /** 16-bit glyph id array. */
     _Xconst unsigned short *chars;
     /** Glyph array size. */
     int nchars;
 
     /** Horizontal offset. */
     int xOff;
     /** Vertical offset. */
     int yOff;
 } XGlyphElt16;
 
 /**
  * 32-bit Glyph Element.
  */
 typedef struct _XGlyphElt32 {
     /** Set of available glyphs. */
     GlyphSet glyphset;
 
     /** 32-bit glyph id array. */
     _Xconst unsigned int *chars;
     /** Glyph array size. */
     int nchars;
 
     /** Horizontal offset. */
     int xOff;
     /** Vertical offset. */
     int yOff;
 } XGlyphElt32;
 /**@} */
 
 /*< Utility number types.
  *
  */
 /**@{ */
 
 /**
  * Floating-point number.
  */
 typedef double XDouble;
 
 /**
  * Fixed-point number.
  */
 typedef int XFixed;
 
 /** Turn XDouble into XFixed. @hideinitializer */
 #define XDoubleToFixed(f) ((XFixed)((f)*65536))
 /** Turn XFixed into XDouble. @hideinitializer */
 #define XFixedToDouble(f) (((XDouble)(f)) / 65536)
 /** @} */
 
 /**
  * Point coordinates stored as floats.
  */
 typedef struct _XPointDouble {
     XDouble x, y;
 } XPointDouble;
 
 /**
  * Point coordinates as integers.
  */
 typedef struct _XPointFixed {
     XFixed x, y;
 } XPointFixed;
 
 /**
  * Line described by two points.
  */
 typedef struct _XLineFixed {
     XPointFixed p1, p2;
 } XLineFixed;
 
 /**
  * Triangle described by it's vertices.
  * @see XTrap
  */
 typedef struct _XTriangle {
     XPointFixed p1, p2, p3;
 } XTriangle;
 
 /**
  * Circle described by it's center point and a radius.
  */
 typedef struct _XCircle {
     XFixed x;
     XFixed y;
     XFixed radius;
 } XCircle;
 
 /** A trapezoid.
  *
  *  @deprecated Use XTrap instead
  *  @see
  *    * XTriangle
  *    * XTrap
  */
 typedef struct _XTrapezoid {
     XFixed top, bottom;
     XLineFixed left, right;
 } XTrapezoid;
 
 /**
  * A transform matrix.
  */
 typedef struct _XTransform {
     XFixed matrix[3][3];
 } XTransform;
 
 /**
  * Group filters and filter aliases.
  */
 typedef struct _XFilters {
     /** Filter names count. */
     int nfilter;
     /** Filter names array. */
     char **filter;
     /** Aliases array count. */
     int nalias;
     /** Array of «Index in .filter of the aliased filter or 0xffff». */
     short *alias;
 } XFilters;
 
 /**
  * The value of an indexed color.
  */
 typedef struct _XIndexValue {
     /** Index ID. */
     unsigned long pixel;
     /** Color components. */
     unsigned short red, green, blue, alpha;
 } XIndexValue;
 
 /**
  * A single cursor frame.
  */
 typedef struct _XAnimCursor {
     /** Existing cursor. */
     Cursor cursor;
     /** Animation delay. */
     unsigned long delay;
 } XAnimCursor;
 
 /**
  * An horizontal line.
  */
 typedef struct _XSpanFix {
     XFixed left, right, y;
 } XSpanFix;
 
 /**
  * A trapezoid defined by two lines.
  * @see XTriangle
  */
 typedef struct _XTrap {
     XSpanFix top, bottom;
 } XTrap;
 
 /**
  * Linear gradient shape.
  */
 typedef struct _XLinearGradient {
     XPointFixed p1;
     XPointFixed p2;
 } XLinearGradient;
 
 /**
  * Radial gradient shape.
  */
 typedef struct _XRadialGradient {
     XCircle inner;
     XCircle outer;
 } XRadialGradient;
 
 /**
  * Conical gradient shape.
  */
 typedef struct _XConicalGradient {
     XPointFixed center;
     XFixed angle; /* in degrees */
 } XConicalGradient;
 
 _XFUNCPROTOBEGIN
 
 /** @defgroup queries Early check queries.
  * @{
  */
 
 /**
  * Ask for the Render extension presence and its base numbers.
  *
  * @param dpy Connection to the X server.
  * @param[out] event_basep first event number for the extension.
  * @param[out] error_basep first error number for the extension.
  * @return True if Render is present.
  */
 Bool XRenderQueryExtension(Display *dpy, int *event_basep, int *error_basep);
 
 /**
  * Ask for the extension version.
  *
  * @param dpy Connection to the X server.
  * @param[out] major_versionp Extension's major version.
  * @param[out] minor_versionp Extension's major version.
  * @return Status «1» on success.
  */
 Status XRenderQueryVersion(Display *dpy, int *major_versionp,
                            int *minor_versionp);
 
 /**
  * Check for and cache compatible picture formats.
  *
  * @param dpy Connection to the X server.
  * @return Status «1» on success.
  */
 Status XRenderQueryFormats(Display *dpy);
 
 /**
  * Ask for the current subpixel order of a screen.
  *
  * @param dpy Connection to the X server.
  * @param[in] screen Target screen number.
  * @return SubPixelUnknown on error, else a subpixel order.
  */
 int XRenderQuerySubpixelOrder(Display *dpy, int screen);
 
 /**
  * Change the subpixel order of a screen.
  *
  * @param dpy Connection to the X server
  * @param[in] screen Target screen number.
  * @param[in] subpixel Requested subpixel order.
  * @return True if the operation was successful.
  */
 Bool XRenderSetSubpixelOrder(Display *dpy, int screen, int subpixel);
 /** @} */
 
 /**
  * Ask for the Picture format for a Visual.
  *
  * @param dpy Connection to the X server.
  * @param[in] visual Reference Visual object.
  * @return The requested Picture format.
  */
 XRenderPictFormat *XRenderFindVisualFormat(Display *dpy,
                                            _Xconst Visual *visual);
 
 /**
  * Ask for matching Picture formats from a template.
  *
  * @param dpy Connection to the X server.
  * @param[in] mask `templ` fields mask to use.
  * @param[in] templ Requested Picture format template.
  * @param[in] count Skip `count` formats.
  * @return NULL if no matching format found, else a Picture format.
  */
 XRenderPictFormat *XRenderFindFormat(Display *dpy, unsigned long mask,
                                      _Xconst XRenderPictFormat *templ,
                                      int count);
 
 /** Standard format specifiers.
  * @{
  */
 /** 8-bit RGB with Alpha. @hideinitializer */
 #define PictStandardARGB32 0
 /** 8-bit RGB. @hideinitializer */
 #define PictStandardRGB24 1
 /** 8-bit Alpha map. @hideinitializer */
 #define PictStandardA8 2
 /** 4-bit Alpha map. @hideinitializer */
 #define PictStandardA4 3
 /** 1-bit Alpha map. @hideinitializer */
 #define PictStandardA1 4
 /** Supported standard formats count. @hideinitializer */
 #define PictStandardNUM 5
 /** @} */
 
 /**
  * Ask for a predefined standard picture format.
  *
  * This is a shorthand to XRenderFindFormat for finding common formats.
  *
  * @param dpy Connection to the X server.
  * @param[in] format Desired format specifier.
  * @return NULL if no matching format found, else a Picture format.
  */
 XRenderPictFormat *XRenderFindStandardFormat(Display *dpy, int format);
 
 /**
  * Ask for the indexed colors of a Picture format.
  *
  * @param dpy Connection to the X server.
  * @param[in] format Queried picture format.
  * @param[out] num Size of the output array.
  * @return An array of XIndexValue.
  */
 XIndexValue *XRenderQueryPictIndexValues(Display *dpy,
                                          _Xconst XRenderPictFormat *format,
                                          int *num);
 
 /**
  * Creates a Picture for a drawable.
  *
  * @param dpy Connection to the X server.
  * @param[in] drawable Target Drawable.
  * @param[in] format Format for the Picture.
  * @param[in] valuemask `attributes` fields mask to use.
  * @param[in] attributes Desired attributes for the Picture.
  * @return A Picture tied to the drawable.
  */
 Picture XRenderCreatePicture(Display *dpy, Drawable drawable,
                              _Xconst XRenderPictFormat *format,
                              unsigned long valuemask,
                              _Xconst XRenderPictureAttributes *attributes);
 
 /**
  * Free allocated structures for a Picture.
  *
  * @warning A freed Picture shouldn't be used again.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture Target Picture.
  */
 void XRenderFreePicture(Display *dpy, Picture picture);
 
 /**
  * Change a Picture's attributes structure.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture Target Picture.
  * @param[in] valuemask `attributes` fields mask to use.
  * @param[in] attributes Desired attributes for the Picture.
  */
 void XRenderChangePicture(Display *dpy, Picture picture,
                           unsigned long valuemask,
                           _Xconst XRenderPictureAttributes *attributes);
 
 /**
  * Change a Picture's clip mask to the specified rectangles.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture Target Picture.
  * @param[in] xOrigin Horizontal mask origin.
  * @param[in] yOrigin Vertical mask origin.
  * @param[in] rects Array of rectangles to clip with.
  * @param[in] n `rects` array size.
  */
 void XRenderSetPictureClipRectangles(Display *dpy, Picture picture, int xOrigin,
                                      int yOrigin, _Xconst XRectangle *rects,
                                      int n);
 
 /**
  * Change a Picture's clip mask to the specified Region.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture Target Picture.
  * @param[in] r Region to clip with.
  */
 void XRenderSetPictureClipRegion(Display *dpy, Picture picture, Region r);
 
 /**
  * Change a Picture's Transform matrix.
  *
  * @param dpy Connection to the X server
  * @param[in] picture Target Picture.
  * @param[in] transform Transform matrix to use.
  */
 void XRenderSetPictureTransform(Display *dpy, Picture picture,
                                 XTransform *transform);
 
 /**
  * Combines two Pictures with the specified compositing operation.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] mask Composition mask.
  * @param[in] dst Picture to combine into.
  * @param[in] src_x Horizontal `src` origin offset.
  * @param[in] src_y Vertical `src` origin offset
  * @param[in] mask_x Horizontal `mask` origin offset.
  * @param[in] mask_y Vertical `mask` origin offset.
  * @param[in] dst_x Horizontal `dst` origin offset.
  * @param[in] dst_y Vertical `dst` origin offset.
  * @param[in] width Maximum composition width.
  * @param[in] height Maximum composition height.
  */
 void XRenderComposite(Display *dpy, int op, Picture src, Picture mask,
                       Picture dst, int src_x, int src_y, int mask_x, int mask_y,
                       int dst_x, int dst_y, unsigned int width,
                       unsigned int height);
 
 /**
  * Create a Glyph Set.
  *
  * @param dpy Connection to the X server.
  * @param[in] format Desired format for the Glyphs Picture.
  * @return A GlyphSet.
  */
 GlyphSet XRenderCreateGlyphSet(Display *dpy, _Xconst XRenderPictFormat *format);
 
 /**
  * Generate a new reference for an existing Glyph Set.
  *
  * @param dpy Connection to the X server.
  * @param[in] existing Target Glyph Set.
  * @return A GlyphSet identical to `existing`.
  */
 GlyphSet XRenderReferenceGlyphSet(Display *dpy, GlyphSet existing);
 
 /**
  * Free allocated structures for a GlyphSet.
  *
  * If there's more references to the underlying GlyphSet structures, this will
  * remove only the specified GlyphSet reference.
  *
  * @warning A freed GlyphSet shouldn't be used again.
  *
  * @param dpy Connection to the X server.
  * @param[in] glyphset Target GlyphSet.
  */
 void XRenderFreeGlyphSet(Display *dpy, GlyphSet glyphset);
 
 /**
  * Add new Glyphs to a GlyphSet.
  *
  * @param dpy Connection to the X server.
  * @param[in] glyphset Glyph storage destination.
  * @param[in] gids Array of ids for the new Glyphs.
  * @param[in] glyphs Array of new Glyphs info.
  * @param[in] nglyphs Number of Glyphs to add.
  * @param[in] images Byte array containing the Glyphs graphics.
  * @param[in] nbyte_images Size of the `images` byte array.
  */
 void XRenderAddGlyphs(Display *dpy, GlyphSet glyphset, _Xconst Glyph *gids,
                       _Xconst XGlyphInfo *glyphs, int nglyphs,
                       _Xconst char *images, int nbyte_images);
 
 /**
  * Free allocated Glyphs.
  *
  * @param dpy Connection to the X server.
  * @param[in] glyphset GlyphSet storing the Glyphs.
  * @param[in] gids Identifier array of the Glyphs to dellocate.
  * @param[in] nglyphs Glyph count.
  */
 void XRenderFreeGlyphs(Display *dpy, GlyphSet glyphset, _Xconst Glyph *gids,
                        int nglyphs);
 
 /**
  * Draw a 8-bit character string into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] glyphset Glyph Source.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] string String to clip to.
  * @param[in] nchar String length.
  */
 void XRenderCompositeString8(Display *dpy, int op, Picture src, Picture dst,
                              _Xconst XRenderPictFormat *maskFormat,
                              GlyphSet glyphset, int xSrc, int ySrc, int xDst,
                              int yDst, _Xconst char *string, int nchar);
 
 /**
  * Draw a 16-bit character string into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] glyphset Glyph Source.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] string String to clip to.
  * @param[in] nchar String length.
  */
 void XRenderCompositeString16(Display *dpy, int op, Picture src, Picture dst,
                               _Xconst XRenderPictFormat *maskFormat,
                               GlyphSet glyphset, int xSrc, int ySrc, int xDst,
                               int yDst, _Xconst unsigned short *string,
                               int nchar);
 
 /**
  * Draw a 32-bit character string into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] glyphset Glyph Source.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] string String to clip to.
  * @param[in] nchar String length.
  */
 void XRenderCompositeString32(Display *dpy, int op, Picture src, Picture dst,
                               _Xconst XRenderPictFormat *maskFormat,
                               GlyphSet glyphset, int xSrc, int ySrc, int xDst,
                               int yDst, _Xconst unsigned int *string,
                               int nchar);
 
 /**
  * Draw several 8-bit Glyph Elements into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] elts Glyph Elements array to clip with.
  * @param[in] nelt Glyph Elements array size.
  */
 void XRenderCompositeText8(Display *dpy, int op, Picture src, Picture dst,
                            _Xconst XRenderPictFormat *maskFormat, int xSrc,
                            int ySrc, int xDst, int yDst,
                            _Xconst XGlyphElt8 *elts, int nelt);
 
 /**
  * Draw several 16-bit Glyph Elements into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] elts Glyph Elements array to clip with.
  * @param[in] nelt Glyph Elements array size.
  */
 void XRenderCompositeText16(Display *dpy, int op, Picture src, Picture dst,
                             _Xconst XRenderPictFormat *maskFormat, int xSrc,
                             int ySrc, int xDst, int yDst,
                             _Xconst XGlyphElt16 *elts, int nelt);
 
 /**
  * Draw several 32-bit Glyph Elements into a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] elts Glyph Elements to clip with.
  * @param[in] nelt Glyph Elements array size.
  */
 void XRenderCompositeText32(Display *dpy, int op, Picture src, Picture dst,
                             _Xconst XRenderPictFormat *maskFormat, int xSrc,
                             int ySrc, int xDst, int yDst,
                             _Xconst XGlyphElt32 *elts, int nelt);
 
 /**
  * Fill a Rectangle with the given color.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] dst Picture to draw into.
  * @param[in] color Color to fill with.
  * @param[in] x Horizontal offset.
  * @param[in] y Vertical offset.
  * @param[in] width Rectangle width.
  * @param[in] height Rectangle height.
  */
 void XRenderFillRectangle(Display *dpy, int op, Picture dst,
                           _Xconst XRenderColor *color, int x, int y,
                           unsigned int width, unsigned int height);
 
 /**
  * Fill a bunch of Rectangle with the given color.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] dst Picture to draw into.
  * @param[in] color Color to fill with.
  * @param[in] rectangles Array of Rectangles to fill.
  * @param[in] n_rects `rectangles` array size.
  */
 void XRenderFillRectangles(Display *dpy, int op, Picture dst,
                            _Xconst XRenderColor *color,
                            _Xconst XRectangle *rectangles, int n_rects);
 
 /**
  * Combine two Pictures using a bunch of Trapezoids as the mask.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] traps Array of Trapezoids to clip with.
  * @param[in] ntrap `traps` Array size.
  */
 void XRenderCompositeTrapezoids(Display *dpy, int op, Picture src, Picture dst,
                                 _Xconst XRenderPictFormat *maskFormat, int xSrc,
                                 int ySrc, _Xconst XTrapezoid *traps, int ntrap);
 
 /**
  * Combine two Pictures using a bunch of Triangles as the mask.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] triangles Array of Triangles to clip with.
  * @param[in] ntriangle `triangles` array size.
  */
 void XRenderCompositeTriangles(Display *dpy, int op, Picture src, Picture dst,
                                _Xconst XRenderPictFormat *maskFormat, int xSrc,
                                int ySrc, _Xconst XTriangle *triangles,
                                int ntriangle);
 
 /**
  * Combine two Pictures using a Triangle Strip as the mask.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] points Array of Points to create Triangles with.
  * @param[in] npoint `points` array size.
  */
 void XRenderCompositeTriStrip(Display *dpy, int op, Picture src, Picture dst,
                               _Xconst XRenderPictFormat *maskFormat, int xSrc,
                               int ySrc, _Xconst XPointFixed *points,
                               int npoint);
 
 /**
  * Combine two Pictures using a Triangle Fan as the mask.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] points Array of Points to create Triangles with.
  * @param[in] npoint `points` array size.
  */
 void XRenderCompositeTriFan(Display *dpy, int op, Picture src, Picture dst,
                             _Xconst XRenderPictFormat *maskFormat, int xSrc,
                             int ySrc, _Xconst XPointFixed *points, int npoint);
 
 /**
  * Combine two Pictures using a Polygon as the mask.
  *
  * @param dpy Connection to the X server.
  * @param[in] op Compositing operation to perform.
  * @param[in] src Picture to combine with.
  * @param[in] dst Picture to combine into.
  * @param[in] maskFormat Picture format of the generated Picture mask.
  * @param[in] xSrc Horizontal `src` origin offset.
  * @param[in] ySrc Vertical `src` origin offset.
  * @param[in] xDst Horizontal `dst` origin offset.
  * @param[in] yDst Vertical `dst` origin offset.
  * @param[in] fpoints Array of DoublePoints to create a Polygon with.
  * @param[in] npoints `points` array size.
  * @param winding Unused.
  */
 void XRenderCompositeDoublePoly(Display *dpy, int op, Picture src, Picture dst,
                                 _Xconst XRenderPictFormat *maskFormat, int xSrc,
                                 int ySrc, int xDst, int yDst,
                                 _Xconst XPointDouble *fpoints, int npoints,
                                 int winding);
 
 /**
  * Parse a color string.
  *
  * @param dpy Connection to the X server.
  * @param[in] spec Null-terminated string.
  * @param[out] def Parsing result.
  * @return Status «1» on success.
  */
 Status XRenderParseColor(Display *dpy, char *spec, XRenderColor *def);
 
 /**
  * Creates a cursor looking like a Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] source Picture defining the cursor look.
  * @param[in] x Horizontal offset.
  * @param[in] y Vertical offset.
  * @return A Cursor.
  */
 Cursor XRenderCreateCursor(Display *dpy, Picture source, unsigned int x,
                            unsigned int y);
 
 /**
  * Ask for Filters applicable to some Drawable.
  *
  * @param dpy Connection to the X server.
  * @param[in] drawable Target Drawable.
  * @return Available Filters and Aliases.
  */
 XFilters *XRenderQueryFilters(Display *dpy, Drawable drawable);
 
 /**
  * Set the current filter of a Picture.
  *
  * @note On Picture creation, the «Nearest» filter is set by default.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture Target.
  * @param[in] filter Filter name.
  * @param[in] params Filter parameters array.
  * @param[in] nparams `params` array size.
  */
 void XRenderSetPictureFilter(Display *dpy, Picture picture, const char *filter,
                              XFixed *params, int nparams);
 
 /**
  * Create an animated Cursor from the given Cursor frames.
  *
  * @param dpy Connection to the X server.
  * @param[in] ncursor Cursor frames count.
  * @param[in] cursors Cursor frames array.
  * @return An animated Cursor.
  */
 Cursor XRenderCreateAnimCursor(Display *dpy, int ncursor, XAnimCursor *cursors);
 
 /**
  * Add the given Trapezoids to a single-channel Picture.
  *
  * @param dpy Connection to the X server.
  * @param[in] picture An alpha-only Picture.
  * @param[in] xOff Horizontal offset.
  * @param[in] yOff Vertical offset.
  * @param[in] traps Array of trapezoids.
  * @param[in] ntrap `traps` array size.
  */
 void XRenderAddTraps(Display *dpy, Picture picture, int xOff, int yOff,
                      _Xconst XTrap *traps, int ntrap);
 
 /**
  * Create a Picture filled with a single Color.
  *
  * @param dpy Connection to the X server.
  * @param[in] color Desired filling.
  * @return A single Color Picture.
  */
 Picture XRenderCreateSolidFill(Display *dpy, const XRenderColor *color);
 
 /**
  * Create a Picture filled with a Linear Gradient.
  *
  * @param dpy Connection to the X server.
  * @param[in] gradient Gradient geometry.
  * @param[in] stops Stop sections.
  * @param[in] colors Stop colors.
  * @param[in] nstops Stops count.
  * @return A Picture filled with a Linear Gradient.
  */
 Picture XRenderCreateLinearGradient(Display *dpy,
                                     const XLinearGradient *gradient,
                                     const XFixed *stops,
                                     const XRenderColor *colors, int nstops);
 
 /**
  * Create a Picture filled with a Radial Gradient.
  *
  * @param dpy Connection to the X server.
  * @param[in] gradient Gradient geometry.
  * @param[in] stops Stop sections.
  * @param[in] colors Stop colors.
  * @param[in] nstops Stops count.
  * @return A Picture filled with a Radial Gradient.
  */
 Picture XRenderCreateRadialGradient(Display *dpy,
                                     const XRadialGradient *gradient,
                                     const XFixed *stops,
                                     const XRenderColor *colors, int nstops);
 
 /**
  * Create a Picture filled with a Conical Gradient.
  *
  * @param dpy Connection to the X server.
  * @param[in] gradient Gradient geometry.
  * @param[in] stops Stop sections.
  * @param[in] colors Stop colors.
  * @param[in] nstops Stops count.
  * @return A Picture filled with a Conical Gradient.
  */
 Picture XRenderCreateConicalGradient(Display *dpy,
                                      const XConicalGradient *gradient,
                                      const XFixed *stops,
                                      const XRenderColor *colors, int nstops);
 
 _XFUNCPROTOEND
 
 #endif /* _XRENDER_H_ */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team