/**
* Flush the drawing command transport buffer.
*
* \param ctx Context whose transport buffer is to be flushed.
* \param pc Pointer to first unused buffer location.
*
* \todo
* Modify this function to use \c ctx->pc instead of the explicit
* \c pc parameter.
*/
_X_HIDDEN GLubyte *
__glXFlushRenderBuffer(struct glx_context * ctx, GLubyte * pc)
{
Display *const dpy = ctx->currentDpy;
#ifdef USE_XCB
xcb_connection_t *c = XGetXCBConnection(dpy);
#else
xGLXRenderReq *req;
#endif /* USE_XCB */
const GLint size = pc - ctx->buf;
if ((dpy != NULL) && (size > 0)) {
#ifdef USE_XCB
xcb_glx_render(c, ctx->currentContextTag, size,
(const uint8_t *) ctx->buf);
#else
/* Send the entire buffer as an X request */
LockDisplay(dpy);
GetReq(GLXRender, req);
req->reqType = ctx->majorOpcode;
req->glxCode = X_GLXRender;
req->contextTag = ctx->currentContextTag;
req->length += (size + 3) >> 2;
_XSend(dpy, (char *) ctx->buf, size);
UnlockDisplay(dpy);
SyncHandle();
#endif
}
int
__glXVForwardSingleReq(__GLXclientState * cl, GLbyte * pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
xGLXVendorPrivateReq *be_req;
__GLXcontext *glxc;
int from_screen = 0;
int to_screen = 0;
int buf_size;
int s;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
/*
* just forward the request to back-end server(s)
*/
for (s = from_screen; s <= to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl, s);
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
if (buf_size > 0)
_XSend(dpy, (const char *) pc, buf_size);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
XExtensionVersion *
_XiGetExtensionVersion (
register Display *dpy,
_Xconst char *name)
{
xGetExtensionVersionReq *req;
xGetExtensionVersionReply rep;
XExtensionVersion *ext;
XExtDisplayInfo *info = XInput_find_display (dpy);
if (_XiCheckExtInit(dpy, Dont_Check) == -1)
return ((XExtensionVersion *) NoSuchExtension);
GetReq(GetExtensionVersion,req);
req->reqType = info->codes->major_opcode;
req->ReqType = X_GetExtensionVersion;
req->nbytes = name ? strlen(name) : 0;
req->length += (unsigned)(req->nbytes+3)>>2;
_XSend(dpy, name, (long)req->nbytes);
if (! _XReply (dpy, (xReply *) &rep, 0, xTrue))
{
return (XExtensionVersion *) NULL;
}
ext = (XExtensionVersion *) Xmalloc (sizeof (XExtensionVersion));
if (ext)
{
ext->present = rep.present;
if (ext->present)
{
ext->major_version = rep.major_version;
ext->minor_version = rep.minor_version;
}
}
return (ext);
}
int
__glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
{
ClientPtr client = cl->client;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
xGLXVendorPrivateReq *be_req;
xGLXVendorPrivReply reply;
xGLXVendorPrivReply be_reply;
__GLXcontext *glxc;
int buf_size;
char *be_buf = NULL;
int be_buf_size = 0;
int from_screen = 0;
int to_screen = 0;
int s;
DMXScreenInfo *dmxScreen;
Display *dpy;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
/*
* send the request to the first back-end server(s)
*/
for (s = to_screen; s >= from_screen; s--) {
dmxScreen = &dmxScreens[s];
dpy = GetBackEndDisplay(cl, s);
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
if (buf_size > 0)
_XSend(dpy, (const char *) pc, buf_size);
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) &be_reply, 0, False);
if (s == from_screen) {
/* Save data from last reply to send on to client */
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = malloc(be_buf_size);
if (be_buf) {
_XRead(dpy, be_buf, be_buf_size);
}
else {
/* Throw data on the floor */
_XEatDataWords(dpy, be_reply.length);
return BadAlloc;
}
}
}
else {
/* Just discard data from all replies before the last one */
if (be_reply.length > 0)
_XEatDataWords(dpy, be_reply.length);
}
UnlockDisplay(dpy);
SyncHandle();
}
/*
* send the reply to the client
*/
memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)
free(be_buf);
return Success;
}
int
__glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
{
ClientPtr client = cl->client;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
xGLXVendorPrivateReq *be_req;
xGLXVendorPrivReply reply;
xGLXVendorPrivReply be_reply;
__GLXcontext *glxc;
int buf_size;
char *be_buf = NULL;
int be_buf_size;
DMXScreenInfo *dmxScreen;
Display *dpy;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return __glXBadContext;
}
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
dmxScreen = &dmxScreens[glxc->pScreen->myNum];
dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
/*
* send the request to the first back-end server
*/
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag =
GetCurrentBackEndTag(cl, req->contextTag, glxc->pScreen->myNum);
if (buf_size > 0)
_XSend(dpy, (const char *) pc, buf_size);
/*
* get the reply from the back-end server
*/
_XReply(dpy, (xReply *) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *) malloc(be_buf_size);
if (be_buf) {
_XRead(dpy, be_buf, be_buf_size);
}
else {
/* Throw data on the floor */
_XEatDataWords(dpy, be_reply.length);
return BadAlloc;
}
}
UnlockDisplay(dpy);
SyncHandle();
/*
* send the reply to the client
*/
memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
SendSwappedReply(client, &reply, be_buf, be_buf_size);
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, be_buf);
}
if (be_buf_size > 0)
free(be_buf);
return Success;
}
/*
* NAME
* XcmsAllocNamedColor -
*
* SYNOPSIS
*/
Status
XcmsAllocNamedColor (
Display *dpy,
Colormap cmap,
_Xconst char *colorname,
XcmsColor *pColor_scrn_return,
XcmsColor *pColor_exact_return,
XcmsColorFormat result_format)
/*
* DESCRIPTION
* Finds the color specification associated with the color
* name in the Device-Independent Color Name Database, then
* converts that color specification to an RGB format. This
* RGB value is then used in a call to XAllocColor to allocate
* a read-only color cell.
*
* RETURNS
* 0 if failed to parse string or find any entry in the database.
* 1 if succeeded in converting color name to XcmsColor.
* 2 if succeeded in converting color name to another color name.
*
*/
{
long nbytes;
xAllocNamedColorReply rep;
xAllocNamedColorReq *req;
XColor hard_def;
XColor exact_def;
Status retval1 = 1;
Status retval2 = XcmsSuccess;
XcmsColor tmpColor;
XColor XColor_in_out;
XcmsCCC ccc;
/*
* 0. Check for invalid arguments.
*/
if (dpy == NULL || colorname[0] == '\0' || pColor_scrn_return == 0
|| pColor_exact_return == NULL) {
return(XcmsFailure);
}
if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) {
return(XcmsFailure);
}
/*
* 1. Convert string to a XcmsColor using Xcms and i18n mechanism
*/
if ((retval1 = _XcmsResolveColorString(ccc, &colorname,
&tmpColor, result_format)) == XcmsFailure) {
return(XcmsFailure);
}
if (retval1 == _XCMS_NEWNAME) {
goto PassToServer;
}
memcpy((char *)pColor_exact_return, (char *)&tmpColor, sizeof(XcmsColor));
/*
* 2. Convert tmpColor to RGB
* Assume pColor_exact_return is now adjusted to Client White Point
*/
if ((retval2 = XcmsConvertColors(ccc, &tmpColor,
1, XcmsRGBFormat, (Bool *) NULL)) == XcmsFailure) {
return(XcmsFailure);
}
/*
* 3. Convert to XColor and call XAllocColor
*/
_XcmsRGB_to_XColor(&tmpColor, &XColor_in_out, 1);
if (XAllocColor(ccc->dpy, cmap, &XColor_in_out) == 0) {
return(XcmsFailure);
}
/*
* 4. pColor_scrn_return
*
* Now convert to the target format.
* We can ignore the return value because we're already in a
* device-dependent format.
*/
_XColor_to_XcmsRGB(ccc, &XColor_in_out, pColor_scrn_return, 1);
if (result_format != XcmsRGBFormat) {
if (result_format == XcmsUndefinedFormat) {
result_format = pColor_exact_return->format;
}
if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
(Bool *) NULL) == XcmsFailure) {
return(XcmsFailure);
}
}
return(retval1 > retval2 ? retval1 : retval2);
PassToServer:
/*
* All previous methods failed, so lets pass it to the server
* for parsing.
*/
dpy = ccc->dpy;
LockDisplay(dpy);
GetReq(AllocNamedColor, req);
req->cmap = cmap;
nbytes = req->nbytes = strlen(colorname);
req->length += (nbytes + 3) >> 2; /* round up to mult of 4 */
_XSend(dpy, colorname, nbytes);
/* _XSend is more efficient that Data, since _XReply follows */
if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
UnlockDisplay(dpy);
SyncHandle();
return (0);
}
exact_def.red = rep.exactRed;
exact_def.green = rep.exactGreen;
exact_def.blue = rep.exactBlue;
hard_def.red = rep.screenRed;
hard_def.green = rep.screenGreen;
hard_def.blue = rep.screenBlue;
exact_def.pixel = hard_def.pixel = rep.pixel;
UnlockDisplay(dpy);
SyncHandle();
/*
* Now convert to the target format.
*/
_XColor_to_XcmsRGB(ccc, &exact_def, pColor_exact_return, 1);
_XColor_to_XcmsRGB(ccc, &hard_def, pColor_scrn_return, 1);
if (result_format != XcmsRGBFormat
&& result_format != XcmsUndefinedFormat) {
if (XcmsConvertColors(ccc, pColor_exact_return, 1, result_format,
(Bool *) NULL) == XcmsFailure) {
return(XcmsFailure);
}
if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
(Bool *) NULL) == XcmsFailure) {
return(XcmsFailure);
}
}
return(XcmsSuccess);
}
Status
XAllocNamedColor(
register Display *dpy,
Colormap cmap,
_Xconst char *colorname, /* STRING8 */
XColor *hard_def, /* RETURN */
XColor *exact_def) /* RETURN */
{
long nbytes;
xAllocNamedColorReply rep;
xAllocNamedColorReq *req;
XcmsCCC ccc;
XcmsColor cmsColor_exact;
Status ret;
/*
* Let's Attempt to use Xcms and i18n approach to Parse Color
*/
if ((ccc = XcmsCCCOfColormap(dpy, cmap)) != (XcmsCCC)NULL) {
const char *tmpName = colorname;
switch (_XcmsResolveColorString(ccc, &tmpName, &cmsColor_exact,
XcmsRGBFormat)) {
case XcmsSuccess:
case XcmsSuccessWithCompression:
_XcmsRGB_to_XColor(&cmsColor_exact, exact_def, 1);
memcpy((char *)hard_def, (char *)exact_def, sizeof(XColor));
ret = XAllocColor(dpy, cmap, hard_def);
exact_def->pixel = hard_def->pixel;
return(ret);
case XcmsFailure:
case _XCMS_NEWNAME:
/*
* if the result was _XCMS_NEWNAME tmpName points to
* a string in cmsColNm.c:pairs table, for example,
* gray70 would become tekhvc:0.0/70.0/0.0
*/
break;
}
}
/*
* Xcms and i18n approach failed.
*/
LockDisplay(dpy);
GetReq(AllocNamedColor, req);
req->cmap = cmap;
nbytes = req->nbytes = strlen(colorname);
req->length += (nbytes + 3) >> 2; /* round up to mult of 4 */
_XSend(dpy, colorname, nbytes);
/* _XSend is more efficient that Data, since _XReply follows */
if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
UnlockDisplay(dpy);
SyncHandle();
return (0);
}
exact_def->red = rep.exactRed;
exact_def->green = rep.exactGreen;
exact_def->blue = rep.exactBlue;
hard_def->red = rep.screenRed;
hard_def->green = rep.screenGreen;
hard_def->blue = rep.screenBlue;
exact_def->pixel = hard_def->pixel = rep.pixel;
UnlockDisplay(dpy);
SyncHandle();
return (1);
}