aboutsummaryrefslogtreecommitdiff
path: root/X11/extensions/renderproto.txt
diff options
context:
space:
mode:
Diffstat (limited to 'X11/extensions/renderproto.txt')
-rw-r--r--X11/extensions/renderproto.txt1253
1 files changed, 1253 insertions, 0 deletions
diff --git a/X11/extensions/renderproto.txt b/X11/extensions/renderproto.txt
new file mode 100644
index 000000000..af158b500
--- /dev/null
+++ b/X11/extensions/renderproto.txt
@@ -0,0 +1,1253 @@
+ The X Rendering Extension
+ Version 0.10
+ 2005-07-01
+ Keith Packard
+ keithp@keithp.com
+
+1. Introduction
+
+The X Rendering Extension (Render) introduces digital image composition as
+the foundation of a new rendering model within the X Window System.
+Rendering geometric figures is accomplished by client-side tessellation into
+either triangles or trapezoids. Text is drawn by loading glyphs into the
+server and rendering sets of them.
+
+2. Acknowledgments
+
+This extension was the work of many people, in particular:
+
+ + Thomas Porter and Tom Duff for their formal description
+ of image compositing.
+
+ + Rob Pike and Russ Cox who designed the Plan 9 window system from
+ which the compositing model was lifted.
+
+ + Juliusz Chroboczek and Raph Levien whose proposal for client-side
+ glyph management eliminated font handling from the X server.
+
+ + Jon Leech, Brad Grantham and Allen Akin for patiently explaining
+ how OpenGL works.
+
+ + Carl Worth for providing the sample implementation of
+ trapezoid rendering and showing how broken the spec was
+
+ + Sam Pottle and Jamey Sharp for helping demonstrate the correctness
+ of the trapezoid specification.
+
+ + Owen Taylor for helping specify projective transformations
+
+3. Rendering Model
+
+Render provides a single rendering operation which can be used in a variety of
+ways to generate images:
+
+ dest = (source IN mask) OP dest
+
+Where 'IN' is the Porter/Duff operator of that name and 'OP' is any of the
+list of compositing operators described below, among which can be found all
+of the Porter/Duff binary operators.
+
+To use this operator several additional values are required:
+
+ + The destination rectangle. This is a subset of the destination
+ within which the rendering is performed.
+
+ + The source location. This identifies the coordinate in the
+ source aligned with the upper left corner of the
+ destination rectangle.
+
+ + The mask location. This identifies the coordinate in the
+ mask aligned with the upper left corner of the
+ destination rectangle.
+
+ + A clip list. This limits the rendering to the intersection of the
+ destination rectangle with this clip list.
+
+ + The OP to use
+
+ + Whether the source should be repeated to cover the destination
+ rectangle, extended with a constant pixel value or extended by
+ using the nearest available source pixel.
+
+ + Whether the mask should be repeated to cover the destination
+ rectangle, extended with a constant pixel value or extended by
+ using the nearest available mask pixel.
+
+ + Whether the mask has a single alpha value for all four channels or
+ whether each mask channel should affect the associated source/dest
+ channels.
+
+ + Whether the source should be reshaped with a projective
+ transformation, and if so, what filter to apply while
+ resampling the data.
+
+ + Whether the mask should be reshaped with a projective
+ transformation, and if so, what filter to apply while
+ resampling the data.
+
+These parameters are variously attached to the operands or included in each
+rendering request.
+
+4. Data types
+
+The core protocol rendering system uses a pixel model and applies color only
+in the final generation of the video signal. A compositing model operates
+on colors, not pixel values so a new datatype is needed to interpret data as
+color instead of just bits.
+
+The "PictFormat" object holds information needed to translate pixel values
+into red, green, blue and alpha channels. The server has a list of picture
+formats corresponding to the various visuals on the screen. There are two
+classes of formats, Indexed and Direct. Indexed PictFormats hold a list of
+pixel values and RGBA values while Direct PictFormats hold bit masks for each
+of R, G, B and A.
+
+The "Picture" object contains a Drawable, a PictFormat and some
+rendering state. More than one Picture can refer to the same Drawable.
+
+5. Errors
+
+Errors are sent using core X error reports.
+
+PictFormat
+ A value for a PICTFORMAT argument does not name a defined PICTFORMAT.
+
+Picture
+ A value for a PICTURE argument does not name a defined PICTURE.
+
+PictOp
+ A value for a PICTOP argument does not name a defined PICTOP.
+
+GlyphSet
+ A value for a GLYPHSET argument does not name a defined GLYPHSET.
+
+Glyph
+ A value for a GLYPH argument does not name a defined GLYPH in the
+ glyphset.
+
+6. Protocol Types
+
+PICTURE 32-bit value (top three bits guaranteed to be zero)
+PICTFORMAT 32-bit value (top three bits guaranteed to be zero)
+PICTTYPE { Indexed, Direct }
+PICTOP { Clear, Src, Dst, Over, OverReverse, In, InReverse,
+ Out, OutReverse, Atop, AtopReverse, Xor, Add, Saturate,
+ DisjointClear, DisjointSrc, DisjointDst, DisjointOver,
+ DisjointOverReverse, DisjointIn, DisjointInReverse,
+ DisjointOut, DisjointOutReverse, DisjointAtop,
+ DisjointAtopReverse, DisjointXor,
+ ConjointClear, ConjointSrc, ConjointDst, ConjointOver,
+ ConjointOverReverse, ConjointIn, ConjointInReverse,
+ ConjointOut, ConjointOutReverse, ConjointAtop,
+ ConjointAtopReverse, ConjointXor }
+SUBPIXEL { Unknown, HorizontalRGB, HorizontalBGR,
+ VerticalRGB, VerticalBGR, None
+ }
+COLOR [
+ red, green, blue, alpha: CARD16
+ ]
+CHANNELMASK [
+ shift, mask: CARD16
+ ]
+DIRECTFORMAT [
+ red, green, blue, alpha: CHANNELMASK
+ ]
+INDEXVALUE [
+ pixel: Pixel;
+ red, green, blue, alpha: CARD16
+ ]
+PICTFORMINFO [
+ id: PICTFORMAT
+ type: PICTTYPE
+ depth: CARD8
+ direct: DIRECTFORMAT
+ colormap: COLORMAP or None
+ ]
+
+PICTVISUAL [
+ visual: VISUALID or None
+ format: PICTFORMAT
+ ]
+
+PICTDEPTH [
+ depth: CARD8
+ visuals: LISTofPICTVISUAL
+ ]
+
+PICTSCREEN LISTofPICTDEPTH
+
+FIXED 32-bit value (top 16 are integer portion, bottom 16 are fraction)
+TRANSFORM [
+ p11, p12, p13: FIXED
+ p21, p22, p23: FIXED
+ p31, p32, p33: FIXED
+ ]
+POINTFIX [
+ x, y: FIXED
+ ]
+POLYEDGE { Sharp, Smooth }
+POLYMODE { Precise, Imprecise }
+REPEAT { None, Regular, Pad, Reflect }
+COLORPOINT [
+ point: POINTFIX
+ color: COLOR
+ ]
+SPANFIX [
+ left, right, y: FIXED
+ ]
+COLORSPANFIX [
+ left, right, y: FIXED
+ left_color: COLOR
+ right_color: COLOR
+QUAD [
+ p1, p2, p3, p4: POINTFIX
+ ]
+TRIANGLE [
+ p1, p2, p3: POINTFIX
+ ]
+LINEFIX [
+ p1, p2: POINTFIX
+ ]
+TRAP [
+ top, bottom: SPANFIX
+ ]
+TRAPEZOID [
+ top, bottom: FIXED
+ left, right: LINEFIX
+ ]
+(TRAPEZOID is deprecated)
+COLORTRIANGLE [
+ p1, p2, p3: COLORPOINT
+ ]
+COLORTRAP [
+ top, bottom: COLORSPANFIX
+ ]
+GLYPHSET 32-bit value (top three bits guaranteed to be zero)
+GLYPH 32-bit value
+GLYPHINFO [
+ width, height: CARD16
+ x, y: INT16
+ off-x, off-y: INT16
+ ]
+PICTGLYPH [
+ info: GLYPHINFO
+ x, y: INT16
+ ]
+GLYPHABLE GLYPHSET or FONTABLE
+GLYPHELT8 [
+ dx, dy: INT16
+ glyphs: LISTofCARD8
+ ]
+GLYPHITEM8 GLYPHELT8 or GLYPHABLE
+GLYPHELT16 [
+ dx, dy: INT16
+ glyphs: LISTofCARD16
+ ]
+GLYPHITEM16 GLYPHELT16 or GLYPHABLE
+GLYPHELT32 [
+ dx, dy: INT16
+ glyphs: LISTofCARD32
+ ]
+GLYPHITEM32 GLYPHELT32 or GLYPHABLE
+
+ANIMCURSORELT [
+ cursor: CURSOR
+ delay: CARD32
+ ]
+7. Standard PictFormats
+
+The server must support a Direct PictFormat with 8 bits each of red, green,
+blue and alpha as well as a Direct PictFormat with 8 bits of red, green and
+blue and 0 bits of alpha. The server must also support Direct PictFormats
+with 1, 4 and 8 bits of alpha and 0 bits of r, g and b.
+
+Pixel component values lie in the close range [0,1]. These values are
+encoded in a varying number of bits. Values are encoded in a straight
+forward manner. For a component encoded in m bits, a binary encoding b
+is equal to a component value of b/(2^m-1).
+
+A Direct PictFormat with zero bits of alpha component is declared to have
+alpha == 1 everywhere. A Direct PictFormat with zero bits of red, green and
+blue is declared to have red, green, blue == 0 everywhere. If any of red,
+green or blue components are of zero size, all are of zero size. Direct
+PictFormats never have colormaps and are therefore screen independent.
+
+Indexed PictFormats never have alpha channels and the direct component is all
+zeros. Indexed PictFormats always have a colormap in which the specified
+colors are allocated read-only and are therefore screen dependent. Drawing
+to in Indexed Picture uses only pixel values listed by QueryPictIndexValues.
+Reading from an Indexed Picture uses red, green and blue values from the
+colormap and alpha values from those listed by QueryPictIndexValues. Pixel
+values not present in QueryPictIndexValues are given alpha values of 1.
+
+8. Compositing Operators
+
+For each pixel, the four channels of the image are computed with:
+
+ C = Ca * Fa + Cb * Fb
+
+where C, Ca, Cb are the values of the respective channels and Fa and Fb
+come from the following table:
+
+ PictOp Fa Fb
+ --------------------------------------------------
+ Clear 0 0
+ Src 1 0
+ Dst 0 1
+ Over 1 1-Aa
+ OverReverse 1-Ab 1
+ In Ab 0
+ InReverse 0 Aa
+ Out 1-Ab 0
+ OutReverse 0 1-Aa
+ Atop Ab 1-Aa
+ AtopReverse 1-Ab Aa
+ Xor 1-Ab 1-Aa
+ Add 1 1
+ Saturate min(1,(1-Ab)/Aa) 1
+ DisjointClear 0 0
+ DisjointSrc 1 0
+ DisjointDst 0 1
+ DisjointOver 1 min(1,(1-Aa)/Ab)
+ DisjointOverReverse min(1,(1-Ab)/Aa) 1
+ DisjointIn max(1-(1-Ab)/Aa,0) 0
+ DisjointInReverse 0 max(1-(1-Aa)/Ab,0)
+ DisjointOut min(1,(1-Ab)/Aa) 0
+ DisjointOutReverse 0 min(1,(1-Aa)/Ab)
+ DisjointAtop max(1-(1-Ab)/Aa,0) min(1,(1-Aa)/Ab)
+ DisjointAtopReverse min(1,(1-Ab)/Aa) max(1-(1-Aa)/Ab,0)
+ DisjointXor min(1,(1-Ab)/Aa) min(1,(1-Aa)/Ab)
+ ConjointClear 0 0
+ ConjointSrc 1 0
+ ConjointDst 0 1
+ ConjointOver 1 max(1-Aa/Ab,0)
+ ConjointOverReverse max(1-Ab/Aa,0) 1
+ ConjointIn min(1,Ab/Aa) 0
+ ConjointInReverse 0 min(Aa/Ab,1)
+ ConjointOut max(1-Ab/Aa,0) 0
+ ConjointOutReverse 0 max(1-Aa/Ab,0)
+ ConjointAtop min(1,Ab/Aa) max(1-Aa/Ab,0)
+ ConjointAtopReverse max(1-Ab/Aa,0) min(1,Aa/Ab)
+ ConjointXor max(1-Ab/Aa,0) max(1-Aa/Ab,0)
+
+Saturate and DisjointOverReverse are the same. They match OpenGL
+compositing with FUNC_ADD, SRC_ALPHA_SATURATE, ONE, except that Render uses
+premultiplied alpha while Open GL uses non-premultiplied alpha.
+
+The result of any compositing operator is always limited to the range
+[0,1] for each component. Components whose value would be greater than 1
+are set to 1.
+
+For operations involving division, when the divisor is zero, define the
+quotient to be positive infinity. The result is always well defined
+because the division is surrounded with a max or min operator which will
+give a finite result.
+
+When the mask contains separate alpha values for each channel, the
+alpha value resulting from the combination of that value with the source
+alpha channel is used in the final image composition.
+
+9. Source and Mask Transformations
+
+When fetching pixels from the source or mask pictures, Render provides three
+options for pixel values which fall outside the drawable (this includes
+pixels within a window geometry obscured by other windows).
+
+ + Transparent. Missing values are replaced with transparent.
+
+ + Nearest. Replace missing pixels with the nearest available
+ pixel. Where multiple pixels are equidistant, select
+ those with smallest Y and then smallest X coordinates
+
+ + Tile. Select the pixel which would appear were the
+ drawable tiled to enclose the missing coordinate. If
+ the tiling doesn't cover the coordinate, use the
+ selected Constant or Nearest mode.
+
+When GraphicsExposures are selected in the destination picture, a region
+containing at least the union of all destination pixel values affected by
+data replaced as above is delivered after each compositing operation. If
+the resulting region is empty, a NoExpose event is delivered instead.
+
+To construct the source and mask operands, the computed pixels values are
+transformed through a homogeneous matrix, filtered and then used in the
+fundamental rendering operator described above. Each screen provides a list
+of supported filter names. There are a few required filters, and several
+required filter alias which must map to one of the available filters.
+
+10. Polygon Rasterization
+
+Render provides only two kinds of polygons, trapezoids and triangles. To
+improve efficiency, several different wire encodings exist for each.
+
+All trapezoids must be convex. Rendering of concave trapezoids is unspecified
+except that the result must obey the clipping rules.
+
+Composite
+Polygons are rasterized by implicit generating an alpha mask and using that
+in the general compositing operator along with a supplied source image:
+
+ tmp = Rasterize (polygon)
+ Composite (op, dst, src, tmp)
+
+When rasterized with Sharp edges, the mask is computed with a depth of 1 so
+that all of the mask values are either 0 or 1.
+
+When rasterized with Smooth edges, the mask is generated by creating a square
+around each pixel coordinate and computing the amount of that square covered
+by the polygon. This ignores sampling theory but it provides a precise
+definition which is close to the right answer. This value is truncated to
+the alpha width in the fallback format before application of the compositing
+operator.
+
+Rasterization
+Alpha values are generated by point sampling the coverage of a square
+surrounding the center of each pixel by the polygon.
+
+In Precise poly mode, the sample points are located in a regular grid. When
+alpha depth 'e' is even, the regular grid is 2**(e/2) + 1 samples wide and
+2**(e/2) -1 samples high. For odd alpha depth 'o', the sample grid is 2**o
+- 1 samples wide and 1 sample high. Note that odd alpha depth usually
+occurs only at depth 1, so this misshapen sample grid has no ill effects.
+The sample grid is centered within the pixel and then each sample point is
+rounded down to a point on the sub-pixel coordinate grid.
+
+In Imprecise mode, the location of the sample points is not specified, but
+the implementation must conform to the following constraints:
+
+ + Abutting edges must match precisely. When specifying two polygons
+ abutting along a common edge, if that edge is specified with the
+ same coordinates in each polygon then the sum of alpha values for
+ pixels inside the union of the two polygons must be precisely one.
+
+ + Translationally invariant. The pixelization of the polygon must
+ be the same when either the polygon or the target drawable
+ are translated by any whole number of pixels in any direction.
+
+ + Sharp edges are honored. When the polygon is rasterized with Sharp
+ edges, the implicit alpha mask will contain only 1 or 0 for
+ each pixel.
+
+ + Order independent. Two identical polygons specified with vertices
+ in different orders must generate identical results.
+
+11. Image Filtering
+
+When computing pixels from source and mask images, a filter may be applied
+to the data. This is usually used with a non-identity transformation
+matrix, but filtering may be applied with an identity transformation.
+
+Each filter is given a unique name encoded as an ISO Latin-1 string.
+Filters may be configured with a list of fixed point values; the number of
+parameters and their interpretation is currently left to conventions passed
+outside of the protocol. A set of standard filters are required to be
+provided:
+
+ Filter Name Description
+
+ nearest Nearest neighbor filtering
+ bilinear Linear interpolation in two dimensions
+
+Additional names may be provided for any filter as aliases. A set of
+standard alias names are required to be mapped to a provided filter so that
+applications can use the alias names without checking for availability.
+
+ Alias name Intended interpretation
+
+ fast High performance, quality similar to Nearest
+ good Reasonable performance, quality similar to Bilinear
+ best Highest quality available, performance may not
+ be suitable for interactive use
+
+Aliases must map directly to a non-aliased filter name.
+
+There is also a set of standard filters which are not required but may be
+provided. If they are provided, using the standard name, they must match
+the definition specified here.
+
+ Filter Name Description
+
+ convolution MxN convolution filter. The values specified
+ in SetPictureFilter are M, N and then M * N
+ filter parameters. M and N must be integers
+ represented as fixed point numbers.
+ gaussian Gaussian blur. The value specified is a radius
+ in pixels (which can be fractional). A standard
+ Gaussian 2D convolution filter will be applied.
+ binomial Binomial blur. An approximation of a Gaussian
+ blur using binomial coefficients
+
+12. Glyph Rendering
+
+Glyphs are small alpha masks which can be stored in the X server and
+rendered by referring to them by name. A set of glyphs can be rendered in a
+single request. Glyphs are positioned by subtracting the x, y elements of
+the GLYPHINFO from the requested rendering position. The next glyph
+rendering position is set to the current rendering position plus the off-x
+and off-y elements.
+
+Glyphs are stored in GlyphSets and are named within the GlyphSet with
+client-specified 32-bit numbers.
+
+Glyphs can be stored in any PictFormat supported by the server. All glyphs
+in a GlyphSet are stored in the same format.
+
+13. Extension Initialization
+
+The client must negotiate the version of the extension before executing
+extension requests. Behavior of the server is undefined otherwise.
+
+QueryVersion
+
+ client-major-version: CARD32
+ client-minor-version: CARD32
+
+ ->
+
+ major-version: CARD32
+ minor-version: CARD32
+
+ The client sends the highest supported version to the server and
+ the server sends the highest version it supports, but no higher than
+ the requested version. Major versions changes can introduce
+ incompatibilities in existing functionality, minor version
+ changes introduce only backward compatible changes. It is
+ the clients responsibility to ensure that the server supports
+ a version which is compatible with its expectations.
+
+QueryPictFormats
+
+ ->
+
+ fallback: PICTFORMAT
+ formats: LISTofPICTFORMINFO
+ screens: LISTofPICTSCREEN
+ subpixels: LISTofSUBPIXEL
+
+ Errors:
+ <none>
+
+ The server responds with a list of supported PictFormats and
+ a list of which PictFormat goes with each visual on each screen.
+ Every PictFormat must match a supported depth, but not every
+ PictFormat need have a matching visual.
+
+ The fallback format is used as an intermediate representation
+ in cases where there is no ideal choice.
+
+ The relationship between the red, green and blue elements making
+ up each pixel indexed by screen is returned in subpixels.
+ This list is not present in servers advertising protocol
+ versions earlier than 0.6. This list may be shorter than
+ the number of screens, in which case the remaining screens
+ are given sub pixel order Unknown.
+
+QueryPictIndexValues
+
+ format: PICTFORMAT
+
+ ->
+
+ values: LISTofINDEXVALUE
+
+ Errors:
+ PictFormat, Match
+
+ Returns the mapping from pixel values to RGBA values for the
+ specified Indexed PictFormat. If 'format' does not refer to
+ an Indexed PictFormat a Match error is generated.
+
+QueryFilters
+
+ drawable: DRAWABLE
+
+ ->
+
+ filters: LISTofSTRING8
+ aliases: LISTofCARD16
+
+
+14. Extension Requests
+
+CreatePicture
+
+ pid: PICTURE
+ drawable: DRAWABLE
+ format: PICTFORMAT
+ value-mask: BITMASK
+ value-list: LISTofVALUE
+
+ Errors:
+ Alloc, Drawable, IDChoice, Match, Pixmap, Picture,
+ PictFormat, Value
+
+ This request creates a Picture object associated with the specified
+ drawable and assigns the identifier pid to it. Pixel data in the
+ image are interpreted according to 'format'. It is a Match error
+ to specify a format with a different depth than the drawable. If
+ the drawable is a Window then the Red, Green and Blue masks must
+ match those in the visual for the window else a Match error is
+ generated.
+
+ The value-mask and value-list specify attributes of the picture that
+ are to be explicitly initialized. The possible values are:
+
+ repeat: REPEAT
+ alpha-map: PICTURE or None
+ alpha-x-origin: INT16
+ alpha-y-origin: INT16
+ clip-x-origin: INT16
+ clip-y-origin: INT16
+ clip-mask: PIXMAP or None
+ graphics-exposures: BOOL
+ subwindow-mode: { ClipByChildren, IncludeInferiors }
+ poly-edge: POLYEDGE
+ poly-mode: POLYMODE
+ dither: ATOM or None
+ component-alpha: BOOL
+
+ When used as a source or mask operand, the repeat and fill-constant
+ values control how pixels outside the geometry of the drawable are
+ computed.
+
+ Repeat indicates how the drawable contents should be extented
+ in both directions.
+
+ The alpha channel of alpha-map is used in place of any alpha channel
+ contained within the drawable for all rendering operations. The
+ alpha-mask origin is interpreted relative to the origin of drawable.
+ Rendering is additionally clipped by the geometry of alpha-map.
+ Exposures to the window do not affect the contents of alpha-map.
+ Alpha-map must refer to a picture containing a Pixmap, not a Window
+ (or a Match error results).
+
+ The clip-mask restricts reads and writes to drawable. Only pixels
+ where the clip-mask has bits set to 1 are read or written. Pixels
+ are not accessed outside the area covered by the clip-mask or where
+ the clip-mask has bits set to 0. The clip-mask affects all graphics
+ requests, including sources. The clip-mask origin is interpreted
+ relative to the origin of drawable. If a pixmap is specified as the
+ clip-mask, it must have depth 1 and have the same root as the
+ drawable (or a Match error results). If clip-mask is None, then
+ pixels are always drawn, regardless of the clip origin. The
+ clip-mask can also be set with the SetPictureClipRectangles request.
+
+ For ClipByChildren, both source and destination windows are
+ additionally clipped by all viewable InputOutput children. For
+ IncludeInferiors , neither source nor destination window is clipped
+ by inferiors. This will result in including subwindow contents in
+ the source and drawing through subwindow boundaries of the
+ destination. The use of IncludeInferiors with a source or
+ destination window of one depth with mapped inferiors of differing
+ depth is not illegal, but the semantics are undefined by this
+ extension.
+
+ The graphics-exposures flag controls GraphicsExposure event
+ generation for Composite requests (and any similar requests
+ defined by additional extensions).
+
+ Poly-edge and poly-mode control the rasterization of polygons
+ as described above.
+
+ Dither selects which of the available dither patterns should
+ be used. If dither is None, no dithering will be done.
+
+ Component-alpha indicates whether each image component is
+ intended as a separate alpha value when the picture is used
+ as a mask operand.
+
+ The default component values are
+
+ Component Default
+ -------------------------------
+ repeat False
+ fill-nearest: False
+ clip-x-origin 0
+ clip-y-origin 0
+ clip-mask None
+ graphics-exposures True
+ subwindow-mode ClipByChildren
+ poly-edge Smooth
+ poly-mode Precise
+ dither None
+ component-alpha False
+
+ChangePicture
+
+ pid: PICTURE
+ value-mask: BITMASK
+ value-list: LISTofVALUE
+
+ Errors:
+ Picture, Alloc, Pixmap, PictOp, Value
+
+ The value-mask and value-list specify which attributes are to be
+ changed. The values and restrictions are the same as for
+ CreatePicture.
+
+SetPictureClipRectangles
+
+ picture: PICTURE
+ clip-x-origin: INT16
+ clip-y-origin: INT16
+ rectangles: LISTofRECTANGLE
+
+ Errors:
+ Alloc, Picture
+
+ This request changes clip-mask in picture to the specified list of
+ rectangles and sets the clip origin. Input and output will be
+ clipped to remain contained within the rectangles. The clip origin
+ is interpreted relative to the origin of the drawable associated
+ with picture. The rectangle coordinates are interpreted relative to
+ the clip origin. Note that the list of rectangles can be empty,
+ which effectively disables output. This is the opposite of passing
+ None as the clip-mask in CreatePicture and ChangePicture.
+
+ Note that output is clipped to the union of all of the rectangles
+ and that no particular ordering among the rectangles is required.
+
+SetPictureTransform
+
+ picture: PICTURE
+ transform: TRANSFORM
+
+ Errors:
+ Alloc, Value, Picture
+
+ This request changes the projective transformation used to
+ map coordinates when 'picture' is used as the source or
+ mask in any compositing operation. The transform
+ maps from destination pixel geometry back to the source pixel
+ geometry.
+
+ The matrix must be invertable, else a Value error is generated.
+
+SetPictureFilter
+
+ picture: PICTURE
+ filter: STRING8
+ values: LISTofFIXED
+
+ Errors:
+ Value, Match, Picture
+
+ This request sets the current filter used when picture is a source
+ or mask operand. Filter must be one of the filters supported
+ for the screen associated with picture, else a Match error
+ is generated. If the filter accepts additional parameters,
+ they can be provided in values, incorrect values generate Value
+ errors, too many values generate Match errors. Too few values
+ cause the filter to assume default values for the missing
+ parameters.
+
+ When created, Pictures are set to the Nearest filter.
+
+FreePicture
+
+ pid: PICTURE
+
+ Errors:
+ Picture
+
+ This request deletes the association between the resource ID and the
+ picture. The picture storage will be freed when no other resource
+ references it.
+
+Composite
+
+ op: PICTOP
+ src: PICTURE
+ mask: PICTURE or None
+ dst: PICTURE
+ src-x, src-y: INT16
+ mask-x, mask-y: INT16
+ dst-x, dst-y: INT16
+ width, height: CARD16
+
+ This request combines the specified rectangle of the transformed
+ src and mask operands with the specified rectangle of dst using op
+ as the compositing operator. The coordinates are relative their
+ respective (transformed) drawable's origin. Rendering is clipped
+ to the geometry of the dst drawable and then to the dst clip-list.
+
+ Pixels outside the geometry of src or mask needed for this
+ computation are substituted as described in the Source and Mask
+ Transformations section above.
+
+ If src, mask and dst are not in the same format, and one of their
+ formats can hold all without loss of precision, they are converted
+ to that format. Alternatively, the server will convert each
+ operand to the fallback format.
+
+ If mask is None, it is replaced by a constant alpha value of 1.
+
+ When dst has graphics-exposures true, a region covering all dst
+ pixels affected by substitutions performed on src or mask pixels
+ outside their respective geometries is computed. If that region is
+ empty, a NoExpose event is sent. Otherwise, a sequence of
+ GraphicsExpose events are sent covering that region.
+
+FillRectangles
+
+ op: PICTOP
+ dst: PICTURE
+ color: COLOR
+ rects: LISTofRECTANGLE
+
+ This request combines color with the destination drawable in the
+ area specified by rects. Each rectangle is combined separately;
+ overlapping areas will be rendered multiple times. The effect is
+ equivalent to compositing with a repeating source picture filled with
+ the specified color.
+
+Trapezoids
+
+ op: PICTOP
+ src: PICTURE
+ src-x, src-y: INT16
+ dst: PICTURE
+ mask-format: PICTFORMAT or None
+ traps: LISTofTRAPEZOID
+
+ This request rasterizes the list of trapezoids.
+
+ For each trap, the area between the left and right edges is filled
+ from the top to the bottom. src-x and src-y register the pattern to
+ the floor of the top x and y coordinate of the left edge of the
+ first trapezoid, they are adjusted for subsequent trapezoids so that
+ the pattern remains globally aligned within the destination.
+
+ When mask-format is not None, trapezoids are rendered in the
+ following way with the effective mask computed in mask-format:
+
+ tmp = temporary alpha picture (in mask-format)
+ Combine (Zero, tmp, tmp, None)
+ for each trapezoid
+ Combine (Add, tmp, trapezoid, None)
+ Combine (op, dst, source, tmp)
+
+ When mask-format is None, trapezoids are rendered in the order
+ specified directly to the destination:
+
+ for each trapezoid
+ Combine (op, dst, source, trapezoid)
+
+Triangles
+
+ op: PICTOP
+ src: PICTURE
+ src-x, src-y: INT16
+ dst: PICTURE
+ mask-format: PICTFORMAT or None
+ triangles: LISTofTRIANGLE
+
+ This request rasterizes the list of triangles in the order they
+ occur in the list.
+
+ When mask-format is not None, triangles are rendered in the
+ following way with the effective mask computed in mask-format:
+
+ tmp = temporary alpha picture (in mask-format)
+ Combine (Zero, tmp, tmp, None)
+ for each triangle
+ Combine (Add, tmp, triangle, None)
+ Combine (op, dst, source, tmp)
+
+ When mask-format is None, triangles are rendered in the order
+ specified directly to the destination:
+
+ for each triangle
+ Combine (op, dst, source, triangle)
+
+TriStrip
+
+ op: PICTOP
+ src: PICTURE
+ src-x, src-y: INT16
+ dst: PICTURE
+ mask-format: PICTFORMAT or None
+ points: LISTofPOINTFIX
+
+ Triangles are formed by initially using the first three points and
+ then by eliminating the first point and appending the next point in
+ the list. If fewer than three points are provided, this request does
+ nothing.
+
+ When mask-format is not None, triangles are rendered in the
+ following way with the effective mask computed in mask-format:
+
+ tmp = temporary alpha picture (in mask-format)
+ Combine (Zero, tmp, tmp, None)
+ for each triangle
+ Combine (Add, tmp, triangle, None)
+ Combine (op, dst, source, tmp)
+
+ When mask-format is None, triangles are rendered in the order
+ specified directly to the destination:
+
+ for each triangle
+ Combine (op, dst, source, triangle)
+
+TriFan
+ op: PICTOP
+ src: PICTURE
+ src-x, src-y: INT16
+ dst: PICTURE
+ mask-format: PICTFORMAT or None
+ points: LISTofPOINTFIX
+
+ Triangles are formed by initially using the first three points and
+ then by eliminating the second point and appending the next point
+ int the list. If fewer than three points are provided, this request
+ does nothing.
+
+ When mask-format is not None, triangles are rendered in the
+ following way with the effective mask computed in mask-format:
+
+ tmp = temporary alpha picture (in mask-format)
+ Combine (Zero, tmp, tmp, None)
+ for each triangle
+ Combine (Add, tmp, triangle, None)
+ Combine (op, dst, source, tmp)
+
+ When mask-format is None, triangles are rendered in the order
+ specified directly to the destination:
+
+ for each triangle
+ Combine (op, dst, source, triangle)
+
+ColorTrapezoids
+
+ op: PICTOP
+ dst: PICTURE
+ trapezoids: LISTofCOLORTRAP
+
+ The geometry of the trapezoids must meet the same requirements as
+ for the Trapezoids request. The trapezoids are filled in the order
+ they occur in the list.
+
+ColorTriangles
+
+ op: PICTOP
+ dst: PICTURE
+ triangles: LISTofCOLORTRIANGLE
+
+ The colored triangles are rasterized in the order they occur in the
+ list.
+
+???
+
+Should I included compressed triangle representations here?
+
+???
+
+CreateGlyphSet
+
+ gsid: GLYPHSET
+ format: PICTFORMAT
+
+ Errors:
+ Alloc, IDChoice, PictFormat, Match
+
+ This request creates a container for glyphs. The glyphset and
+ all contained glyphs are destroyed when gsid and any other names
+ for the glyphset are freed. Format must be a Direct format, when
+ it contains RGB values, the glyphs are composited using
+ component-alpha True, otherwise they are composited using
+ component-alpha False.
+
+ReferenceGlyphSet
+
+ gsid: GLYPHSET
+ existing: GLYPHSET
+
+ Errors:
+ Alloc, IDChoice, GlyphSet
+
+ This request creates an additional name for the existing glyphset.
+ The glyphset will not be freed until all references to it are
+ destroyed.
+
+FreeGlyphSet
+
+ glyphset: GLYPHSET
+
+ Errors:
+ GlyphSet
+
+ This request frees the name for the glyphset. When all names have
+ been freed, the glyphset and all contained glyphs are freed.
+
+AddGlyphs
+ glyphset: GLYPHSET
+ glyphids: LISTofCARD32
+ glyphs: LISTofGLYPHINFO
+ data: LISTofBYTE
+
+ Errors:
+ GlyphSet, Alloc
+
+ This request adds glyphs to glyphset. The image for the glyphs
+ are stored with each glyph in a separate Z-format image padded to a
+ 32-bit boundary. Existing glyphs with the same names are replaced.
+
+AddGlyphsFromPicture
+
+ glyphset: GLYPHSET
+ src: PICTURE
+ glyphs: LISTofPICTGLYPH
+
+ Errors:
+ GlyphSet, Alloc
+
+ This request adds glyphs to glyphset by copying them from src from
+ the locations included in glyphs. Existing glyphs with the same
+ names are replaced. Src may be in a different PictFormat than
+ glyphset, in which case the images are converted to the glyphset
+ format.
+
+FreeGlyphs
+
+ glyphset: GLYPHSET
+ glyphs: LISTofGLYPH
+
+ Errors:
+ GlyphSet, Match
+
+ This request removes glyphs from glyphset. Each glyph must exist
+ in glyphset (else a Match error results).
+
+CompositeGlyphs8
+CompositeGlyphs16
+CompositeGlyphs32
+
+ op: PICTOP
+ src: PICTURE
+ dst: PICTURE
+ mask-format: PICTFORMAT or None
+ glyphset: GLYPHABLE
+ src-x, src-y: INT16
+ dst-x, dst-y: INT16
+ glyphcmds: LISTofGLYPHITEM8 CompositeGlyphs8
+ glyphcmds: LISTofGLYPHITEM16 CompositeGlyphs16
+ glyphcmds: LISTofGLYPHITEM32 CompositeGlyphs32
+
+ Errors:
+ Picture, PictOp, PictFormat, GlyphSet, Glyph
+
+ The dst-x and dst-y coordinates are relative to the drawable's
+ origin and specify the baseline starting position (the initial glyph
+ origin). Each glyph item is processed in turn. A glyphset item
+ causes the glyphset to be used for subsequent glyphs. Switching
+ among glyphsets does not affect the next glyph origin. A glyph
+ element delta-x and delta-y specify additional changes in the
+ position along the x and y axes before the string is drawn; the
+ deltas are always added to the glyph origin.
+
+ All contained GLYPHSETs are always transmitted most significant byte
+ first.
+
+ If a GlyphSet error is generated for an item, the previous items may
+ have been drawn.
+
+ When mask-format is not None, glyphs are rendered in the following
+ way with the effective mask computed in mask-format:
+
+ tmp = temporary alpha picture
+ Combine (Zero, tmp, tmp, None)
+ for each glyph
+ Combine (Add, tmp, glyph, None)
+ Combine (op, dst, source, tmp)
+
+ When mask-format is None, glyphs are rendered in the order specified
+ directly to the destination:
+
+ for each glyph
+ Combine (op, dst, source, glyph)
+
+CreateCursor
+
+ cid: CURSOR
+ source: PICTURE
+ x, y: CARD16
+
+ Errors: Alloc, IDChoice, Match, Picture
+
+ This request creates a cursor and associates identifier cid with it.
+ The x and y coordinates define the hotspot relative to the source's
+ origin and must be a point within the source (or a Match error
+ results). The resulting picture will nominally be drawn to the
+ screen with PictOpOver.
+
+ The components of the cursor may be transformed arbitrarily to meet
+ display limitations. In particular, if the display supports only
+ two colors cursors without translucency, the cursor will be
+ transformed so that areas less than .5 alpha will be transparent,
+ else opaque, and areas darker than 50% gray will be black else white.
+
+ The source picture can be freed immediately if no further explicit
+ references to it are to be made.
+
+ Subsequent drawing in the source has an undefined effect on the
+ cursor. The server might or might not make a copy of the picture.
+
+CreateAnimCursor
+ cid: CURSOR
+ cursors: LISTofANIMCURSORELT
+
+ Errors: Alloc, IDChoice, Cursor
+
+ This request creates a cursor and associates identifier cid with it.
+ When active, the cursor image on the screen will cycle through
+ 'cursors', showing each cursor in the element for the number of
+ milliseconds indicated by the 'delay' member of that element.
+
+AddTraps
+ picture: PICTURE
+ off-x, off-y: INT16
+ trapezoids: LISTofTRAP
+
+ Errors: Match
+
+ Each trap is PictOpAdd'ed to 'picture'. 'off-x', 'off-y'
+ are added to each coordinate.
+
+ 'picture' must be an alpha-only picture else a 'Match' error is
+ returned.
+
+CreateSolidFill
+ pid: PICTURE
+ color: COLOR
+
+ Creates a Source picture that represents a solid fill with
+ the specified color.
+
+CreateLinearGradient
+ pid: PICTURE
+ p1, p2: POINTFIX
+ nstops: CARD32
+ stops: LISTofFIXED
+ stop_colors: LISTofCOLOR
+
+ Errors: Alloc, Value
+
+ Creates a source picture representing a linear Gradient. The gradients
+ bounds are defined by the two end points p1 and p2.
+
+ The gradient has nstops stop points between 0 and 1, each
+ having a stop color defined in stop_colors.
+
+ The array of stops has to contain values between 0 and 1 (inclusive) and
+ has to be ordered in increasing size or a Value error is generated. If
+ p1 == p2 a Value error is generated.
+
+ The colors are non premultiplied.
+
+CreateRadialGradient
+ pid: PICTURE
+ inner_center: POINTFIX
+ outer_center: POINTFIX
+ inner_radius: FIXED
+ outer_radius: FIXED
+ nstops: CARD32
+ stops: LISTofFIXED
+ stop_colors: LISTofCOLOR
+
+ Errors: Alloc, Value
+
+ Creates a source picture representing a radial Gradient. The
+ gradients bounds are defined by a center point, a focal point and a
+ radius around the center.
+
+ The gradient has nstops stop points between 0 and 1, each
+ having a stop color defined in stop_colors.
+
+ The array of stops has to contain values between 0 and 1 (inclusive) and
+ has to be ordered in increasing size or a Value error is generated. The inner
+ circle has to be completely contained inside the outer one or a Value error is
+ generated.
+
+ The colors are non premultiplied.
+
+CreateConicalGradient
+ pid: PICTURE
+ center: POINTFIX
+ angle: FIXED
+ nstops: CARD32
+ stops: LISTofFIXED
+ stop_colors: LISTofCOLOR
+
+ Errors: Alloc, Value
+
+ Creates a source picture representing a conical Gradient. The
+ gradient is defined by a center point and an angle (in degrees).
+
+ The gradient has nstops stop points between 0 and 1, each
+ having a stop color defined in stop_colors.
+
+ The array of stops has to contain values between 0 and 1 (inclusive) and
+ has to be ordered in increasing size or a Value error is generated.
+
+ The colors are non premultiplied.
+
+
+15. Extension Versioning
+
+The Render extension was developed in parallel with the implementation to
+ensure the feasibility of various portions of the design. As portions of
+the extension are implemented, the version number of the extension has
+changed to reflect the portions of the standard provided. This document
+describes the intent for version 1.0 of the specification, the partial
+implementations have version numbers less than that. Here's a list of
+what each version before 1.0 implemented:
+
+ 0.0:
+ No disjoint/conjoint operators
+ No component alpha
+ Composite
+ CreateGlyphSet
+ FreeGlyphSet
+ AddGlyphs
+ CompositeGlyphs
+
+ 0.1:
+ Component alpha
+ FillRectangles
+
+ 0.2:
+ Disjoint/Conjoint operators
+
+ 0.3:
+ FreeGlyphs
+
+ 0.4:
+ Trapezoids
+ Triangles
+ TriStrip
+ TriFan
+
+ 0.5:
+ CreateCursor
+
+ 0.6:
+ SetPictureTransform
+ QueryFilters
+ SetPictureFilter
+ subpixels member of QueryPictFormats
+
+ 0.7:
+ QueryPictIndexValues
+ 0.8:
+ CreateAnimCursor
+ 0.9:
+ AddTrapezoids
+
+ 0.10:
+ CreateSolidFill
+ CreateLinearGradient
+ CreateRadialGradient
+ CreateConicalGradient
+
+ The repeat picture attribute now supports Pad and
+ Reflect, older versions only supported None and Normal.