Picture XRenderCreateConicalGradient(Display *dpy, const XConicalGradient *gradient, const XFixed *stops, const XRenderColor *colors, int nStops) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); Picture pid; xRenderCreateConicalGradientReq *req; long len; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderCreateConicalGradient, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCreateConicalGradient; req->pid = pid = XAllocID(dpy); req->center.x = gradient->center.x; req->center.y = gradient->center.y; req->angle = gradient->angle; req->nStops = nStops; len = (long) nStops * 3; SetReqLen (req, len, 6); DataInt32(dpy, stops, nStops * 4); Data16(dpy, colors, nStops * 8); UnlockDisplay(dpy); SyncHandle(); return pid; }
void XRenderAddGlyphs (Display *dpy, GlyphSet glyphset, _Xconst Glyph *gids, _Xconst XGlyphInfo *glyphs, int nglyphs, _Xconst char *images, int nbyte_images) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderAddGlyphsReq *req; long len; if (nbyte_images & 3) nbyte_images += 4 - (nbyte_images & 3); RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderAddGlyphs, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderAddGlyphs; req->glyphset = glyphset; req->nglyphs = nglyphs; len = (nglyphs * (SIZEOF (xGlyphInfo) + 4) + nbyte_images) >> 2; SetReqLen(req, len, len); Data32 (dpy, (long *) gids, nglyphs * 4); Data16 (dpy, (short *) glyphs, nglyphs * SIZEOF (xGlyphInfo)); Data (dpy, images, nbyte_images); UnlockDisplay(dpy); SyncHandle(); }
void XRenderSetPictureClipRegion (Display *dpy, Picture picture, Region r) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); int i; XRectangle *xr, *pr; BOX *pb; unsigned long total; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); total = r->numRects * sizeof (XRectangle); if ((xr = (XRectangle *) _XAllocTemp(dpy, total))) { for (pr = xr, pb = r->rects, i = r->numRects; --i >= 0; pr++, pb++) { pr->x = pb->x1; pr->y = pb->y1; pr->width = pb->x2 - pb->x1; pr->height = pb->y2 - pb->y1; } } if (xr || !r->numRects) _XRenderSetPictureClipRectangles (dpy, info, picture, 0, 0, xr, r->numRects); if (xr) _XFreeTemp(dpy, (char *)xr, total); UnlockDisplay(dpy); SyncHandle(); }
void XRenderSetPictureTransform (Display *dpy, Picture picture, XTransform *transform) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderSetPictureTransformReq *req; RenderSimpleCheckExtension (dpy, info); LockDisplay (dpy); GetReq(RenderSetPictureTransform, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderSetPictureTransform; req->picture = picture; req->transform.matrix11 = transform->matrix[0][0]; req->transform.matrix12 = transform->matrix[0][1]; req->transform.matrix13 = transform->matrix[0][2]; req->transform.matrix21 = transform->matrix[1][0]; req->transform.matrix22 = transform->matrix[1][1]; req->transform.matrix23 = transform->matrix[1][2]; req->transform.matrix31 = transform->matrix[2][0]; req->transform.matrix32 = transform->matrix[2][1]; req->transform.matrix33 = transform->matrix[2][2]; UnlockDisplay(dpy); SyncHandle(); }
Picture XRenderCreatePicture (Display *dpy, Drawable drawable, _Xconst XRenderPictFormat *format, unsigned long valuemask, _Xconst XRenderPictureAttributes *attributes) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); Picture pid; xRenderCreatePictureReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderCreatePicture, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCreatePicture; req->pid = pid = XAllocID(dpy); req->drawable = drawable; req->format = format->id; if ((req->mask = valuemask)) _XRenderProcessPictureAttributes (dpy, (xRenderChangePictureReq *) req, valuemask, attributes); UnlockDisplay(dpy); SyncHandle(); return pid; }
static int XRenderCloseDisplay (Display *dpy, XExtCodes *codes) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); if (info->info) XFree (info->info); return XRenderExtRemoveDisplay (&XRenderExtensionInfo, dpy); }
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; } }
void XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderFreeGlyphSetReq *req; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderFreeGlyphSet, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderFreeGlyphSet; req->glyphset = glyphset; UnlockDisplay(dpy); SyncHandle(); }
void XRenderFreePicture (Display *dpy, Picture picture) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderFreePictureReq *req; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderFreePicture, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderFreePicture; req->picture = picture; UnlockDisplay(dpy); SyncHandle(); }
void XRenderSetPictureClipRectangles (Display *dpy, Picture picture, int xOrigin, int yOrigin, _Xconst XRectangle *rects, int n) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); _XRenderSetPictureClipRectangles (dpy, info, picture, xOrigin, yOrigin, rects, n); UnlockDisplay (dpy); SyncHandle (); }
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; }
GlyphSet XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); GlyphSet gsid; xRenderReferenceGlyphSetReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderReferenceGlyphSet, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderReferenceGlyphSet; req->gsid = gsid = XAllocID(dpy); req->existing = existing; UnlockDisplay(dpy); SyncHandle(); return gsid; }
GlyphSet XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); GlyphSet gsid; xRenderCreateGlyphSetReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderCreateGlyphSet, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCreateGlyphSet; req->gsid = gsid = XAllocID(dpy); req->format = format->id; UnlockDisplay(dpy); SyncHandle(); return gsid; }
void XRenderFillRectangles (Display *dpy, int op, Picture dst, _Xconst XRenderColor *color, _Xconst XRectangle *rectangles, int n_rects) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderFillRectanglesReq *req; long len; int n; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); while (n_rects) { GetReq(RenderFillRectangles, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderFillRectangles; req->op = op; req->dst = dst; req->color.red = color->red; req->color.green = color->green; req->color.blue = color->blue; req->color.alpha = color->alpha; n = n_rects; len = ((long)n) << 1; if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) { n = (dpy->max_request_size - req->length) >> 1; len = ((long)n) << 1; } SetReqLen(req, len, len); len <<= 2; /* watch out for macros... */ Data16 (dpy, (short *) rectangles, len); n_rects -= n; rectangles += n; }
void XRenderFreeGlyphs (Display *dpy, GlyphSet glyphset, _Xconst Glyph *gids, int nglyphs) { XExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderFreeGlyphsReq *req; long len; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderFreeGlyphs, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderFreeGlyphs; len = nglyphs; SetReqLen(req, len, len); len <<= 2; Data32 (dpy, (long *) gids, len); UnlockDisplay(dpy); SyncHandle(); }
void XRenderChangePicture (Display *dpy, Picture picture, unsigned long valuemask, _Xconst XRenderPictureAttributes *attributes) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderChangePictureReq *req; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderChangePicture, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderChangePicture; req->picture = picture; req->mask = valuemask; _XRenderProcessPictureAttributes (dpy, req, valuemask, attributes); UnlockDisplay(dpy); SyncHandle(); }
Picture XRenderCreateSolidFill(Display *dpy, const XRenderColor *color) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); Picture pid; xRenderCreateSolidFillReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderCreateSolidFill, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCreateSolidFill; req->pid = pid = XAllocID(dpy); req->color.red = color->red; req->color.green = color->green; req->color.blue = color->blue; req->color.alpha = color->alpha; UnlockDisplay(dpy); SyncHandle(); return pid; }
void XRenderSetPictureFilter (Display *dpy, Picture picture, const char *filter, XFixed *params, int nparams) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderSetPictureFilterReq *req; int nbytes = strlen (filter); RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderSetPictureFilter, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderSetPictureFilter; req->picture = picture; req->nbytes = nbytes; req->length += ((nbytes + 3) >> 2) + nparams; Data (dpy, filter, nbytes); Data (dpy, (_Xconst char *)params, nparams << 2); UnlockDisplay(dpy); SyncHandle(); }
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) { XExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderCompositeGlyphs32Req *req; long len; long elen; xGlyphElt *elt; int i; _Xconst unsigned int *chars; int nchars; if (!nelt) return; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderCompositeGlyphs32, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCompositeGlyphs32; req->op = op; req->src = src; req->dst = dst; req->maskFormat = maskFormat ? maskFormat->id : None; req->glyphset = elts[0].glyphset; req->xSrc = xSrc; req->ySrc = ySrc; /* * Compute the space necessary */ len = 0; for (i = 0; i < nelt; i++) { if (elts[i].glyphset != req->glyphset) len += (SIZEOF (xGlyphElt) + 4) >> 2; nchars = elts[i].nchars; elen = SIZEOF(xGlyphElt) * ((nchars + MAX_32) / MAX_32) + nchars *4; len += (elen + 3) >> 2; } req->length += len; /* * If the entire request does not fit into the remaining space in the * buffer, flush the buffer first. */ if (dpy->bufptr + (len << 2) > dpy->bufmax) _XFlush (dpy); for (i = 0; i < nelt; i++) { /* * Switch glyphsets */ if (elts[i].glyphset != req->glyphset) { BufAlloc (xGlyphElt *, elt, SIZEOF (xGlyphElt)); elt->len = 0xff; elt->deltax = 0; elt->deltay = 0; Data32(dpy, &elts[i].glyphset, 4); } nchars = elts[i].nchars; xDst = elts[i].xOff; yDst = elts[i].yOff; chars = elts[i].chars; while (nchars) { BufAlloc (xGlyphElt *, elt, SIZEOF(xGlyphElt)) elt->len = nchars > MAX_32 ? MAX_32 : nchars; elt->deltax = xDst; elt->deltay = yDst; xDst = 0; yDst = 0; Data32 (dpy, chars, elt->len * 4); nchars -= elt->len; chars += elt->len; } } UnlockDisplay(dpy); SyncHandle(); }
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) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderCompositeGlyphs8Req *req; GlyphSet glyphset; long len; long elen; xGlyphElt *elt; int i; _Xconst char *chars; int nchars; if (!nelt) return; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderCompositeGlyphs8, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCompositeGlyphs8; req->op = op; req->src = src; req->dst = dst; req->maskFormat = maskFormat ? maskFormat->id : None; req->glyphset = elts[0].glyphset; req->xSrc = xSrc; req->ySrc = ySrc; /* * Compute the space necessary */ len = 0; #define MAX_8 252 glyphset = elts[0].glyphset; for (i = 0; i < nelt; i++) { /* * Check for glyphset change */ if (elts[i].glyphset != glyphset) { glyphset = elts[i].glyphset; len += (SIZEOF (xGlyphElt) + 4) >> 2; } nchars = elts[i].nchars; /* * xGlyphElt must be aligned on a 32-bit boundary; this is * easily done by filling no more than 252 glyphs in each * bucket */ elen = SIZEOF(xGlyphElt) * ((nchars + MAX_8-1) / MAX_8) + nchars; len += (elen + 3) >> 2; }
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) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderCompositeGlyphs8Req *req; long len; xGlyphElt *elt; int nbytes; if (!nchar) return; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderCompositeGlyphs32, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCompositeGlyphs32; req->op = op; req->src = src; req->dst = dst; req->maskFormat = maskFormat ? maskFormat->id : None; req->glyphset = glyphset; req->xSrc = xSrc; req->ySrc = ySrc; #define MAX_32 254 len = SIZEOF(xGlyphElt) * ((nchar + MAX_32-1) / MAX_32) + nchar * 4; req->length += (len + 3)>>2; /* convert to number of 32-bit words */ /* * If the entire request does not fit into the remaining space in the * buffer, flush the buffer first. */ if (dpy->bufptr + len > dpy->bufmax) _XFlush (dpy); while(nchar > MAX_32) { nbytes = MAX_32 * 4 + SIZEOF(xGlyphElt); BufAlloc (xGlyphElt *, elt, nbytes); elt->len = MAX_32; elt->deltax = xDst; elt->deltay = yDst; xDst = 0; yDst = 0; memcpy ((char *) (elt + 1), (char *) string, MAX_32 * 4); nchar = nchar - MAX_32; string += MAX_32; } if (nchar) { nbytes = nchar * 4 + SIZEOF(xGlyphElt); BufAlloc (xGlyphElt *, elt, nbytes); elt->len = nchar; elt->deltax = xDst; elt->deltay = yDst; memcpy ((char *) (elt + 1), (char *) string, nchar * 4); } #undef MAX_32 UnlockDisplay(dpy); SyncHandle(); }
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) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); xRenderCompositeGlyphs8Req *req; long len; xGlyphElt *elt; int nbytes; if (!nchar) return; RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RenderCompositeGlyphs8, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCompositeGlyphs8; req->op = op; req->src = src; req->dst = dst; req->maskFormat = maskFormat ? maskFormat->id : None; req->glyphset = glyphset; req->xSrc = xSrc; req->ySrc = ySrc; /* * xGlyphElt must be aligned on a 32-bit boundary; this is * easily done by filling no more than 252 glyphs in each * bucket */ #define MAX_8 252 len = SIZEOF(xGlyphElt) * ((nchar + MAX_8-1) / MAX_8) + nchar; req->length += (len + 3)>>2; /* convert to number of 32-bit words */ /* * If the entire request does not fit into the remaining space in the * buffer, flush the buffer first. */ if (dpy->bufptr + len > dpy->bufmax) _XFlush (dpy); while(nchar > MAX_8) { nbytes = MAX_8 + SIZEOF(xGlyphElt); BufAlloc (xGlyphElt *, elt, nbytes); elt->len = MAX_8; elt->deltax = xDst; elt->deltay = yDst; xDst = 0; yDst = 0; memcpy ((char *) (elt + 1), string, MAX_8); nchar = nchar - MAX_8; string += MAX_8; } if (nchar) { nbytes = (nchar + SIZEOF(xGlyphElt) + 3) & ~3; BufAlloc (xGlyphElt *, elt, nbytes); elt->len = nchar; elt->deltax = xDst; elt->deltay = yDst; memcpy ((char *) (elt + 1), string, nchar); } #undef MAX_8 UnlockDisplay(dpy); SyncHandle(); }
XFilters * XRenderQueryFilters (Display *dpy, Drawable drawable) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); XRenderInfo *xri; xRenderQueryFiltersReq *req; xRenderQueryFiltersReply rep; XFilters *filters; char *name; char len; int i; long nbytes, nbytesAlias, nbytesName; if (!RenderHasExtension (info)) return NULL; if (!XRenderQueryFormats (dpy)) return NULL; xri = info->info; if (xri->minor_version < 6) return NULL; LockDisplay (dpy); GetReq (RenderQueryFilters, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderQueryFilters; req->drawable = drawable; if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay (dpy); SyncHandle (); return NULL; } /* * Compute total number of bytes for filter names */ nbytes = (long)rep.length << 2; nbytesAlias = rep.numAliases * 2; if (rep.numAliases & 1) nbytesAlias += 2; nbytesName = nbytes - nbytesAlias; /* * Allocate one giant block for the whole data structure */ filters = Xmalloc (sizeof (XFilters) + rep.numFilters * sizeof (char *) + rep.numAliases * sizeof (short) + nbytesName); if (!filters) { _XEatData (dpy, (unsigned long) rep.length << 2); UnlockDisplay (dpy); SyncHandle (); return NULL; } /* * Layout: * XFilters * numFilters char * pointers to filter names * numAliases short alias values * nbytesName char strings */ filters->nfilter = rep.numFilters; filters->nalias = rep.numAliases; filters->filter = (char **) (filters + 1); filters->alias = (short *) (filters->filter + rep.numFilters); name = (char *) (filters->alias + rep.numAliases); /* * Read the filter aliases */ _XRead16Pad (dpy, filters->alias, 2 * rep.numAliases); /* * Read the filter names */ for (i = 0; i < rep.numFilters; i++) { int l; _XRead (dpy, &len, 1); l = len & 0xff; filters->filter[i] = name; _XRead (dpy, name, l); name[l] = '\0'; name += l + 1; } i = name - (char *) (filters->alias + rep.numAliases); if (i & 3) _XEatData (dpy, 4 - (i & 3)); UnlockDisplay (dpy); SyncHandle (); return filters; }