void
XRRConfigureProviderProperty (Display *dpy, RRProvider provider, Atom property,
Bool pending, Bool range, int num_values,
long *values)
{
XExtDisplayInfo *info = XRRFindDisplay(dpy);
xRRConfigureProviderPropertyReq *req;
long len;
RRSimpleCheckExtension (dpy, info);
LockDisplay(dpy);
GetReq (RRConfigureProviderProperty, req);
req->reqType = info->codes->major_opcode;
req->randrReqType = X_RRConfigureProviderProperty;
req->provider = provider;
req->property = property;
req->pending = pending;
req->range = range;
len = num_values;
if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) {
SetReqLen(req, len, len);
len = (long)num_values << 2;
Data32 (dpy, values, len);
} /* else force BadLength */
UnlockDisplay(dpy);
SyncHandle();
}
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();
}
int
XRotateWindowProperties(
register Display *dpy,
Window w,
Atom *properties,
register int nprops,
int npositions)
{
register long nbytes;
register xRotatePropertiesReq *req;
LockDisplay(dpy);
GetReq (RotateProperties, req);
req->window = w;
req->nAtoms = nprops;
req->nPositions = npositions;
req->length += nprops;
nbytes = nprops << 2;
/* XXX Cray needs packing here.... */
Data32 (dpy, (long *) properties, nbytes);
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
/*
* XdbeSwapBuffers -
* This function swaps the front and back buffers for a list of windows.
* The argument num_windows specifies how many windows are to have their
* buffers swapped; it is the number of elements in the swap_info array.
* The argument swap_info specifies the information needed per window
* to do the swap.
*/
Status XdbeSwapBuffers (
Display *dpy,
XdbeSwapInfo *swap_info,
int num_windows)
{
XExtDisplayInfo *info = find_display (dpy);
register xDbeSwapBuffersReq *req;
int i;
DbeCheckExtension (dpy, info, (Status)0 /* failure */);
LockDisplay (dpy);
DbeGetReq (DbeSwapBuffers, req, info);
req->length += 2*num_windows;
req->n = num_windows;
/* We need to handle 64-bit machines, where we can not use PackData32
* directly because info would be lost in translating from 32- to 64-bit.
* Instead we send data via a loop that accounts for the translation.
*/
for (i = 0; i < num_windows; i++)
{
char tmp[4];
Data32 (dpy, (long *)&swap_info[i].swap_window, 4);
tmp[0] = swap_info[i].swap_action;
Data (dpy, (char *)tmp, 4);
}
UnlockDisplay (dpy);
SyncHandle ();
return (Status)1; /* success */
} /* XdbeSwapBuffers() */
int
XFreeColors(
register Display *dpy,
Colormap cmap,
unsigned long *pixels, /* LISTofCARD32 */
int npixels,
unsigned long planes) /* CARD32 */
{
register xFreeColorsReq *req;
register long nbytes;
LockDisplay(dpy);
GetReq(FreeColors, req);
req->cmap = cmap;
req->planeMask = planes;
/* on the VAX, each pixel is a 32-bit (unsigned) integer */
req->length += npixels;
nbytes = npixels << 2; /* watch out for macros... */
Data32 (dpy, (long *) pixels, nbytes);
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
/*
* XmbufChangeBufferAttributes -
* Sets the attributes for the indicated buffer. This is currently
* limited to the event_mask.
*/
void XmbufChangeBufferAttributes (
Display *dpy,
Multibuffer b,
unsigned long valuemask,
XmbufSetBufferAttributes *attr)
{
XExtDisplayInfo *info = find_display (dpy);
register xMbufSetBufferAttributesReq *req;
MbufSimpleCheckExtension (dpy, info);
LockDisplay (dpy);
MbufGetReq (MbufSetBufferAttributes, req, info);
req->buffer = b;
if ((req->valueMask = valuemask)) { /* stolen from lib/X/XWindow.c */
unsigned long values[1]; /* one per element in if stmts below */
unsigned long *v = values;
unsigned int nvalues;
if (valuemask & MultibufferBufferEventMask)
*v++ = attr->event_mask;
req->length += (nvalues = v - values);
nvalues <<= 2; /* watch out for macros... */
Data32 (dpy, (long *) values, (long)nvalues);
}
UnlockDisplay (dpy);
SyncHandle();
}
int
XSelectExtensionEvent(
register Display *dpy,
Window w,
XEventClass *event_list,
int count)
{
register xSelectExtensionEventReq *req;
XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release, info) == -1)
return (NoSuchExtension);
GetReq(SelectExtensionEvent, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SelectExtensionEvent;
req->window = w;
req->count = count;
req->length += count;
/* note: Data is a macro that uses its arguments multiple
* times, so "nvalues" is changed in a separate assignment
* statement */
count <<= 2;
Data32(dpy, (long *)event_list, count);
UnlockDisplay(dpy);
SyncHandle();
return (Success);
}
Status
XSendExtensionEvent(
register Display *dpy,
XDevice *dev,
Window dest,
Bool prop,
int count,
XEventClass *list,
XEvent *event)
{
int num_events;
int ev_size;
xSendExtensionEventReq *req;
xEvent *ev;
ext_event_to_wire *fp;
Status status;
XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_Initial_Release, info) == -1)
return (NoSuchExtension);
/* call through display to find proper conversion routine */
fp = (ext_event_to_wire*)&dpy->wire_vec[event->type & 0177];
if (*fp == NULL)
*fp = _XiEventToWire;
status = (*fp) (dpy, event, &ev, &num_events);
if (status) {
GetReq(SendExtensionEvent, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_SendExtensionEvent;
req->deviceid = dev->device_id;
req->destination = dest;
req->propagate = prop;
req->count = count;
req->num_events = num_events;
ev_size = num_events * sizeof(xEvent);
req->length += (count + (ev_size >> 2));
/* note: Data is a macro that uses its arguments multiple
* times, so "count" is changed in a separate assignment
* statement. Any extra events must be sent before the event
* list, in order to ensure quad alignment. */
Data(dpy, (char *)ev, ev_size);
count <<= 2;
Data32(dpy, (long *)list, count);
XFree((char *)ev);
}
UnlockDisplay(dpy);
SyncHandle();
return (status);
}
int
XISelectEvents(Display* dpy, Window win, XIEventMask* masks, int num_masks)
{
XIEventMask *current;
xXISelectEventsReq *req;
xXIEventMask mask;
int i;
int len = 0;
int r = Success;
XExtDisplayInfo *info = XInput_find_display(dpy);
LockDisplay(dpy);
if (_XiCheckExtInit(dpy, XInput_2_0, info) == -1) {
r = NoSuchExtension;
goto out;
}
GetReq(XISelectEvents, req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_XISelectEvents;
req->win = win;
req->num_masks = num_masks;
/* get the right length */
for (i = 0; i < num_masks; i++)
{
len++;
current = &masks[i];
len += (current->mask_len + 3)/4;
}
SetReqLen(req, len, len);
for (i = 0; i < num_masks; i++)
{
char *buff;
current = &masks[i];
mask.deviceid = current->deviceid;
mask.mask_len = (current->mask_len + 3)/4;
/* masks.mask_len is in bytes, but we need 4-byte units on the wire,
* and they need to be padded with 0 */
buff = calloc(1, mask.mask_len * 4);
memcpy(buff, current->mask, current->mask_len);
Data32(dpy, &mask, sizeof(xXIEventMask));
Data(dpy, buff, mask.mask_len * 4);
free(buff);
}
out:
UnlockDisplay(dpy);
SyncHandle();
return r;
}
int
XMoveResizeWindow(
register Display *dpy,
Window w,
int x,
int y,
unsigned int width,
unsigned int height)
{
register xConfigureWindowReq *req;
LockDisplay(dpy);
GetReqExtra(ConfigureWindow, 16, req);
req->window = w;
req->mask = CWX | CWY | CWWidth | CWHeight;
#ifdef MUSTCOPY
{
long lx = x, ly = y;
unsigned long lwidth = width, lheight = height;
dpy->bufptr -= 16;
Data32 (dpy, (long *) &lx, 4); /* order must match values of */
Data32 (dpy, (long *) &ly, 4); /* CWX, CWY, CWWidth, and CWHeight */
Data32 (dpy, (long *) &lwidth, 4);
Data32 (dpy, (long *) &lheight, 4);
}
#else
{
register CARD32 *valuePtr =
(CARD32 *) NEXTPTR(req,xConfigureWindowReq);
*valuePtr++ = x;
*valuePtr++ = y;
*valuePtr++ = width;
*valuePtr = height;
}
#endif /* MUSTCOPY */
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
int
XQueryColors(
register Display *dpy,
Colormap cmap,
XColor *defs, /* RETURN */
int ncolors)
{
register int i;
xrgb *color;
xQueryColorsReply rep;
long nbytes;
register xQueryColorsReq *req;
LockDisplay(dpy);
GetReq(QueryColors, req);
req->cmap = cmap;
req->length += ncolors; /* each pixel is a CARD32 */
for (i = 0; i < ncolors; i++)
Data32 (dpy, (long *)&defs[i].pixel, 4L);
/* XXX this isn't very efficient */
if (_XReply(dpy, (xReply *) &rep, 0, xFalse) != 0) {
if ((color = (xrgb *)
Xmalloc((unsigned) (nbytes = (long) ncolors * SIZEOF(xrgb))))) {
_XRead(dpy, (char *) color, nbytes);
for (i = 0; i < ncolors; i++) {
register XColor *def = &defs[i];
register xrgb *rgb = &color[i];
def->red = rgb->red;
def->green = rgb->green;
def->blue = rgb->blue;
def->flags = DoRed | DoGreen | DoBlue;
}
Xfree((char *)color);
}
else _XEatData(dpy, (unsigned long) nbytes);
}
UnlockDisplay(dpy);
SyncHandle();
return 1;
}
static void
_XRenderProcessPictureAttributes (Display *dpy,
xRenderChangePictureReq *req,
unsigned long valuemask,
_Xconst XRenderPictureAttributes *attributes)
{
unsigned long values[32];
register unsigned long *value = values;
unsigned int nvalues;
if (valuemask & CPRepeat)
*value++ = attributes->repeat;
if (valuemask & CPAlphaMap)
*value++ = attributes->alpha_map;
if (valuemask & CPAlphaXOrigin)
*value++ = attributes->alpha_x_origin;
if (valuemask & CPAlphaYOrigin)
*value++ = attributes->alpha_y_origin;
if (valuemask & CPClipXOrigin)
*value++ = attributes->clip_x_origin;
if (valuemask & CPClipYOrigin)
*value++ = attributes->clip_y_origin;
if (valuemask & CPClipMask)
*value++ = attributes->clip_mask;
if (valuemask & CPGraphicsExposure)
*value++ = attributes->graphics_exposures;
if (valuemask & CPSubwindowMode)
*value++ = attributes->subwindow_mode;
if (valuemask & CPPolyEdge)
*value++ = attributes->poly_edge;
if (valuemask & CPPolyMode)
*value++ = attributes->poly_mode;
if (valuemask & CPDither)
*value++ = attributes->dither;
if (valuemask & CPComponentAlpha)
*value++ = attributes->component_alpha;
req->length += (nvalues = value - values);
nvalues <<= 2; /* watch out for macros... */
Data32 (dpy, (long *) values, (long)nvalues);
}
static void
_XQueryColors(
register Display *dpy,
Colormap cmap,
XColor *defs, /* RETURN */
int ncolors)
{
register int i;
xQueryColorsReply rep;
register xQueryColorsReq *req;
GetReq(QueryColors, req);
req->cmap = cmap;
SetReqLen(req, ncolors, ncolors); /* each pixel is a CARD32 */
for (i = 0; i < ncolors; i++)
Data32 (dpy, (long *)&defs[i].pixel, 4L);
/* XXX this isn't very efficient */
if (_XReply(dpy, (xReply *) &rep, 0, xFalse) != 0) {
unsigned long nbytes = (long) ncolors * SIZEOF(xrgb);
xrgb *color = Xmalloc(nbytes);
if (color != NULL) {
_XRead(dpy, (char *) color, nbytes);
for (i = 0; i < ncolors; i++) {
register XColor *def = &defs[i];
register xrgb *rgb = &color[i];
def->red = rgb->red;
def->green = rgb->green;
def->blue = rgb->blue;
def->flags = DoRed | DoGreen | DoBlue;
}
Xfree(color);
}
else
_XEatDataWords(dpy, rep.length);
}
}
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();
}
int
XChangeKeyboardMapping (
register Display *dpy,
int first_keycode,
int keysyms_per_keycode,
KeySym *keysyms,
int nkeycodes)
{
register long nbytes;
register xChangeKeyboardMappingReq *req;
LockDisplay(dpy);
GetReq (ChangeKeyboardMapping, req);
req->firstKeyCode = first_keycode;
req->keyCodes = nkeycodes;
req->keySymsPerKeyCode = keysyms_per_keycode;
req->length += nkeycodes * keysyms_per_keycode;
nbytes = keysyms_per_keycode * nkeycodes * 4;
Data32 (dpy, (long *)keysyms, nbytes);
UnlockDisplay(dpy);
SyncHandle();
return 0;
}
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
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
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();
}
Status XReconfigureWMWindow (
register Display *dpy,
Window w,
int screen,
unsigned int mask,
XWindowChanges *changes)
{
XConfigureRequestEvent ev;
Window root = RootWindow (dpy, screen);
_XAsyncHandler async;
_XAsyncErrorState async_state;
/*
* Only need to go through the trouble if we are actually changing the
* stacking mode.
*/
if (!(mask & CWStackMode)) {
XConfigureWindow (dpy, w, mask, changes);
return True;
}
/*
* We need to inline XConfigureWindow and XSync so that everything is done
* while the display is locked.
*/
LockDisplay(dpy);
/*
* XConfigureWindow (dpy, w, mask, changes);
*/
{
unsigned long values[7];
register unsigned long *value = values;
long nvalues;
register xConfigureWindowReq *req;
GetReq(ConfigureWindow, req);
async_state.min_sequence_number = dpy->request;
async_state.max_sequence_number = dpy->request;
async_state.error_code = BadMatch;
async_state.major_opcode = X_ConfigureWindow;
async_state.minor_opcode = 0;
async_state.error_count = 0;
async.next = dpy->async_handlers;
async.handler = _XAsyncErrorHandler;
async.data = (XPointer)&async_state;
dpy->async_handlers = &async;
req->window = w;
mask &= AllMaskBits;
req->mask = mask;
if (mask & CWX) *value++ = changes->x;
if (mask & CWY) *value++ = changes->y;
if (mask & CWWidth) *value++ = changes->width;
if (mask & CWHeight) *value++ = changes->height;
if (mask & CWBorderWidth) *value++ = changes->border_width;
if (mask & CWSibling) *value++ = changes->sibling;
if (mask & CWStackMode) *value++ = changes->stack_mode;
req->length += (nvalues = value - values);
nvalues <<= 2; /* watch out for macros... */
Data32 (dpy, (long *) values, nvalues);
}
/*
* XSync (dpy, 0)
*/
{
xGetInputFocusReply rep;
register xReq *req;
GetEmptyReq(GetInputFocus, req);
(void) _XReply (dpy, (xReply *)&rep, 0, xTrue);
}
DeqAsyncHandler(dpy, &async);
UnlockDisplay(dpy);
SyncHandle();
/*
* If the request succeeded, then everything is okay; otherwise, send event
*/
if (!async_state.error_count) return True;
ev.type = ConfigureRequest;
ev.window = w;
ev.parent = root;
ev.value_mask = (mask & AllMaskBits);
ev.x = changes->x;
ev.y = changes->y;
ev.width = changes->width;
ev.height = changes->height;
ev.border_width = changes->border_width;
ev.above = changes->sibling;
ev.detail = changes->stack_mode;
return (XSendEvent (dpy, root, False,
SubstructureRedirectMask|SubstructureNotifyMask,
(XEvent *)&ev));
}
/*
* XdbeGetVisualInfo -
* This function returns information about which visuals support
* double buffering. The argument num_screens specifies how many
* elements there are in the screen_specifiers list. Each drawable
* in screen_specifiers designates a screen for which the supported
* visuals are being requested. If num_screens is zero, information
* for all screens is requested. In this case, upon return from this
* function, num_screens will be set to the number of screens that were
* found. If an error occurs, this function returns NULL, else it returns
* a pointer to a list of XdbeScreenVisualInfo structures of length
* num_screens. The nth element in the returned list corresponds to the
* nth drawable in the screen_specifiers list, unless num_screens was
* passed in with the value zero, in which case the nth element in the
* returned list corresponds to the nth screen of the server, starting
* with screen zero.
*/
XdbeScreenVisualInfo *XdbeGetVisualInfo (
Display *dpy,
Drawable *screen_specifiers,
int *num_screens) /* SEND and RETURN */
{
XExtDisplayInfo *info = find_display(dpy);
register xDbeGetVisualInfoReq *req;
xDbeGetVisualInfoReply rep;
XdbeScreenVisualInfo *scrVisInfo;
int i;
DbeCheckExtension (dpy, info, (XdbeScreenVisualInfo *)NULL);
LockDisplay (dpy);
DbeGetReq(DbeGetVisualInfo, req, info);
req->length = 2 + *num_screens;
req->n = *num_screens;
Data32 (dpy, screen_specifiers, (*num_screens * sizeof (CARD32)));
if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
UnlockDisplay (dpy);
SyncHandle ();
return NULL;
}
/* return the number of screens actually found if we
* requested information about all screens (*num_screens == 0)
*/
if (*num_screens == 0)
*num_screens = rep.m;
/* allocate list of visual information to be returned */
if (!(scrVisInfo =
(XdbeScreenVisualInfo *)Xmalloc(
(unsigned)(*num_screens * sizeof(XdbeScreenVisualInfo))))) {
UnlockDisplay (dpy);
SyncHandle ();
return NULL;
}
for (i = 0; i < *num_screens; i++)
{
int nbytes;
int j;
long c;
_XRead32 (dpy, &c, sizeof(CARD32));
scrVisInfo[i].count = c;
nbytes = scrVisInfo[i].count * sizeof(XdbeVisualInfo);
/* if we can not allocate the list of visual/depth info
* then free the lists that we already allocate as well
* as the visual info list itself
*/
if (!(scrVisInfo[i].visinfo = (XdbeVisualInfo *)Xmalloc(
(unsigned)nbytes))) {
for (j = 0; j < i; j++) {
Xfree ((char *)scrVisInfo[j].visinfo);
}
Xfree ((char *)scrVisInfo);
UnlockDisplay (dpy);
SyncHandle ();
return NULL;
}
/* Read the visual info item into the wire structure. Then copy each
* element into the library structure. The element sizes and/or
* padding may be different in the two structures.
*/
for (j = 0; j < scrVisInfo[i].count; j++) {
xDbeVisInfo xvi;
_XRead (dpy, (char *)&xvi, sizeof(xDbeVisInfo));
scrVisInfo[i].visinfo[j].visual = xvi.visualID;
scrVisInfo[i].visinfo[j].depth = xvi.depth;
scrVisInfo[i].visinfo[j].perflevel = xvi.perfLevel;
}
}
UnlockDisplay (dpy);
SyncHandle ();
return scrVisInfo;
} /* XdbeGetVisualInfo() */
void
DPSCAPChangeGC(
register Display *agent,
GC gc,
unsigned long valuemask,
XGCValues *values)
{
register xChangeGCReq *req;
unsigned long oldDirty = gc->dirty;
/* ASSERT: called from within LockDisplay section */
/* Always include the clip_mask */
valuemask |= GCClipMask;
/* +++ HACK! Hide the gc->rects flag in arc_mode */
valuemask |= GCArcMode;
valuemask &= (1L << (GCLastBit + 1)) - 1;
/* Stupid macro insists on Display being called 'dpy' */
{
Display *dpy = agent;
Display *xdpy = (Display *)NULL;
NXMacroGetReq(ChangeGC, req);
}
req->gc = XGContextFromGC(gc);
gc->dirty = req->mask = valuemask;
{
/* Derived from MIT XCrGC.c, _XGenerateGCList:
Copyright 1985, 1986, 1987, 1988, 1989 by the
Massachusetts Institute of Technology
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 M.I.T. not be used in advertising or
publicity pertaining to distribution of the software without specific,
written prior permission. M.I.T. makes no representations about the
suitability of this software for any purpose. It is provided "as is"
without express or implied warranty.
*/
/* Warning! This code assumes that "unsigned int" is 32-bits wide */
unsigned int vals[32];
register unsigned int *value = vals;
long nvalues;
register XGCValues *gv = values;
register unsigned long dirty = gc->dirty;
/*
* Note: The order of these tests are critical; the order must be the
* same as the GC mask bits in the word.
*/
if (dirty & GCFunction) *value++ = gv->function;
if (dirty & GCPlaneMask) *value++ = gv->plane_mask;
if (dirty & GCForeground) *value++ = gv->foreground;
if (dirty & GCBackground) *value++ = gv->background;
if (dirty & GCLineWidth) *value++ = gv->line_width;
if (dirty & GCLineStyle) *value++ = gv->line_style;
if (dirty & GCCapStyle) *value++ = gv->cap_style;
if (dirty & GCJoinStyle) *value++ = gv->join_style;
if (dirty & GCFillStyle) *value++ = gv->fill_style;
if (dirty & GCFillRule) *value++ = gv->fill_rule;
if (dirty & GCTile) *value++ = gv->tile;
if (dirty & GCStipple) *value++ = gv->stipple;
if (dirty & GCTileStipXOrigin) *value++ = gv->ts_x_origin;
if (dirty & GCTileStipYOrigin) *value++ = gv->ts_y_origin;
if (dirty & GCFont) *value++ = gv->font;
if (dirty & GCSubwindowMode) *value++ = gv->subwindow_mode;
if (dirty & GCGraphicsExposures) *value++ = gv->graphics_exposures;
if (dirty & GCClipXOrigin) *value++ = gv->clip_x_origin;
if (dirty & GCClipYOrigin) *value++ = gv->clip_y_origin;
if (dirty & GCClipMask) *value++ = gv->clip_mask;
if (dirty & GCDashOffset) *value++ = gv->dash_offset;
if (dirty & GCDashList) *value++ = gv->dashes;
/* +++ HACK! Hide gc->rects flag in GCArcMode */
if (dirty & GCArcMode) *value++ = gc->rects;
req->length += (nvalues = value - vals);
/*
* note: Data is a macro that uses its arguments multiple
* times, so "nvalues" is changed in a separate assignment
* statement
*/
nvalues <<= 2;
Data32 (agent, (long *) vals, nvalues);
}
gc->dirty = oldDirty;
/* ASSERT: SyncHandle called by caller */
}