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();
}
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;
}
/* can only call when display is locked. */
void _XSetClipRectangles (
register Display *dpy,
GC gc,
int clip_x_origin, int clip_y_origin,
XRectangle *rectangles,
int n,
int ordering)
{
register xSetClipRectanglesReq *req;
register long len;
unsigned long dirty;
register _XExtension *ext;
GetReq (SetClipRectangles, req);
req->gc = gc->gid;
req->xOrigin = gc->values.clip_x_origin = clip_x_origin;
req->yOrigin = gc->values.clip_y_origin = clip_y_origin;
req->ordering = ordering;
len = ((long)n) << 1;
SetReqLen(req, len, 1);
len <<= 2;
Data16 (dpy, (short *) rectangles, len);
gc->rects = 1;
dirty = gc->dirty & ~(GCClipMask | GCClipXOrigin | GCClipYOrigin);
gc->dirty = GCClipMask | GCClipXOrigin | GCClipYOrigin;
/* call out to any extensions interested */
for (ext = dpy->ext_procs; ext; ext = ext->next)
if (ext->flush_GC) (*ext->flush_GC)(dpy, gc, &ext->codes);
gc->dirty = dirty;
}
int
XFillArcs(
register Display *dpy,
Drawable d,
GC gc,
XArc *arcs,
int n_arcs)
{
register xPolyFillArcReq *req;
long len;
int n;
LockDisplay(dpy);
FlushGC(dpy, gc);
while (n_arcs) {
GetReq(PolyFillArc, req);
req->drawable = d;
req->gc = gc->gid;
n = n_arcs;
len = ((long)n) * arc_scale;
if (!dpy->bigreq_size && len > (dpy->max_request_size - req->length)) {
n = (dpy->max_request_size - req->length) / arc_scale;
len = ((long)n) * arc_scale;
}
SetReqLen(req, len, len);
len <<= 2; /* watch out for macros... */
Data16 (dpy, (short *) arcs, len);
n_arcs -= n;
arcs += n;
}
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
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;
}
static void
_XRenderSetPictureClipRectangles (Display *dpy,
XRenderExtDisplayInfo *info,
Picture picture,
int xOrigin,
int yOrigin,
_Xconst XRectangle *rects,
int n)
{
xRenderSetPictureClipRectanglesReq *req;
long len;
GetReq (RenderSetPictureClipRectangles, req);
req->reqType = info->codes->major_opcode;
req->renderReqType = X_RenderSetPictureClipRectangles;
req->picture = picture;
req->xOrigin = xOrigin;
req->yOrigin = yOrigin;
len = ((long) n) << 1;
SetReqLen (req, len, 1);
len <<= 2;
Data16 (dpy, (short *) rects, len);
}
int
XDrawArcs(
register Display *dpy,
Drawable d,
GC gc,
XArc *arcs,
int n_arcs)
{
register xPolyArcReq *req;
register long len;
LockDisplay(dpy);
FlushGC(dpy, gc);
GetReq(PolyArc,req);
req->drawable = d;
req->gc = gc->gid;
len = ((long)n_arcs) * arc_scale;
SetReqLen(req, len, 1);
len <<= 2; /* watch out for macros... */
Data16 (dpy, (short *) arcs, len);
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
void
XChangeDeviceProperty(Display* dpy, XDevice* dev,
Atom property, Atom type,
int format, int mode,
_Xconst unsigned char *data, int nelements)
{
xChangeDevicePropertyReq *req;
int len;
XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release, info) == -1)
return;
GetReq(ChangeDeviceProperty, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_ChangeDeviceProperty;
req->deviceid = dev->device_id;
req->property = property;
req->type = type;
req->mode = mode;
if (nelements < 0) {
req->nUnits = 0;
req->format = 0; /* ask for garbage, get garbage */
} else {
req->nUnits = nelements;
req->format = format;
}
switch (req->format) {
case 8:
len = ((long)nelements + 3) >> 2;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
Data (dpy, (_Xconst char *)data, nelements);
} /* else force BadLength */
break;
case 16:
len = ((long)nelements + 1) >> 1;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
len = (long)nelements << 1;
Data16 (dpy, (_Xconst short *) data, len);
} /* else force BadLength */
break;
case 32:
len = nelements;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
len = (long)nelements << 2;
Data32 (dpy, (_Xconst long *) data, len);
} /* else force BadLength */
break;
default:
/* BadValue will be generated */ ;
}
UnlockDisplay(dpy);
SyncHandle();
}
void
XRRChangeProviderProperty (Display *dpy, RRProvider provider,
Atom property, Atom type,
int format, int mode,
_Xconst unsigned char *data, int nelements)
{
XExtDisplayInfo *info = XRRFindDisplay(dpy);
xRRChangeProviderPropertyReq *req;
long len;
RRSimpleCheckExtension (dpy, info);
LockDisplay(dpy);
GetReq (RRChangeProviderProperty, req);
req->reqType = info->codes->major_opcode;
req->randrReqType = X_RRChangeProviderProperty;
req->provider = provider;
req->property = property;
req->type = type;
req->mode = mode;
if (nelements < 0) {
req->nUnits = 0;
req->format = 0; /* ask for garbage, get garbage */
} else {
req->nUnits = nelements;
req->format = format;
}
switch (req->format) {
case 8:
len = ((long)nelements + 3) >> 2;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
Data (dpy, (char *)data, nelements);
} /* else force BadLength */
break;
case 16:
len = ((long)nelements + 1) >> 1;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
len = (long)nelements << 1;
Data16 (dpy, (short *) data, len);
} /* else force BadLength */
break;
case 32:
len = nelements;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
len = (long)nelements << 2;
Data32 (dpy, (long *) data, len);
} /* else force BadLength */
break;
default:
/* BadValue will be generated */ ;
}
UnlockDisplay(dpy);
SyncHandle();
}
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)
{
XExtDisplayInfo *info = XRenderFindDisplay (dpy);
xRenderCompositeGlyphs16Req *req;
long len;
long elen;
xGlyphElt *elt;
int i;
_Xconst unsigned short *chars;
int nchars;
if (!nelt)
return;
RenderSimpleCheckExtension (dpy, info);
LockDisplay(dpy);
GetReq(RenderCompositeGlyphs16, req);
req->reqType = info->codes->major_opcode;
req->renderReqType = X_RenderCompositeGlyphs16;
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;
/*
* xGlyphElt must be aligned on a 32-bit boundary; this is
* easily done by filling no more than 254 glyphs in each
* bucket
*/
elen = SIZEOF(xGlyphElt) * ((nchars + MAX_16-1) / MAX_16) + nchars * 2;
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_16 ? MAX_16 : nchars;
elt->deltax = xDst;
elt->deltay = yDst;
xDst = 0;
yDst = 0;
Data16 (dpy, chars, elt->len * 2);
nchars -= elt->len;
chars += elt->len;
}
}
UnlockDisplay(dpy);
SyncHandle();
}
