fteqw/plugins/xsv/x_reqs.c

3902 lines
98 KiB
C
Raw Normal View History

#include "../plugin.h"
#include <math.h>
#include "qux.h"
#undef strncpy
XRequest XRequests [256];
#ifdef XBigReqExtensionName
int X_BigReqCode;
#endif
void XR_MapWindow(xclient_t *cl, xReq *request);
void XR_UnmapWindow(xclient_t *cl, xReq *request);
#define GXclear 0x0 /* 0 */
#define GXand 0x1 /* src AND dst */
#define GXandReverse 0x2 /* src AND NOT dst */
#define GXcopy 0x3 /* src */
#define GXandInverted 0x4 /* NOT src AND dst */
#define GXnoop 0x5 /* dst */
#define GXxor 0x6 /* src XOR dst */
#define GXor 0x7 /* src OR dst */
#define GXnor 0x8 /* NOT src AND NOT dst */
#define GXequiv 0x9 /* NOT src XOR dst */
#define GXinvert 0xa /* NOT dst */
#define GXorReverse 0xb /* src OR NOT dst */
#define GXcopyInverted 0xc /* NOT src */
#define GXorInverted 0xd /* NOT src OR dst */
#define GXnand 0xe /* NOT src OR NOT dst */
#define GXset 0xf /* 1 */
#define GCFunc(src, dst, fnc, out, setval) \
switch(fnc) \
{ \
case GXclear: \
out = 0; \
break; \
case GXand: \
out = src&dst; \
break; \
case GXandReverse: \
out = src&~dst; \
break; \
case GXcopy: \
out = src; \
break; \
case GXandInverted: \
out = ~src&dst; \
break; \
case GXnoop: \
out = dst; \
break; \
case GXxor: \
out = src^dst; \
break; \
case GXor: \
out = src|dst; \
break; \
case GXnor: \
out = ~src&~dst; \
break; \
case GXequiv: \
out = ~src^dst; \
break; \
case GXinvert: \
out = ~dst; \
break; \
case GXorReverse: \
out = src|~dst; \
break; \
case GXcopyInverted: \
out = ~src; \
break; \
case GXorInverted: \
out = ~src|dst; \
break; \
case GXnand: \
out = ~src|~dst; \
break; \
case GXset: \
out = setval; \
break; \
}
void XW_ClearArea(xwindow_t *wnd, int xp, int yp, int width, int height);
void XR_QueryExtension (xclient_t *cl, xReq *request)
{
char extname[256];
xQueryExtensionReply rep;
xQueryExtensionReq *req = (xQueryExtensionReq *)request;
if (req->nbytes > sizeof(extname)-1)
req->nbytes = sizeof(extname)-1;
memcpy(extname, (char *)(req+1), req->nbytes);
extname[req->nbytes] = '\0';
#ifdef XBigReqExtensionName
if (X_BigReqCode && !strcmp(extname, XBigReqExtensionName))
{
rep.major_opcode = X_BigReqCode;
rep.present = true;
rep.first_event = 0;
rep.first_error = 0;
}
else
#endif
{
Con_Printf("Extension %s not supported\n", extname);
rep.major_opcode = 0;
rep.present = false;
rep.first_event = 0;
rep.first_error = 0;
}
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
rep.pad6 = 0;
rep.pad7 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
void XW_ExposeWindowRegionInternal(xwindow_t *root, int x, int y, int width, int height)
{
int nx,ny,nw,nh;
xEvent ev;
if (!root->mapped || root->inputonly)
return;
ev.u.u.type = VisibilityNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.visibility.window = root->res.id;
ev.u.visibility.state = VisibilityUnobscured;
ev.u.visibility.pad1 = 0;
ev.u.visibility.pad2 = 0;
ev.u.visibility.pad3 = 0;
X_SendNotificationMasked(&ev, root, VisibilityChangeMask);
ev.u.u.type = Expose;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.expose.window = root->res.id;
ev.u.expose.x = x;
ev.u.expose.y = y;
ev.u.expose.width = width;
ev.u.expose.height = height;
ev.u.expose.count = false; //other expose events following (none - rewrite to group these then send all in one go...)
ev.u.expose.pad2 = 0;
X_SendNotificationMasked(&ev, root, ExposureMask);
if (root->buffer && root != rootwindow)
{
// XW_ClearArea(root, 0, 0, root->width, root->height);
// free(root->buffer);
// root->buffer = NULL;
}
for (root = root->child; root; root = root->sibling)
{
if (!root->mapped || root->inputonly)
continue;
//subtract the minpos
nx = x - root->xpos;
nw = width;
ny = y - root->ypos;
nh = height;
//cap new minpos to the child window.
if (nx < 0)
{
nw += nx;
nx = 0;
}
if (ny < 0)
{
nh += ny;
ny = 0;
}
//cap new maxpos
if (nx+nw > x + root->width)
nw = x+root->width - nx;
if (ny+nh > y + root->height)
nh = y+root->height - ny;
if (nw > 0 && nh > 0) //make sure some is valid.
XW_ExposeWindowRegionInternal(root, nx, ny, nw, nh);
}
}
void XW_ExposeWindow(xwindow_t *root, int x, int y, int width, int height)
{//we have to go back to the root so we know the exact region, and can expose our sibling's windows.
while(root)
{
x += root->xpos;
y += root->ypos;
root = root->parent;
}
XW_ExposeWindowRegionInternal(rootwindow, x, y, width, height);
}
void XR_ListExtensions (xclient_t *cl, xReq *request)
{
char buffer[8192];
xListExtensionsReply *rep = (xListExtensionsReply *)buffer;
char *out;
rep->type = X_Reply;
rep->nExtensions = 0;
rep->sequenceNumber = cl->requestnum;
rep->length = 0;
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
rep->pad6 = 0;
rep->pad7 = 0;
out = (char *)(rep+1);
#ifdef XBigReqExtensionName
rep->nExtensions++;
strcpy(out, XBigReqExtensionName);
out+=strlen(out)+1;
#endif
rep->length = (out-(char *)(rep+1) + 3)/4;
X_SendData(cl, rep, sizeof(xListExtensionsReply) + rep->length*4);
}
void XR_SetCloseDownMode(xclient_t *cl, xReq *request)
{
xSetCloseDownModeReq *req = (xSetCloseDownModeReq*)request;
switch(req->mode)
{
case DestroyAll:
case RetainPermanent:
case RetainTemporary:
break;
default:
X_SendError(cl, BadValue, req->mode, X_SetCloseDownMode, 0);
return;
}
cl->closedownmode = req->mode;
}
void XR_GetAtomName (xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq*)request;
char buffer[8192];
xGetAtomNameReply *rep = (xGetAtomNameReply*)buffer;
xatom_t *xa;
if (XS_GetResource(req->id, (void**)&xa) != x_atom)
{
X_SendError(cl, BadAtom, req->id, X_GetAtomName, 0);
return;
}
rep->type = X_Reply;
rep->pad1 = 0;
rep->sequenceNumber = cl->requestnum;
rep->length = (strlen(xa->atomname)+3)/4;
rep->nameLength = strlen(xa->atomname);
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
rep->pad6 = 0;
rep->pad7 = 0;
strcpy((char *)(rep+1), xa->atomname);
X_SendData(cl, rep, sizeof(*rep)+rep->length*4);
}
void XR_InternAtom (xclient_t *cl, xReq *request)
{
xInternAtomReq *req = (xInternAtomReq*)request;
xInternAtomReply rep;
char atomname[1024];
Atom atom;
if (req->nbytes >= sizeof(atomname))
{ //exceeded that limit then...
X_SendError(cl, BadImplementation, 0, X_InternAtom, 0);
return;
}
strncpy(atomname, (char *)(req+1), req->nbytes);
atomname[req->nbytes] = '\0';
atom = XS_FindAtom(atomname);
if (atom == None && !req->onlyIfExists)
{
atom = XS_NewResource();
XS_CreateAtom(atom, atomname, NULL); //global atom...
}
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.atom = atom;
rep.pad2 = 0;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
rep.pad6 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
void XR_GetProperty (xclient_t *cl, xReq *request)
{
xGetPropertyReq *req = (xGetPropertyReq*)request;
char buffer[8192];
xwindow_t *wnd;
int datalen;
int format;
int trailing;
xGetPropertyReply *rep = (xGetPropertyReply*)buffer;
Atom proptype;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{ //wait a minute, That's not a window!!!
X_SendError(cl, BadWindow, req->window, X_GetProperty, 0);
return;
}
if (XS_GetResource(req->property, (void**)NULL) != x_atom)
{ //whoops
X_SendError(cl, BadAtom, req->property, X_GetProperty, 0);
return;
}
if (req->longLength > sizeof(buffer) - sizeof(req)/4)
req->longLength = sizeof(buffer) - sizeof(req)/4;
datalen = XS_GetProperty(wnd, req->property, &proptype, (char *)(rep+1), req->longLength*4, req->longOffset*4, &trailing, &format);
rep->type = X_Reply;
rep->format = format;
rep->propertyType = proptype;
rep->sequenceNumber = cl->requestnum;
rep->length = (datalen+3)/4;
//rep->propertyType = None;
rep->bytesAfter = trailing;
if (format)
rep->nItems = datalen / (format/8);
else
rep->nItems = 0;
rep->pad1 = 0;
rep->pad2 = 0;
rep->pad3 = 0;
X_SendData(cl, rep, rep->length*4 + sizeof(*rep));
if (req->delete)
{
xEvent ev;
XS_DeleteProperty(wnd, req->property);
ev.u.u.type = PropertyNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.property.window = req->window;
ev.u.property.atom = req->property;
ev.u.property.time = pSys_Milliseconds();
ev.u.property.state = PropertyDelete;
ev.u.property.pad1 = 0;
ev.u.property.pad2 = 0;
X_SendNotificationMasked(&ev, wnd, PropertyChangeMask);
}
}
void XR_ListProperties(xclient_t *cl, xReq *request)
{
xproperty_t *xp;
xResourceReq *req = (xResourceReq*)request;
char buffer[65536];
xwindow_t *wnd;
xListPropertiesReply *rep = (xListPropertiesReply*)buffer;
Atom *out = (Atom *)(rep+1);
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{ //wait a minute, That's not a window!!!
X_SendError(cl, BadWindow, req->id, X_GetProperty, 0);
return;
}
rep->type = X_Reply;
rep->sequenceNumber = cl->requestnum;
rep->length = 0;
rep->nProperties = 0;
rep->pad1 = 0;
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
rep->pad6 = 0;
rep->pad7 = 0;
for (xp = wnd->properties; xp; xp = xp->next)
{
rep->nProperties++;
*out = xp->atomid;
}
rep->length = rep->nProperties;
X_SendData(cl, rep, rep->length*4 + sizeof(*rep));
}
void XR_ChangeProperty (xclient_t *cl, xReq *request)
{
xChangePropertyReq *req = (xChangePropertyReq*)request;
int len;
xatom_t *atom;
xwindow_t *wnd;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{ //wait a minute, That's not a window!!!
X_SendError(cl, BadWindow, req->window, X_ChangeProperty, 0);
return;
}
if (XS_GetResource(req->property, (void**)&atom) != x_atom)
{
X_SendError(cl, BadAtom, req->property, X_ChangeProperty, 0);
return;
}
len = req->nUnits * (req->format/8);
if (req->mode == PropModeReplace)
XS_SetProperty(wnd, req->property, req->type, (char *)(req+1), len, req->format);
else if (req->mode == PropModePrepend)
{
X_SendError(cl, BadImplementation, req->window, X_ChangeProperty, 0);
return;
}
else if (req->mode == PropModeAppend)
{
char hugebuffer[65536];
int trailing;
int format, datalen;
Atom proptype;
datalen = XS_GetProperty(wnd, req->property, &proptype, hugebuffer, sizeof(hugebuffer), 0, &trailing, &format);
if (datalen+len > sizeof(hugebuffer))
{
X_SendError(cl, BadImplementation, req->window, X_ChangeProperty, 0);
return;
}
memcpy(hugebuffer + datalen, (char *)(req+1), len);
XS_SetProperty(wnd, req->property, proptype, hugebuffer, datalen+len, format);
}
{
xEvent ev;
ev.u.u.type = PropertyNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.property.window = req->window;
ev.u.property.atom = req->property;
ev.u.property.time = pSys_Milliseconds();
ev.u.property.state = PropertyNewValue;
ev.u.property.pad1 = 0;
ev.u.property.pad2 = 0;
X_SendNotificationMasked(&ev, wnd, PropertyChangeMask);
}
}
void XR_DeleteProperty(xclient_t *cl, xReq *request)
{
xDeletePropertyReq *req = (xDeletePropertyReq*)request;
xwindow_t *wnd;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{ //wait a minute, That's not a window!!!
X_SendError(cl, BadWindow, req->window, X_DeleteProperty, 0);
return;
}
if (XS_GetResource(req->property, (void**)NULL) != x_atom)
{
X_SendError(cl, BadAtom, req->property, X_DeleteProperty, 0);
return;
}
XS_DeleteProperty(wnd, req->property);
{
xEvent ev;
ev.u.u.type = PropertyNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.property.window = req->window;
ev.u.property.atom = req->property;
ev.u.property.time = pSys_Milliseconds();
ev.u.property.state = PropertyDelete;
ev.u.property.pad1 = 0;
ev.u.property.pad2 = 0;
X_SendNotificationMasked(&ev, wnd, PropertyChangeMask);
}
}
void XR_GetSelectionOwner (xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xGetSelectionOwnerReply reply;
xatom_t *atom;
if (XS_GetResource(req->id, (void**)&atom) != x_atom)
{
X_SendError(cl, BadAtom, req->id, X_GetSelectionOwner, 0);
return;
}
if (XS_GetResource(atom->selectionownerwindowid, (void**)NULL) != x_window) //make sure the window still exists.
{
atom->selectionownerwindowid = None;
}
reply.type = X_Reply;
reply.sequenceNumber = cl->requestnum;
reply.length = 0;
reply.owner = atom->selectionownerwindowid;
reply.pad1 = 0;
reply.pad2 = 0;
reply.pad3 = 0;
reply.pad4 = 0;
reply.pad5 = 0;
reply.pad6 = 0;
X_SendData(cl, &reply, sizeof(reply));
}
void XR_SetSelectionOwner (xclient_t *cl, xReq *request)
{
xSetSelectionOwnerReq *req = (xSetSelectionOwnerReq *)request;
xatom_t *atom;
xwindow_t *window;
if (XS_GetResource(req->selection, (void**)&atom) != x_atom)
{
X_SendError(cl, BadAtom, req->selection, X_SetSelectionOwner, 0);
return;
}
if (XS_GetResource(req->window, (void**)&window) != x_window) //make sure the window still exists.
{
X_SendError(cl, BadWindow, req->window, X_SetSelectionOwner, 0);
return;
}
if (req->window)
{
atom->selectionownerwindowid = req->window;
atom->selectionownerclient = cl;
}
else
{
atom->selectionownerwindowid = None;
atom->selectionownerclient = NULL;
}
}
void XR_ConvertSelection (xclient_t *cl, xReq *request)
{
xConvertSelectionReq *req = (void*)request;
xatom_t *atom = XS_GetResourceType(req->selection, x_atom);
xEvent rep;
if (atom && atom->selectionownerwindowid)
{ //forward the request to the selection's owner
rep.u.u.type = SelectionRequest;
rep.u.u.detail = 0;
rep.u.u.sequenceNumber = 0;
rep.u.selectionRequest.time = req->time;
rep.u.selectionRequest.owner = atom->selectionownerwindowid;
rep.u.selectionRequest.target = req->target;
rep.u.selectionRequest.property = req->property;
rep.u.selectionRequest.requestor = req->requestor;
rep.u.selectionRequest.selection = req->selection;
X_SendData(atom->selectionownerclient, &rep, sizeof(rep));
}
else
{ //return it back to the sender, or so
rep.u.u.type = SelectionNotify;
rep.u.u.detail = 0;
rep.u.u.sequenceNumber = 0;
rep.u.selectionNotify.time = req->time;
rep.u.selectionNotify.target = req->target;
rep.u.selectionNotify.property = req->property;
rep.u.selectionNotify.requestor = req->requestor;
rep.u.selectionNotify.selection = req->selection;
X_SendData(cl, &rep, sizeof(rep));
}
}
extern int x_windowwithcursor;
void XR_GetInputFocus (xclient_t *cl, xReq *request)
{
xGetInputFocusReply rep;
extern xwindow_t *xfocusedwindow;
rep.type = X_Reply;
rep.revertTo = None;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.focus = xfocusedwindow?xfocusedwindow->res.id:None;
rep.pad1 = 0;
rep.pad2 = 0;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
void XR_SetInputFocus (xclient_t *cl, xReq *request)
{
extern xwindow_t *xfocusedwindow;
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadDrawable, req->id, X_SetInputFocus, 0);
return;
}
xfocusedwindow = wnd;
X_EvalutateFocus(NotifyWhileGrabbed);
}
void XR_QueryBestSize (xclient_t *cl, xReq *request)
{
xQueryBestSizeReq *req = (xQueryBestSizeReq *)request;
xQueryBestSizeReply rep;
if (req->class == CursorShape && req->drawable != rootwindow->res.id)
{
X_SendError(cl, BadDrawable, req->drawable, X_QueryBestSize, req->class);
return;
}
else if (req->class != CursorShape)
{
X_SendError(cl, BadImplementation, req->drawable, X_QueryBestSize, req->class);
return;
}
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.width = req->width;
rep.height = req->height;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
rep.pad6 = 0;
rep.pad7 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
void XR_GetGeometry (xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xGetGeometryReply rep;
xresource_t *drawable;
xwindow_t *wnd;
xpixmap_t *pm;
rep.type = X_Reply;
rep.depth = 24;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.root = 0;
rep.x = 0;
rep.y = 0;
rep.width = 0;
rep.height = 0;
rep.borderWidth = 0;
rep.pad1 = 0;
rep.pad2 = 0;
rep.pad3 = 0;
switch(XS_GetResource(req->id, (void**)&drawable))
{
case x_window:
wnd = (xwindow_t*)drawable;
rep.x = wnd->xpos;
rep.y = wnd->ypos;
rep.borderWidth = 0; //fixme
rep.width = wnd->width;
rep.height = wnd->height;
rep.root = rootwindow->res.id;
break;
case x_pixmap:
pm = (xpixmap_t*)drawable;
rep.width = pm->width;
rep.height = pm->height;
break;
default:
X_SendError(cl, BadDrawable, req->id, X_GetGeometry, 0);
return;
}
X_SendData(cl, &rep, sizeof(rep));
}
void XR_CreateWindow (xclient_t *cl, xReq *request)
{
xCreateWindowReq *req = (xCreateWindowReq *)request;
xwindow_t *parent;
xwindow_t *wnd;
CARD32 *parameters;
if (req->class == InputOnly && req->depth != 0)
{
X_SendError(cl, BadMatch, req->wid, X_CreateWindow, 0);
return;
}
if (XS_GetResource(req->wid, (void**)&parent) != x_none)
{
X_SendError(cl, BadIDChoice, req->wid, X_CreateWindow, 0);
return;
}
if (XS_GetResource(req->parent, (void**)&parent) != x_window)
{
X_SendError(cl, BadWindow, req->parent, X_CreateWindow, 0);
return;
}
wnd = XS_CreateWindow(req->wid, cl, parent, req->x, req->y, req->width, req->height);
if (req->depth != 0)
wnd->depth = req->depth;
else
wnd->depth = parent->depth;
if (req->class == CopyFromParent)
wnd->inputonly = parent->inputonly;
else
wnd->inputonly = (req->class == InputOnly);
//FIXME: Depth must be valid
//FIXME: visual id must be valid.
parameters = (CARD32 *)(req+1);
if (req->mask & CWBackPixmap)
{
wnd->backpixmap = NULL;
if (XS_GetResource(*parameters, (void**)&wnd->backpixmap) != x_pixmap)
{
if (*parameters)
X_SendError(cl, BadPixmap, *parameters, X_CreateWindow, 0);
}
else
wnd->backpixmap->references++;
parameters++;
}
if (req->mask & CWBackPixel)//
{
wnd->backpixel = *parameters;
parameters++;
}
if (req->mask & CWBorderPixmap)
parameters+=0;
if (req->mask & CWBorderPixel)//
{
wnd->borderpixel = *parameters;
parameters++;
}
if (req->mask & CWBitGravity)//
{
wnd->bitgravity = *parameters;
parameters++;
}
if (req->mask & CWWinGravity)
wnd->bitgravity = *parameters++;
if (req->mask & CWBackingStore)
parameters++; //ignored
if (req->mask & CWBackingPlanes)
parameters+=0;
if (req->mask & CWBackingPixel)
parameters+=0;
if (req->mask & CWOverrideRedirect)
wnd->overrideredirect = *parameters++;
else
wnd->overrideredirect = false;
if (req->mask & CWSaveUnder)
parameters++;
if (req->mask & CWEventMask)//
{
xnotificationmask_t *nm;
nm = malloc(sizeof(xnotificationmask_t));
nm->client = cl;
nm->next = NULL;
nm->mask = *parameters;
wnd->notificationmask = nm;
parameters++;
wnd->notificationmasks = 0;
for (nm = wnd->notificationmask; nm; nm = nm->next)
wnd->notificationmasks |= nm->mask;
}
if (req->mask & CWDontPropagate)
wnd->donotpropagate = *parameters++;
if (req->mask & CWColormap)//
{
wnd->colormap = *parameters;
parameters++;
}
if (req->mask & CWCursor)
parameters++;
#define CWBackPixmap (1L<<0)
#define CWBackPixel (1L<<1)
#define CWBorderPixmap (1L<<2)
#define CWBorderPixel (1L<<3)
#define CWBitGravity (1L<<4)
#define CWWinGravity (1L<<5)
#define CWBackingStore (1L<<6)
#define CWBackingPlanes (1L<<7)
#define CWBackingPixel (1L<<8)
#define CWOverrideRedirect (1L<<9)
#define CWSaveUnder (1L<<10)
#define CWEventMask (1L<<11)
#define CWDontPropagate (1L<<12)
#define CWColormap (1L<<13)
#define CWCursor (1L<<14)
/*
CARD8 depth;
Window wid;
Window parent;
INT16 x B16, y B16;
CARD16 width B16, height B16, borderWidth B16;
#if defined(__cplusplus) || defined(c_plusplus)
CARD16 c_class B16;
#else
CARD16 class B16;
#endif
VisualID visual B32;
CARD32 mask B32;
*/
if (wnd->inputonly)
return;
{
xEvent ev;
ev.u.u.type = CreateNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.createNotify.parent = wnd->parent->res.id;
ev.u.createNotify.window = wnd->res.id;
ev.u.createNotify.x = wnd->xpos;
ev.u.createNotify.y = wnd->ypos;
ev.u.createNotify.width = wnd->width;
ev.u.createNotify.height = wnd->height;
ev.u.createNotify.borderWidth = req->borderWidth;
ev.u.createNotify.override = wnd->overrideredirect;
ev.u.createNotify.bpad = 0;
X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask);
}
/* {
xEvent ev;
ev.u.u.type = MapRequest;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.mapRequest.window = wnd->res.id;
ev.u.mapRequest.parent = wnd->parent->res.id;
X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask);
}*/
/* {
xEvent ev;
ev.u.u.type = GraphicsExpose;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.expose.window = wnd->res.id;
ev.u.expose.x = 0;
ev.u.expose.y = 0;
ev.u.expose.width = wnd->width;
ev.u.expose.height = wnd->height;
ev.u.expose.count = 0; //matching expose events after this one
ev.u.expose.pad2 = 0;
X_SendNotificationMasked(&ev, wnd, ExposureMask);
}*/
}
void XR_ChangeWindowAttributes (xclient_t *cl, xReq *request)
{
CARD32 *parameters;
xChangeWindowAttributesReq *req = (xChangeWindowAttributesReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->window, X_ChangeWindowAttributes, 0);
return;
}
parameters = (CARD32 *)(req+1);
if (req->valueMask & CWBackPixmap)
{
if (wnd->backpixmap)
wnd->backpixmap->references--;
wnd->backpixmap = NULL;
if (XS_GetResource(*parameters, (void**)&wnd->backpixmap) != x_pixmap)
{
if (*parameters)
X_SendError(cl, BadPixmap, *parameters, X_ChangeWindowAttributes, 0);
}
else
wnd->backpixmap->references++;
parameters++;
}
if (req->valueMask & CWBackPixel)
{
if (wnd->backpixmap)
wnd->backpixmap->references--;
wnd->backpixmap = NULL;
wnd->backpixel = *parameters++;
}
if (req->valueMask & CWBorderPixmap)
{
X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
/* wnd->borderpixmap = NULL;
if (XS_GetResource(*parameters, (void**)&wnd->borderpixmap) != x_pixmap)
{
if (*parameters)
X_SendError(cl, BadPixmap, *parameters, X_ChangeWindowAttributes, 0);
}
else
wnd->backpixmap->references++;
*/ parameters++;
}
if (req->valueMask & CWBorderPixel)
wnd->borderpixel = *parameters++;
if (req->valueMask & CWBitGravity)
{
wnd->bitgravity = *parameters++;
}
if (req->valueMask & CWWinGravity)
{
wnd->wingravity = *parameters++;
}
if (req->valueMask & CWBackingStore)
{
// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++; //ignore
}
if (req->valueMask & CWBackingPlanes)
{
X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++;
}
if (req->valueMask & CWBackingPixel)
{
X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++;
}
if (req->valueMask & CWOverrideRedirect)
{
wnd->overrideredirect = *parameters++;
}
if (req->valueMask & CWSaveUnder)
{
// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++;
}
if (req->valueMask & CWEventMask)
{
xnotificationmask_t *nm;
if (*parameters & (SubstructureRedirectMask | ResizeRedirectMask))
{ //you're only allowed one client with that one at a time.
for (nm = wnd->notificationmask; nm; nm = nm->next)
{
if (nm->mask & (*parameters))
if (nm->client != cl)
break;
}
}
else
nm = NULL;
if (nm) //client has this one.
X_SendError(cl, BadAccess, *parameters, X_ChangeWindowAttributes, CWEventMask);
else
{
for (nm = wnd->notificationmask; nm; nm = nm->next)
{
if (nm->client == cl)
break;
}
if (!nm)
{
nm = malloc(sizeof(xnotificationmask_t));
nm->next = wnd->notificationmask;
wnd->notificationmask = nm;
nm->client = cl;
}
nm->mask = *parameters;
wnd->notificationmasks = 0;
for (nm = wnd->notificationmask; nm; nm = nm->next)
wnd->notificationmasks |= nm->mask;
}
parameters++;
}
if (req->valueMask & CWDontPropagate)
{
wnd->donotpropagate = *parameters++;
}
if (req->valueMask & CWColormap)
{
X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++;
}
if (req->valueMask & CWCursor)
{
// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
parameters++;
}
xrefreshed=true;
if (req->valueMask > CWCursor) //anything else is an error on some implementation's part.
X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0);
// XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
void XR_ConfigureWindow (xclient_t *cl, xReq *request)
{
int newx, newy, neww, newh, sibid, newbw, stackmode;
xConfigureWindowReq *req = (xConfigureWindowReq *)request;
xwindow_t *wnd;
CARD32 *parm;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->window, X_ConfigureWindow, 0);
return;
}
if (!wnd->parent) //root window.
{ //can't resize this one.
X_SendError(cl, BadWindow, req->window, X_ConfigureWindow, 0);
return;
}
parm = (CARD32 *)(req+1);
if (req->mask & CWX)
newx = *parm++;
else
newx=wnd->xpos;
if (req->mask & CWY)
newy = *parm++;
else
newy=wnd->ypos;
if (req->mask & CWWidth)
neww = *parm++;
else
neww=wnd->width;
if (wnd->width <= 0)
wnd->width = 1;
if (req->mask & CWHeight)
newh = *parm++;
else
newh=wnd->height;
if (req->mask & CWBorderWidth)
newbw = *parm++;
else
newbw = 0;
if (req->mask & CWSibling)
sibid = *parm++;
else
sibid = None;
if (req->mask & CWStackMode)
stackmode = *parm++;
else
stackmode = Above;
if (!wnd->overrideredirect && X_NotifcationMaskPresent(wnd, SubstructureRedirectMask, cl))
{
xEvent ev;
ev.u.u.type = ConfigureRequest;
ev.u.u.detail = stackmode;
ev.u.u.sequenceNumber = 0;
ev.u.configureRequest.parent = wnd->parent->res.id;
ev.u.configureRequest.window = wnd->res.id;
ev.u.configureRequest.sibling = sibid;
ev.u.configureRequest.x = newx;
ev.u.configureRequest.y = newy;
ev.u.configureRequest.width = neww;
ev.u.configureRequest.height = newh;
ev.u.configureRequest.borderWidth = newbw;
ev.u.configureRequest.valueMask = req->mask;
ev.u.configureRequest.pad1 = 0;
X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask);
}
else
X_Resize(wnd, newx, newy, neww, newh);
}
void XR_ReparentWindow (xclient_t *cl, xReq *request)
{
qboolean wasmapped;
xEvent ev;
xReparentWindowReq *req = (xReparentWindowReq *)request;
xwindow_t *wnd, *parent;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->window, X_ReparentWindow, 0);
return;
}
if (XS_GetResource(req->parent, (void**)&parent) != x_window)
{
X_SendError(cl, BadWindow, req->parent, X_ReparentWindow, 0);
return;
}
if (wnd->mapped)
{
XR_UnmapWindow(cl, request);
wasmapped = true;
}
else
wasmapped = false;
ev.u.u.type = ReparentNotify;
ev.u.u.detail = 0;
ev.u.reparent.override = wnd->overrideredirect;
ev.u.reparent.window = wnd->res.id;
ev.u.reparent.parent = wnd->parent->res.id;
ev.u.reparent.x = req->x;
ev.u.reparent.y = req->y;
X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask);
XS_SetParent(wnd, parent);
wnd->xpos = req->x;
wnd->ypos = req->y;
X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask); //and again, now that we have the new parent.
ev.u.reparent.event = wnd->res.id;
X_SendNotificationMasked (&ev, wnd, StructureNotifyMask);
if (wasmapped)
XR_MapWindow(cl, request);
}
void XR_DestroyWindow (xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_DestroyWindow, 0);
return;
}
if (!wnd->res.owner) //root window.
return;
XS_DestroyResource(&wnd->res);
}
void XR_QueryTree (xclient_t *cl, xReq *request)
{
char buffer[8192];
xResourceReq *req = (xResourceReq *)request;
xQueryTreeReply *rep = (xQueryTreeReply*)buffer;
xwindow_t *wnd;
Window *cwnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_DestroyWindow, 0);
return;
}
//FIXME: be careful of the count of children overflowing buffer.
rep->type = X_Reply;
rep->pad1 = 0;
rep->sequenceNumber = cl->requestnum;
rep->length = 0;
rep->root = rootwindow->res.id; //we only have one root
if (wnd->parent)
rep->parent = wnd->parent->res.id;
else
rep->parent = 0;
rep->nChildren = 0;
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
cwnd = (Window*)(rep+1);
for (wnd = wnd->child ; wnd ; wnd = wnd->sibling)
{
*cwnd++ = wnd->res.id;
rep->nChildren++;
}
rep->length = rep->nChildren;
X_SendData(cl, rep, sizeof(*rep)+rep->length*4);
}
void XR_GetWindowAttributes (xclient_t *cl, xReq *request)
{
xnotificationmask_t *nm;
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
xGetWindowAttributesReply rep;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_GetWindowAttributes, 0);
return;
}
rep.type = X_Reply;
rep.backingStore = 2;
rep.sequenceNumber = cl->requestnum;
rep.visualID = 0x22;
rep.class = wnd->inputonly;
rep.bitGravity = wnd->bitgravity;
rep.winGravity = wnd->wingravity;
rep.backingBitPlanes = wnd->depth;
rep.backingPixel = wnd->backpixel;
rep.saveUnder = 1;
rep.mapInstalled = !!wnd->buffer;
rep.mapState = wnd->mapped*2;
rep.override = wnd->overrideredirect;
rep.colormap = wnd->colormap;
rep.yourEventMask = 0;
rep.allEventMasks = 0;
for (nm = wnd->notificationmask; nm; nm = nm->next)
{
if (nm->client == cl)
rep.yourEventMask = nm->mask;
rep.allEventMasks |= nm->mask;
}
rep.doNotPropagateMask = wnd->donotpropagate;
rep.pad = 0;
rep.length = (sizeof(xGetWindowAttributesReply) - sizeof(xGenericReply) + 3)/4;
X_SendData(cl, &rep, sizeof(xGetWindowAttributesReply));
}
static struct
{
KeySym keysym[8];
} keyboardmapping[256] =
{
{{0}},
{{0}},
{{0}},
{{0}},
{{0}},
{{0}},
{{0}},
{{0}},
{{0}},
{{XK_Escape, NoSymbol, XK_Escape}}, //10
{{XK_1, XK_exclam, XK_1, XK_exclam, XK_onesuperior, XK_exclamdown, XK_onesuperior}}, //10 //11
{{XK_2, XK_quotedbl, XK_2, XK_quotedbl, XK_twosuperior}},//, XK_oneeighth, XK_twosuperior}}, //12
{{XK_3, XK_sterling, XK_3, XK_sterling, XK_threesuperior, XK_sterling, XK_threesuperior}}, //13
{{XK_4, XK_dollar, XK_4, XK_dollar}},//, XK_EuroSign, XK_onequarter, XK_EuroSign}}, //14
{{XK_5, XK_percent, XK_5, XK_percent, XK_onehalf}},//, XK_threeeighths, XK_onehalf}}, //15
{{XK_6, XK_asciicircum, XK_6, XK_asciicircum, XK_threequarters}},//, XK_fiveeighths, XK_threequarters}}, //16
{{XK_7, XK_ampersand, XK_7, XK_ampersand, XK_braceleft}},//, XK_seveneighths, XK_braceleft}}, //17
{{XK_8, XK_asterisk, XK_8, XK_asterisk, XK_bracketleft}},//, XK_trademark, XK_bracketleft}}, //18
{{XK_9, XK_parenleft, XK_9, XK_parenleft, XK_bracketright, XK_plusminus, XK_bracketright}}, //19
{{XK_0, XK_parenright, XK_0, XK_parenright, XK_braceright, XK_degree, XK_braceright}}, //10
{{XK_minus, XK_underscore, XK_minus, XK_underscore, XK_backslash, XK_questiondown, XK_backslash}}, //20
{{XK_equal, XK_plus, XK_equal, XK_plus}},//, XK_dead_cedilla, XK_dead_ogonek, XK_dead_cedilla}}, //21
{{XK_BackSpace, XK_BackSpace, XK_BackSpace, XK_BackSpace}}, //22
{{XK_Tab}},//, XK_ISO_Left_Tab, XK_Tab, XK_ISO_Left_Tab}}, //23
{{XK_q, XK_Q, XK_q, XK_Q, XK_at}},//, XK_Greek_OMEGA, XK_at}}, //24
{{XK_w, XK_W, XK_w, XK_W}},//, XK_lstroke, XK_Lstroke, XK_lstroke}}, //25
{{XK_e, XK_E, XK_e, XK_E, XK_e, XK_E, XK_e}}, //26
{{XK_r, XK_R, XK_r, XK_R, XK_paragraph, XK_registered, XK_paragraph}}, //27
{{XK_t, XK_T, XK_t, XK_T}},//, XK_tslash, XK_Tslash, XK_tslash}}, //28
{{XK_y, XK_Y, XK_y, XK_Y}},//, XK_leftarrow, XK_yen, XK_leftarrow}}, //29
{{XK_u, XK_U, XK_u, XK_U}},//, XK_downarrow, XK_uparrow, XK_downarrow}}, //30
{{XK_i, XK_I, XK_i, XK_I}},//, XK_rightarrow, XK_idotless, XK_rightarrow}}, //31
{{XK_o, XK_O, XK_o, XK_O, XK_oslash, XK_Oslash, XK_oslash}}, //32
{{XK_p, XK_P, XK_p, XK_P, XK_thorn, XK_THORN, XK_thorn}}, //33
{{XK_bracketleft, XK_braceleft, XK_bracketleft, XK_braceleft}},//, XK_dead_diaeresis, XK_dead_abovering, XK_dead_diaeresis}}, //34
{{XK_bracketright, XK_braceright, XK_bracketright, XK_braceright}},//, XK_dead_tilde, XK_dead_macron, XK_dead_tilde}}, //35
{{XK_Return, NoSymbol, XK_Return}}, //36
{{XK_Control_L, NoSymbol, XK_Control_L}}, //37
{{XK_a, XK_A, XK_a, XK_A, XK_ae, XK_AE, XK_ae}}, //38
{{XK_s, XK_S, XK_s, XK_S, XK_ssharp, XK_section, XK_ssharp}}, //39
{{XK_d, XK_D, XK_d, XK_D, XK_eth, XK_ETH, XK_eth}}, //40
{{XK_f, XK_F, XK_f, XK_F}},//, XK_dstroke, XK_ordfeminine, XK_dstroke}}, //41
{{XK_g, XK_G, XK_g, XK_G}},//, XK_eng, XK_ENG, XK_eng}}, //42
{{XK_h, XK_H, XK_h, XK_H}},//, XK_hstroke, XK_Hstroke, XK_hstroke}}, //43
{{XK_j, XK_J, XK_j, XK_J}},//, XK_dead_hook, XK_dead_horn, XK_dead_hook}}, //44
{{XK_k, XK_K, XK_k, XK_K}},//, XK_kra, XK_ampersand, XK_kra}}, //45
{{XK_l, XK_L, XK_l, XK_L}},//, XK_lstroke, XK_Lstroke, XK_lstroke}}, //46
{{XK_semicolon, XK_colon, XK_semicolon, XK_colon}},//, XK_dead_acute, XK_dead_doubleacute, XK_dead_acute}}, //47
{{XK_apostrophe, XK_at, XK_apostrophe, XK_at}},//, XK_dead_circumflex, XK_dead_caron, XK_dead_circumflex}}, //48
{{XK_grave, XK_notsign, XK_grave, XK_notsign, XK_bar, XK_bar, XK_bar}}, //49
{{XK_Shift_L, NoSymbol, XK_Shift_L}}, //50
{{XK_numbersign, XK_asciitilde, XK_numbersign, XK_asciitilde}},//, XK_dead_grave, XK_dead_breve, XK_dead_grave}}, //51
{{XK_z, XK_Z, XK_z, XK_Z, XK_guillemotleft, XK_less, XK_guillemotleft}}, //52
{{XK_x, XK_X, XK_x, XK_X, XK_guillemotright, XK_greater, XK_guillemotright}}, //53
{{XK_c, XK_C, XK_c, XK_C, XK_cent, XK_copyright, XK_cent}}, //54
{{XK_v, XK_V, XK_v, XK_V}},//, XK_leftdoublequotemark, XK_leftsinglequotemark, XK_leftdoublequotemark}}, //55
{{XK_b, XK_B, XK_b, XK_B}},//, XK_rightdoublequotemark, XK_rightsinglequotemark, XK_rightdoublequotemark}}, //56
{{XK_n, XK_N, XK_n, XK_N, XK_n, XK_N, XK_n}}, //57
{{XK_m, XK_M, XK_m, XK_M, XK_mu, XK_masculine, XK_mu}}, //58
{{XK_comma, XK_less, XK_comma, XK_less}},//, XK_horizconnector, XK_multiply, XK_horizconnector}}, //59
{{XK_period, XK_greater, XK_period, XK_greater, XK_periodcentered, XK_division, XK_periodcentered}}, //60
{{XK_slash, XK_question, XK_slash, XK_question}},//, XK_dead_belowdot, XK_dead_abovedot, XK_dead_belowdot}}, //61
{{XK_Shift_R, NoSymbol, XK_Shift_R}}, //62
{{XK_KP_Multiply, XK_KP_Multiply, XK_KP_Multiply, XK_KP_Multiply, XK_KP_Multiply, XK_KP_Multiply}},//, XK_XF86ClearGrab}}, //63
{{XK_Alt_L, XK_Meta_L, XK_Alt_L, XK_Meta_L}}, //64
{{XK_space, NoSymbol, XK_space}}, //65
{{XK_Caps_Lock, NoSymbol, XK_Caps_Lock}}, //66
{{XK_F1, XK_F1, XK_F1, XK_F1, XK_F1, XK_F1}},//, XK_XF86Switch_VT_1}}, //67
{{XK_F2, XK_F2, XK_F2, XK_F2, XK_F2, XK_F2}},//, XK_XF86Switch_VT_2}}, //68
{{XK_F3, XK_F3, XK_F3, XK_F3, XK_F3, XK_F3}},//, XK_XF86Switch_VT_3}}, //69
{{XK_F4, XK_F4, XK_F4, XK_F4, XK_F4, XK_F4}},//, XK_XF86Switch_VT_4}}, //70
{{XK_F5, XK_F5, XK_F5, XK_F5, XK_F5, XK_F5}},//, XK_XF86Switch_VT_5}}, //71
{{XK_F6, XK_F6, XK_F6, XK_F6, XK_F6, XK_F6}},//, XK_XF86Switch_VT_6}}, //72
{{XK_F7, XK_F7, XK_F7, XK_F7, XK_F7, XK_F7}},//, XK_XF86Switch_VT_7}}, //73
{{XK_F8, XK_F8, XK_F8, XK_F8, XK_F8, XK_F8}},//, XK_XF86Switch_VT_8}}, //74
{{XK_F9, XK_F9, XK_F9, XK_F9, XK_F9, XK_F9}},//, XK_XF86Switch_VT_9}}, //75
{{XK_F10, XK_F10, XK_F10, XK_F10, XK_F10, XK_F10}},//, XK_XF86Switch_VT_10}}, //76
{{XK_Num_Lock, NoSymbol, XK_Num_Lock}}, //77
{{XK_Scroll_Lock, NoSymbol, XK_Scroll_Lock}}, //78
{{XK_KP_Home, XK_KP_7, XK_KP_Home, XK_KP_7}}, //79
{{XK_KP_Up, XK_KP_8, XK_KP_Up, XK_KP_8}}, //80
{{XK_KP_Prior, XK_KP_9, XK_KP_Prior, XK_KP_9}}, //81
{{XK_KP_Subtract, XK_KP_Subtract, XK_KP_Subtract, XK_KP_Subtract, XK_KP_Subtract, XK_KP_Subtract}},//, XK_XF86Prev_VMode}}, //82
{{XK_KP_Left, XK_KP_4, XK_KP_Left, XK_KP_4}}, //83
{{XK_KP_Begin, XK_KP_5, XK_KP_Begin, XK_KP_5}}, //84
{{XK_KP_Right, XK_KP_6, XK_KP_Right, XK_KP_6}}, //85
{{XK_KP_Add, XK_KP_Add, XK_KP_Add, XK_KP_Add, XK_KP_Add, XK_KP_Add}},//, XK_XF86Next_VMode}}, //86
{{XK_KP_End, XK_KP_1, XK_KP_End, XK_KP_1}}, //87
{{XK_KP_Down, XK_KP_2, XK_KP_Down, XK_KP_2}}, //88
{{XK_KP_Next, XK_KP_3, XK_KP_Next, XK_KP_3}}, //89
{{XK_KP_Insert, XK_KP_0, XK_KP_Insert, XK_KP_0}}, //90
{{XK_KP_Delete, XK_KP_Decimal, XK_KP_Delete, XK_KP_Decimal}}, //91
{{0}},//XK_ISO_Level3_Shift, NoSymbol, XK_ISO_Level3_Shift}}, //92
{{0}}, //93
{{XK_backslash, XK_bar, XK_backslash, XK_bar, XK_bar, XK_brokenbar, XK_bar}}, //94
{{XK_F11, XK_F11, XK_F11, XK_F11, XK_F11, XK_F11}},//, XK_XF86Switch_VT_11}}, //95
{{XK_F12, XK_F12, XK_F12, XK_F12, XK_F12, XK_F12}},//, XK_XF86Switch_VT_12}}, //96
{{0}}, //97
{{XK_Katakana, NoSymbol, XK_Katakana}}, //98
{{XK_Hiragana, NoSymbol, XK_Hiragana}}, //99
{{XK_Henkan_Mode, NoSymbol, XK_Henkan_Mode}}, //100
{{XK_Hiragana_Katakana, NoSymbol, XK_Hiragana_Katakana}}, //101
{{XK_Muhenkan, NoSymbol, XK_Muhenkan}}, //102
{{0}}, //103
{{XK_KP_Enter, NoSymbol, XK_KP_Enter}}, //104
{{XK_Control_R, NoSymbol, XK_Control_R}}, //105
{{XK_KP_Divide, XK_KP_Divide, XK_KP_Divide, XK_KP_Divide, XK_KP_Divide, XK_KP_Divide}},//, XK_XF86Ungrab}}, //106
{{XK_Print, XK_Sys_Req, XK_Print, XK_Sys_Req}}, //107
{{0}},//XK_ISO_Level3_Shift, XK_Multi_key, XK_ISO_Level3_Shift, XK_Multi_key}}, //108
{{XK_Linefeed, NoSymbol, XK_Linefeed}}, //109
{{XK_Home, NoSymbol, XK_Home}}, //110
{{XK_Up, NoSymbol, XK_Up}}, //111
{{XK_Prior, NoSymbol, XK_Prior}}, //112
{{XK_Left, NoSymbol, XK_Left}}, //113
{{XK_Right, NoSymbol, XK_Right}}, //114
{{XK_End, NoSymbol, XK_End}}, //115
{{XK_Down, NoSymbol, XK_Down}}, //116
{{XK_Next, NoSymbol, XK_Next}}, //117
{{XK_Insert, NoSymbol, XK_Insert}}, //118
{{XK_Delete, NoSymbol, XK_Delete}}, //119
/*
120
121 0x1008ff12 (XF86AudioMute) 0x0000 (NoSymbol) 0x1008ff12 (XF86AudioMute)
122 0x1008ff11 (XF86AudioLowerVolume) 0x0000 (NoSymbol) 0x1008ff11 (XF86AudioLowerVolume)
123 0x1008ff13 (XF86AudioRaiseVolume) 0x0000 (NoSymbol) 0x1008ff13 (XF86AudioRaiseVolume)
124 0x1008ff2a (XF86PowerOff) 0x0000 (NoSymbol) 0x1008ff2a (XF86PowerOff)
125 0xffbd (KP_Equal) 0x0000 (NoSymbol) 0xffbd (KP_Equal)
126 0x00b1 (plusminus) 0x0000 (NoSymbol) 0x00b1 (plusminus)
127 0xff13 (Pause) 0xff6b (Break) 0xff13 (Pause) 0xff6b (Break)
128 0x1008ff4a (XF86LaunchA) 0x0000 (NoSymbol) 0x1008ff4a (XF86LaunchA)
129 0xffae (KP_Decimal) 0xffae (KP_Decimal) 0xffae (KP_Decimal) 0xffae (KP_Decimal)
130 0xff31 (Hangul) 0x0000 (NoSymbol) 0xff31 (Hangul)
131 0xff34 (Hangul_Hanja) 0x0000 (NoSymbol) 0xff34 (Hangul_Hanja)
132
133 0xffeb (Super_L) 0x0000 (NoSymbol) 0xffeb (Super_L)
134 0xffec (Super_R) 0x0000 (NoSymbol) 0xffec (Super_R)
135 0xff67 (Menu) 0x0000 (NoSymbol) 0xff67 (Menu)
136 0xff69 (Cancel) 0x0000 (NoSymbol) 0xff69 (Cancel)
137 0xff66 (Redo) 0x0000 (NoSymbol) 0xff66 (Redo)
138 0x1005ff70 (SunProps) 0x0000 (NoSymbol) 0x1005ff70 (SunProps)
139 0xff65 (Undo) 0x0000 (NoSymbol) 0xff65 (Undo)
140 0x1005ff71 (SunFront) 0x0000 (NoSymbol) 0x1005ff71 (SunFront)
141 0x1008ff57 (XF86Copy) 0x0000 (NoSymbol) 0x1008ff57 (XF86Copy)
142 0x1008ff6b (XF86Open) 0x0000 (NoSymbol) 0x1008ff6b (XF86Open)
143 0x1008ff6d (XF86Paste) 0x0000 (NoSymbol) 0x1008ff6d (XF86Paste)
144 0xff68 (Find) 0x0000 (NoSymbol) 0xff68 (Find)
145 0x1008ff58 (XF86Cut) 0x0000 (NoSymbol) 0x1008ff58 (XF86Cut)
146 0xff6a (Help) 0x0000 (NoSymbol) 0xff6a (Help)
147 0x1008ff65 (XF86MenuKB) 0x0000 (NoSymbol) 0x1008ff65 (XF86MenuKB)
148 0x1008ff1d (XF86Calculator) 0x0000 (NoSymbol) 0x1008ff1d (XF86Calculator)
149
150 0x1008ff2f (XF86Sleep) 0x0000 (NoSymbol) 0x1008ff2f (XF86Sleep)
151 0x1008ff2b (XF86WakeUp) 0x0000 (NoSymbol) 0x1008ff2b (XF86WakeUp)
152 0x1008ff5d (XF86Explorer) 0x0000 (NoSymbol) 0x1008ff5d (XF86Explorer)
153 0x1008ff7b (XF86Send) 0x0000 (NoSymbol) 0x1008ff7b (XF86Send)
154
155 0x1008ff8a (XF86Xfer) 0x0000 (NoSymbol) 0x1008ff8a (XF86Xfer)
156 0x1008ff41 (XF86Launch1) 0x0000 (NoSymbol) 0x1008ff41 (XF86Launch1)
157 0x1008ff42 (XF86Launch2) 0x0000 (NoSymbol) 0x1008ff42 (XF86Launch2)
158 0x1008ff2e (XF86WWW) 0x0000 (NoSymbol) 0x1008ff2e (XF86WWW)
159 0x1008ff5a (XF86DOS) 0x0000 (NoSymbol) 0x1008ff5a (XF86DOS)
160 0x1008ff2d (XF86ScreenSaver) 0x0000 (NoSymbol) 0x1008ff2d (XF86ScreenSaver)
161 0x1008ff74 (XF86RotateWindows) 0x0000 (NoSymbol) 0x1008ff74 (XF86RotateWindows)
162 0x1008ff7f (XF86TaskPane) 0x0000 (NoSymbol) 0x1008ff7f (XF86TaskPane)
163 0x1008ff19 (XF86Mail) 0x0000 (NoSymbol) 0x1008ff19 (XF86Mail)
164 0x1008ff30 (XF86Favorites) 0x0000 (NoSymbol) 0x1008ff30 (XF86Favorites)
165 0x1008ff33 (XF86MyComputer) 0x0000 (NoSymbol) 0x1008ff33 (XF86MyComputer)
166 0x1008ff26 (XF86Back) 0x0000 (NoSymbol) 0x1008ff26 (XF86Back)
167 0x1008ff27 (XF86Forward) 0x0000 (NoSymbol) 0x1008ff27 (XF86Forward)
168
169 0x1008ff2c (XF86Eject) 0x0000 (NoSymbol) 0x1008ff2c (XF86Eject)
170 0x1008ff2c (XF86Eject) 0x1008ff2c (XF86Eject) 0x1008ff2c (XF86Eject) 0x1008ff2c (XF86Eject)
171 0x1008ff17 (XF86AudioNext) 0x0000 (NoSymbol) 0x1008ff17 (XF86AudioNext)
172 0x1008ff14 (XF86AudioPlay) 0x1008ff31 (XF86AudioPause) 0x1008ff14 (XF86AudioPlay) 0x1008ff31 (XF86AudioPause)
173 0x1008ff16 (XF86AudioPrev) 0x0000 (NoSymbol) 0x1008ff16 (XF86AudioPrev)
174 0x1008ff15 (XF86AudioStop) 0x1008ff2c (XF86Eject) 0x1008ff15 (XF86AudioStop) 0x1008ff2c (XF86Eject)
175 0x1008ff1c (XF86AudioRecord) 0x0000 (NoSymbol) 0x1008ff1c (XF86AudioRecord)
176 0x1008ff3e (XF86AudioRewind) 0x0000 (NoSymbol) 0x1008ff3e (XF86AudioRewind)
177 0x1008ff6e (XF86Phone) 0x0000 (NoSymbol) 0x1008ff6e (XF86Phone)
178
179 0x1008ff81 (XF86Tools) 0x0000 (NoSymbol) 0x1008ff81 (XF86Tools)
180 0x1008ff18 (XF86HomePage) 0x0000 (NoSymbol) 0x1008ff18 (XF86HomePage)
181 0x1008ff73 (XF86Reload) 0x0000 (NoSymbol) 0x1008ff73 (XF86Reload)
182 0x1008ff56 (XF86Close) 0x0000 (NoSymbol) 0x1008ff56 (XF86Close)
183
184
185 0x1008ff78 (XF86ScrollUp) 0x0000 (NoSymbol) 0x1008ff78 (XF86ScrollUp)
186 0x1008ff79 (XF86ScrollDown) 0x0000 (NoSymbol) 0x1008ff79 (XF86ScrollDown)
187 0x0028 (parenleft) 0x0000 (NoSymbol) 0x0028 (parenleft)
188 0x0029 (parenright) 0x0000 (NoSymbol) 0x0029 (parenright)
189 0x1008ff68 (XF86New) 0x0000 (NoSymbol) 0x1008ff68 (XF86New)
190 0xff66 (Redo) 0x0000 (NoSymbol) 0xff66 (Redo)
191 0x1008ff81 (XF86Tools) 0x0000 (NoSymbol) 0x1008ff81 (XF86Tools)
192 0x1008ff45 (XF86Launch5) 0x0000 (NoSymbol) 0x1008ff45 (XF86Launch5)
193 0x1008ff46 (XF86Launch6) 0x0000 (NoSymbol) 0x1008ff46 (XF86Launch6)
194 0x1008ff47 (XF86Launch7) 0x0000 (NoSymbol) 0x1008ff47 (XF86Launch7)
195 0x1008ff48 (XF86Launch8) 0x0000 (NoSymbol) 0x1008ff48 (XF86Launch8)
196 0x1008ff49 (XF86Launch9) 0x0000 (NoSymbol) 0x1008ff49 (XF86Launch9)
197
198 0x1008ffb2 (XF86AudioMicMute) 0x0000 (NoSymbol) 0x1008ffb2 (XF86AudioMicMute)
199 0x1008ffa9 (XF86TouchpadToggle) 0x0000 (NoSymbol) 0x1008ffa9 (XF86TouchpadToggle)
200 0x1008ffb0 (XF86TouchpadOn) 0x0000 (NoSymbol) 0x1008ffb0 (XF86TouchpadOn)
201 0x1008ffb1 (XF86TouchpadOff) 0x0000 (NoSymbol) 0x1008ffb1 (XF86TouchpadOff)
202
203 0xff7e (Mode_switch) 0x0000 (NoSymbol) 0xff7e (Mode_switch)
204 0x0000 (NoSymbol) 0xffe9 (Alt_L) 0x0000 (NoSymbol) 0xffe9 (Alt_L)
205 0x0000 (NoSymbol) 0xffe7 (Meta_L) 0x0000 (NoSymbol) 0xffe7 (Meta_L)
206 0x0000 (NoSymbol) 0xffeb (Super_L) 0x0000 (NoSymbol) 0xffeb (Super_L)
207 0x0000 (NoSymbol) 0xffed (Hyper_L) 0x0000 (NoSymbol) 0xffed (Hyper_L)
208 0x1008ff14 (XF86AudioPlay) 0x0000 (NoSymbol) 0x1008ff14 (XF86AudioPlay)
209 0x1008ff31 (XF86AudioPause) 0x0000 (NoSymbol) 0x1008ff31 (XF86AudioPause)
210 0x1008ff43 (XF86Launch3) 0x0000 (NoSymbol) 0x1008ff43 (XF86Launch3)
211 0x1008ff44 (XF86Launch4) 0x0000 (NoSymbol) 0x1008ff44 (XF86Launch4)
212 0x1008ff4b (XF86LaunchB) 0x0000 (NoSymbol) 0x1008ff4b (XF86LaunchB)
213 0x1008ffa7 (XF86Suspend) 0x0000 (NoSymbol) 0x1008ffa7 (XF86Suspend)
214 0x1008ff56 (XF86Close) 0x0000 (NoSymbol) 0x1008ff56 (XF86Close)
215 0x1008ff14 (XF86AudioPlay) 0x0000 (NoSymbol) 0x1008ff14 (XF86AudioPlay)
216 0x1008ff97 (XF86AudioForward) 0x0000 (NoSymbol) 0x1008ff97 (XF86AudioForward)
217
218 0xff61 (Print) 0x0000 (NoSymbol) 0xff61 (Print)
219
220 0x1008ff8f (XF86WebCam) 0x0000 (NoSymbol) 0x1008ff8f (XF86WebCam)
221
222
223 0x1008ff19 (XF86Mail) 0x0000 (NoSymbol) 0x1008ff19 (XF86Mail)
224 0x1008ff8e (XF86Messenger) 0x0000 (NoSymbol) 0x1008ff8e (XF86Messenger)
225 0x1008ff1b (XF86Search) 0x0000 (NoSymbol) 0x1008ff1b (XF86Search)
226 0x1008ff5f (XF86Go) 0x0000 (NoSymbol) 0x1008ff5f (XF86Go)
227 0x1008ff3c (XF86Finance) 0x0000 (NoSymbol) 0x1008ff3c (XF86Finance)
228 0x1008ff5e (XF86Game) 0x0000 (NoSymbol) 0x1008ff5e (XF86Game)
229 0x1008ff36 (XF86Shop) 0x0000 (NoSymbol) 0x1008ff36 (XF86Shop)
230
231 0xff69 (Cancel) 0x0000 (NoSymbol) 0xff69 (Cancel)
232 0x1008ff03 (XF86MonBrightnessDown) 0x0000 (NoSymbol) 0x1008ff03 (XF86MonBrightnessDown)
233 0x1008ff02 (XF86MonBrightnessUp) 0x0000 (NoSymbol) 0x1008ff02 (XF86MonBrightnessUp)
234 0x1008ff32 (XF86AudioMedia) 0x0000 (NoSymbol) 0x1008ff32 (XF86AudioMedia)
235 0x1008ff59 (XF86Display) 0x0000 (NoSymbol) 0x1008ff59 (XF86Display)
236 0x1008ff04 (XF86KbdLightOnOff) 0x0000 (NoSymbol) 0x1008ff04 (XF86KbdLightOnOff)
237 0x1008ff06 (XF86KbdBrightnessDown) 0x0000 (NoSymbol) 0x1008ff06 (XF86KbdBrightnessDown)
238 0x1008ff05 (XF86KbdBrightnessUp) 0x0000 (NoSymbol) 0x1008ff05 (XF86KbdBrightnessUp)
239 0x1008ff7b (XF86Send) 0x0000 (NoSymbol) 0x1008ff7b (XF86Send)
240 0x1008ff72 (XF86Reply) 0x0000 (NoSymbol) 0x1008ff72 (XF86Reply)
241 0x1008ff90 (XF86MailForward) 0x0000 (NoSymbol) 0x1008ff90 (XF86MailForward)
242 0x1008ff77 (XF86Save) 0x0000 (NoSymbol) 0x1008ff77 (XF86Save)
243 0x1008ff5b (XF86Documents) 0x0000 (NoSymbol) 0x1008ff5b (XF86Documents)
244 0x1008ff93 (XF86Battery) 0x0000 (NoSymbol) 0x1008ff93 (XF86Battery)
245 0x1008ff94 (XF86Bluetooth) 0x0000 (NoSymbol) 0x1008ff94 (XF86Bluetooth)
246 0x1008ff95 (XF86WLAN) 0x0000 (NoSymbol) 0x1008ff95 (XF86WLAN)
247
248
249
250
251
*/
};
void XR_GetKeyboardMapping (xclient_t *cl, xReq *request)
{//fixme: send the XK equivelents.
xGetKeyboardMappingReq *req = (xGetKeyboardMappingReq *)request;
char buffer[8192];
xGetKeyboardMappingReply *rep = (xGetKeyboardMappingReply *)buffer;
int i, y, x;
int *syms = ((int *)(rep+1));
rep->type = X_Reply;
rep->keySymsPerKeyCode = countof(keyboardmapping[0].keysym);
rep->sequenceNumber = cl->requestnum;
rep->length = 0;
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
rep->pad6 = 0;
rep->pad7 = 0;
for (i = 0; i < req->count; i++)
{
y = req->firstKeyCode+i;
if (y >= countof(keyboardmapping))
break;
for (x = 0; x < rep->keySymsPerKeyCode; x++)
*syms++ = keyboardmapping[y].keysym[x];
}
rep->length = i*rep->keySymsPerKeyCode;
X_SendData(cl, rep, sizeof(*rep)+rep->length*4);
}
static struct
{
KEYCODE keysym[8];
} modifiermapping[] =
{ //these are scancodes
{{0x32, 0x32}},
{{0x42}},
{{0x24, 0x69}},
{{0x40, 0xcd}},
{{0x4d}},
{{0}},
{{0x85, 0x86, 0xce, 0xcf}},
{{0x5c, 0xcb}},
};
void XR_GetModifierMapping (xclient_t *cl, xReq *request)
{//fixme: send the XK equivelents.
// xReq *req = (xReq *)request;
char buffer[8192];
xGetModifierMappingReply *rep = (xGetModifierMappingReply *)buffer;
int x, y;
KEYCODE *syms = ((KEYCODE *)(rep+1));
rep->type = X_Reply;
rep->numKeyPerModifier = countof(modifiermapping[0].keysym);
rep->sequenceNumber = cl->requestnum;
rep->length = (8*rep->numKeyPerModifier * sizeof(KEYCODE) + 3)/4;
rep->pad2 = 0;
rep->pad3 = 0;
rep->pad4 = 0;
rep->pad5 = 0;
rep->pad6 = 0;
for (y = 0; y < countof(modifiermapping); y++)
{
for (x = 0; x < rep->numKeyPerModifier; x++)
{
*syms++ = modifiermapping[y].keysym[x];
}
}
X_SendData(cl, rep, sizeof(*rep)+rep->length*4);
}
void XR_QueryPointer (xclient_t *cl, xReq *request)
{
extern int x_mousex, x_mousey, x_mousestate;
xQueryPointerReply rep;
rep.type = X_Reply;
rep.sameScreen = 1;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.root = rootwindow->res.id;
rep.child = rootwindow->res.id;
rep.rootX = x_mousex;
rep.rootY = x_mousey;
rep.winX = x_mousex;
rep.winY = x_mousey;
rep.mask = 0;
rep.pad1 = 0;
rep.pad = 0;
if ((x_mousestate) & Button1Mask)
rep.mask |= Button1MotionMask;
if ((x_mousestate) & Button2Mask)
rep.mask |= Button2MotionMask;
if ((x_mousestate) & Button3Mask)
rep.mask |= Button3MotionMask;
if ((x_mousestate) & Button4Mask)
rep.mask |= Button4MotionMask;
if ((x_mousestate) & Button5Mask)
rep.mask |= Button5MotionMask;
X_SendData(cl, &rep, sizeof(rep));
}
void XR_CreateCursor (xclient_t *cl, xReq *request)
{
// xCreateCursorReq *req = (xCreateCursorReq *)request;
// X_SendError(cl, BadImplementation, 0, req->reqType, 0);
}
void XR_CreateGlyphCursor (xclient_t *cl, xReq *request)
{
// xCreateGlyphCursorReq *req = (xCreateGlyphCursorReq *)request;
// char buffer[8192];
// xGetKeyboardMappingReply *rep = (xGetKeyboardMappingReply *)buffer;
// X_SendError(cl, BadImplementation, 0, req->reqType, 0);
// X_SendError(cl, BadAlloc, req->id, X_DestroyWindow, 0);
// X_SendError(cl, BadFont, req->id, X_DestroyWindow, 0);
// X_SendError(cl, BadValue, req->id, X_DestroyWindow, 0);
}
void XR_FreeCursor (xclient_t *cl, xReq *request)
{
// X_SendError(cl, BadImplementation, 0, req->reqType, 0);
// X_SendError(cl, BadValue, req->id, X_DestroyWindow, 0);
}
void XR_RecolorCursor (xclient_t *cl, xReq *request)
{
}
void XR_GrabButton (xclient_t *cl, xReq *request)
{
}
void XR_UngrabButton (xclient_t *cl, xReq *request)
{
}
void XR_ChangeGCInternal(unsigned int mask, xgcontext_t *gc, CARD32 *param)
{
if (mask & GCFunction)
gc->function = *param++;
if (mask & GCPlaneMask)
param++;
if (mask & GCForeground)
gc->fgcolour = *param++;
if (mask & GCBackground)
gc->bgcolour = *param++;
if (mask & GCLineWidth)
param++;
if (mask & GCLineStyle)
param++;
if (mask & GCCapStyle)
param++;
if (mask & GCJoinStyle)
param++;
if (mask & GCFillStyle)
param++;
if (mask & GCFillRule)
param++;
if (mask & GCTile)
param++;
if (mask & GCStipple)
param++;
if (mask & GCTileStipXOrigin)
param++;
if (mask & GCTileStipYOrigin)
param++;
if (mask & GCFont)
{
void *font = NULL;
if (XS_GetResource(*param++, &font) != x_font)
font = NULL;
gc->font = font;
}
if (mask & GCSubwindowMode)
param++;
if (mask & GCGraphicsExposures)
param++;
if (mask & GCClipXOrigin)
param++;
if (mask & GCClipYOrigin)
param++;
if (mask & GCClipMask)
param++;
if (mask & GCDashOffset)
param++;
if (mask & GCDashList)
param++;
if (mask & GCArcMode)
param++;
}
void XR_CopyGCInternal(unsigned int mask, xgcontext_t *dest, xgcontext_t *src)
{
int param=0;
if (mask & GCFunction)
dest->function = src->function;
if (mask & GCPlaneMask)
param++;
if (mask & GCForeground)
dest->fgcolour = src->fgcolour;
if (mask & GCBackground)
dest->bgcolour = src->fgcolour;
if (mask & GCLineWidth)
param++;
if (mask & GCLineStyle)
param++;
if (mask & GCCapStyle)
param++;
if (mask & GCJoinStyle)
param++;
if (mask & GCFillStyle)
param++;
if (mask & GCFillRule)
param++;
if (mask & GCTile)
param++;
if (mask & GCStipple)
param++;
if (mask & GCTileStipXOrigin)
param++;
if (mask & GCTileStipYOrigin)
param++;
if (mask & GCFont)
{
dest->font = src->font;
}
if (mask & GCSubwindowMode)
param++;
if (mask & GCGraphicsExposures)
param++;
if (mask & GCClipXOrigin)
param++;
if (mask & GCClipYOrigin)
param++;
if (mask & GCClipMask)
param++;
if (mask & GCDashOffset)
param++;
if (mask & GCDashList)
param++;
if (mask & GCArcMode)
param++;
}
void XR_ChangeGC(xclient_t *cl, xReq *request)
{
xChangeGCReq *req = (xChangeGCReq *)request;
xgcontext_t *gc;
if (XS_GetResource(req->gc, (void**)&gc) != x_gcontext)
{
X_SendError(cl, BadGC, req->gc, X_FreeGC, 0);
return;
}
XR_ChangeGCInternal(req->mask, gc, (CARD32 *)(req + 1));
}
void XR_CopyGC(xclient_t *cl, xReq *request)
{
xCopyGCReq *req = (xCopyGCReq *)request;
xgcontext_t *dest, *src;
if (XS_GetResource(req->dstGC, (void**)&dest) != x_gcontext)
{
X_SendError(cl, BadGC, req->dstGC, X_FreeGC, 0);
return;
}
if (XS_GetResource(req->srcGC, (void**)&src) != x_gcontext)
{
X_SendError(cl, BadGC, req->srcGC, X_FreeGC, 0);
return;
}
XR_CopyGCInternal(req->mask, dest, src);
}
void XR_CreateGC(xclient_t *cl, xReq *request)
{
xCreateGCReq *req = (xCreateGCReq *)request;
xresource_t *drawable;
if (XS_GetResource(req->gc, (void**)&drawable) != x_none)
{
// if (req->gc == cl->ridbase&&drawable->owner)
// XS_DestroyResourcesOfClient(drawable->owner);
// else
{
X_SendError(cl, BadIDChoice, req->gc, X_CreateGC, 0);
return;
}
}
XS_GetResource(req->drawable, (void**)&drawable);
/*if (drawable->restype != x_window && drawable->restype != x_gcontext)
{
X_SendError(cl, BadDrawable, req->drawable, X_CreateGC, 0);
return;
}*/
XR_ChangeGCInternal(req->mask, XS_CreateGContext(req->gc, cl, drawable), (CARD32 *)(req + 1));
}
void XR_FreeGC(xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xresource_t *gc;
if (XS_GetResource(req->id, (void**)&gc) != x_gcontext)
{
X_SendError(cl, BadGC, req->id, X_FreeGC, 0);
return;
}
XS_DestroyResource(gc);
}
void XW_ClearArea(xwindow_t *wnd, int xp, int yp, int width, int height)
{
if (!wnd->buffer)
{
if (wnd->width*wnd->height<=0)
wnd->buffer = malloc(1);
else
wnd->buffer = malloc(wnd->width*wnd->height*4);
}
if (xp < 0)
{
width += xp;
xp = 0;
}
if (xp>wnd->width)
xp = wnd->width;
if (yp < 0)
{
height += yp;
xp = 0;
}
if (yp>wnd->height)
yp = wnd->height;
if (width+xp > wnd->width)
width = wnd->width - xp;
if (height+yp > wnd->height)
height = wnd->height - yp;
if (wnd->backpixmap && wnd->backpixmap->width && wnd->backpixmap->height)
{
int x, xs;
int y, ys;
unsigned int *out;
unsigned int *in;
out = (unsigned int *)wnd->buffer + xp +yp*wnd->width;
in = (unsigned int *)wnd->backpixmap->data;
for (y = 0, ys = 0; y < height; y++)
{
for (x = 0; x < width; x+=wnd->backpixmap->width)
{
//when do we stop?
xs = wnd->backpixmap->width;
if (xs > wnd->width-x-1)
xs = wnd->width-x-1;
for (; xs > 0; xs--)
{
out[x+xs] = in[xs+ys*wnd->backpixmap->width];
}
}
out += wnd->width;
ys++;
if (ys >= wnd->backpixmap->height)
ys = 0;
}
}
else
{
int x;
int y;
unsigned int *out;
out = (unsigned int *)wnd->buffer + xp +yp*wnd->width;
for (y = yp; y < height; y++)
{
for (x = xp; x < width; x++)
{
out[x] = wnd->backpixel;
}
out+=wnd->width;
}
}
}
void XW_CopyArea(unsigned int *dest, int dx, int dy, int dwidth, int dheight, unsigned int *source, int sx, int sy, int swidth, int sheight, int cwidth, int cheight, xgcontext_t *gc)
{
int x, y;
//tlcap on dest
if (dx < 0)
{
cwidth += dx;
dx = 0;
}
if (dy < 0)
{
cheight += dy;
dy = 0;
}
//tlcap on source
if (sx < 0)
{
cwidth += sx;
sx = 0;
}
if (sy < 0)
{
cheight += sy;
sy = 0;
}
//brcap on dest
if (cwidth > dwidth - dx)
cwidth = dwidth - dx;
if (cheight > dheight - dy)
cheight = dheight - dy;
//brcap on source
if (cwidth > swidth - sx)
cwidth = swidth - sx;
if (cheight > sheight - sy)
cheight = sheight - sy;
if (cwidth<=0)
return;
if (cheight<=0)
return;
dest += dx+dy*dwidth;
source += sx+sy*swidth;
for (y = 0; y < cheight; y++)
{
for (x = 0; x < cwidth;x++)
{
GCFunc(gc->fgcolour, dest[x], gc->function, source[x], 0xffffff);
}
dest += dwidth;
source += swidth;
}
}
void XR_ClearArea(xclient_t *cl, xReq *request)
{//FIXME: Should be area rather than entire window
xClearAreaReq *req = (xClearAreaReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->window, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->window, X_ClearArea, 0);
return;
}
if (req->x < 0)
{
if (req->width)
req->width += req->x;
req->x = 0;
}
if (req->y < 0)
{
if (req->height)
req->height += req->y;
req->y = 0;
}
if (!req->width || req->width + req->x > wnd->width)
{
if (req->width)
req->width = wnd->width - req->x;
req->width = wnd->width - req->x;
}
if (!req->height || req->height + req->y > wnd->height)
{
if (req->height)
req->height = wnd->height - req->y;
req->height = wnd->height - req->y;
}
XW_ClearArea(wnd, req->x, req->y, req->width, req->height);
if (req->exposures)
XW_ExposeWindowRegionInternal(wnd, req->x, req->y, req->width, req->height);
xrefreshed=true;
}
void XR_CopyArea(xclient_t *cl, xReq *request) //from and to pixmap or drawable.
{
xCopyAreaReq *req = (xCopyAreaReq *)request;
xresource_t *drawable;
xgcontext_t *gc;
unsigned int *outbuffer;
unsigned int *inbuffer;
int inwidth;
int inheight;
int outwidth;
int outheight;
if (XS_GetResource(req->gc, (void**)&gc) == x_none)
{
X_SendError(cl, BadGC, req->gc, X_CopyArea, 0);
return;
}
switch (XS_GetResource(req->srcDrawable, (void**)&drawable))
{
default:
X_SendError(cl, BadDrawable, req->srcDrawable, X_CopyArea, 0);
return;
case x_window:
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
inwidth = wnd->width;
inheight = wnd->height;
inbuffer = (unsigned int *)wnd->buffer;
}
break;
case x_pixmap:
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
inwidth = pm->width;
inheight = pm->height;
inbuffer = (unsigned int *)pm->data;
}
break;
}
switch (XS_GetResource(req->dstDrawable, (void**)&drawable))
{
default:
X_SendError(cl, BadDrawable, req->dstDrawable, X_CopyArea, 0);
return;
case x_window:
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
outwidth = wnd->width;
outheight = wnd->height;
outbuffer = (unsigned int *)wnd->buffer;
}
break;
case x_pixmap:
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
outwidth = pm->width;
outheight = pm->height;
outbuffer = (unsigned int *)pm->data;
}
break;
}
XW_CopyArea(outbuffer, req->dstX, req->dstY, outwidth, outheight, inbuffer, req->srcX, req->srcY, inwidth, inheight, req->width, req->height, gc);
xrefreshed=true;
}
void XR_MapWindow(xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_MapWindow, 0);
return;
}
// if (wnd->mapped)
// return;
if (!wnd->overrideredirect && X_NotifcationMaskPresent(wnd, SubstructureRedirectMask, cl))
{
xEvent ev;
ev.u.u.type = MapRequest;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.mapRequest.parent = wnd->parent->res.id;
ev.u.mapRequest.window = wnd->res.id;
X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask);
return;
}
if (!wnd->buffer)
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
wnd->mapped = true;
{
xEvent ev;
ev.u.u.type = MapNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.mapNotify.event = wnd->res.id;
ev.u.mapNotify.window = wnd->res.id;
ev.u.mapNotify.override = wnd->overrideredirect;
ev.u.mapNotify.pad1 = 0;
ev.u.mapNotify.pad2 = 0;
ev.u.mapNotify.pad3 = 0;
X_SendNotificationMasked(&ev, wnd, StructureNotifyMask);
X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask);
}
/* {
xEvent ev;
ev.u.u.type = GraphicsExpose;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.mapNotify.window = wnd->res.id;
ev.u.mapNotify.override = false;
ev.u.mapNotify.pad1 = 0;
ev.u.mapNotify.pad2 = 0;
ev.u.mapNotify.pad3 = 0;
X_SendNotificationMasked(&ev, wnd, ExposureMask);
}*/
XW_ExposeWindowRegionInternal(wnd, 0, 0, wnd->width, wnd->height);
/*
while(wnd->mapped)
{
xEvent ev;
ev.u.u.type = VisibilityNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.visibility.window = wnd->res.id;
ev.u.visibility.state = 0;
ev.u.visibility.pad1 = 0;
ev.u.visibility.pad2 = 0;
ev.u.visibility.pad3 = 0;
X_SendNotificationMasked(&ev, wnd, VisibilityChangeMask);
}
{
xEvent ev;
ev.u.u.type = Expose;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.expose.window = wnd->res.id;
ev.u.expose.x = 0;
ev.u.expose.y = 0;
ev.u.expose.width = wnd->width;
ev.u.expose.height = wnd->height;
ev.u.expose.count = false; //other expose events following
ev.u.expose.pad2 = 0;
X_SendNotificationMasked(&ev, wnd, ExposureMask);
}*/
xrefreshed = true;
}
void XR_UnmapWindow(xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_UnmapWindow, 0);
return;
}
if (!wnd->mapped || !wnd->parent)
return;
wnd->mapped = false;
xrefreshed=true;
XW_ExposeWindow(wnd, 0, 0, wnd->width, wnd->height);
{
xEvent ev;
ev.u.u.type = UnmapNotify;
ev.u.u.detail = 0;
ev.u.u.sequenceNumber = 0;
ev.u.unmapNotify.event = wnd->res.id;
ev.u.unmapNotify.window = wnd->res.id;
ev.u.unmapNotify.fromConfigure = 0;
ev.u.unmapNotify.pad1 = 0;
ev.u.unmapNotify.pad2 = 0;
ev.u.unmapNotify.pad3 = 0;
X_SendNotificationMasked(&ev, wnd, StructureNotifyMask);
X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask);
}
}
void XR_MapSubwindows(xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xwindow_t *wnd;
if (XS_GetResource(req->id, (void**)&wnd) != x_window)
{
X_SendError(cl, BadWindow, req->id, X_MapWindow, 0);
return;
}
for (wnd = wnd->child; wnd; wnd = wnd->sibling)
{
req->id = wnd->res.id;
XR_MapWindow(cl, request);
}
}
void XR_CreatePixmap(xclient_t *cl, xReq *request)
{
xCreatePixmapReq *req = (xCreatePixmapReq *)request;
xresource_t *res;
xpixmap_t *newpix;
switch(XS_GetResource(req->drawable, (void**)&res))
{
case x_window:
case x_pixmap:
break;
default:
X_SendError(cl, BadDrawable, req->drawable, X_CreatePixmap, 0);
return;
}
//depth must be one of the depths supported by the drawable's root window
if (req->depth != 24 && req->depth != 32)
{
// X_SendError(cl, BadValue, req->depth, X_CreatePixmap, 0);
// return;
}
if (XS_GetResource(req->pid, (void**)&newpix) != x_none)
{
X_SendError(cl, BadIDChoice, req->pid, X_CreatePixmap, 0);
}
XS_CreatePixmap(req->pid, cl, req->width, req->height, req->depth);
}
void XR_FreePixmap(xclient_t *cl, xReq *request)
{
xResourceReq *req = (xResourceReq *)request;
xresource_t *pm;
if (XS_GetResource(req->id, (void**)&pm) != x_pixmap)
{
X_SendError(cl, BadPixmap, req->id, X_FreePixmap, 0);
return;
}
XS_DestroyResource(pm);
}
void XR_PutImage(xclient_t *cl, xReq *request)
{
unsigned char *out;
unsigned char *in;
xPutImageReq *req = (xPutImageReq *)request;
xresource_t *drawable;
xgcontext_t *gc;
int i;
int drwidth;
int drheight;
int drdepth;
unsigned char *drbuffer;
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) == x_none)
{
X_SendError(cl, BadGC, req->gc, X_PutImage, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
drdepth = wnd->depth;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
drdepth = pm->depth;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0);
return;
}
xrefreshed = true;
if (req->dstX < 0)
{
req->width += req->dstX;
req->dstX = 0;
}
if (req->dstY < 0)
{
req->height += req->dstY;
req->dstY = 0;
}
if (req->width > drwidth - req->dstX)
req->width = drwidth - req->dstX;
if (req->height > drheight - req->dstY)
req->height = drheight - req->dstY;
in = (qbyte *)(req+1);
//my own bugs...
if (req->leftPad != 0)
{
X_SendError(cl, BadImplementation, req->drawable, X_PutImage, req->format);
return;
}
if (req->format == XYBitmap)
{ //bitmaps are just a 'mask' specifying which pixels get foreground and which get background.
int bnum;
unsigned int *o4;
bnum=0;
if (req->depth == 1)
{
while(req->height)
{
bnum += req->leftPad;
out = drbuffer + (req->dstX + req->dstY*drwidth)*4;
o4 = (unsigned int*)out;
for (i = 0; i < req->width; i++)
{
if (in[bnum>>8]&(1<<(bnum&7)))
o4[i] = gc->fgcolour;
else
o4[i] = gc->bgcolour;
bnum++;
}
bnum += req->width;
req->height--;
req->dstY++;
}
}
else
X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0);
}
else if (req->depth != drdepth) /*depth must match*/
{
X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0);
}
else if (req->format == ZPixmap) //32 bit network bandwidth (hideous)
{
if (req->leftPad != 0)
{
X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0);
return;
}
if (req->depth == 1)
{
unsigned int *o4;
int bnum = 0;
while(req->height)
{
out = drbuffer + (req->dstX + req->dstY*drwidth)*4;
o4 = (unsigned int*)out;
for (i = 0; i < req->width; i++, bnum++)
{
if (in[bnum>>8]&(1<<(bnum&7)))
o4[i] = 0xffffff;
else
o4[i] = 0;
}
req->height--;
req->dstY++;
}
}
else
{
while(req->height)
{
unsigned int *i4, *o4;
out = drbuffer + (req->dstX + req->dstY*drwidth)*4;
i4 = (unsigned int*)in;
o4 = (unsigned int*)out;
for (i = 0; i < req->width; i++)
{
o4[i] = i4[i];
}
/* for (i = 0; i < req->width; i++)
{
out[i*4+0] = in[i*4+0];
out[i*4+1] = in[i*4+1];
out[i*4+2] = in[i*4+2];
}
*/ in += req->width*4;
req->height--;
req->dstY++;
}
}
}
else if (req->format == XYPixmap)
{
while(req->height)
{
unsigned int *o4;
out = drbuffer + (req->dstX + req->dstY*drwidth)*4;
o4 = (unsigned int*)out;
for (i = 0; i < req->width; i++)
{
if (in[i>>3] & (1u<<(i&7)))
o4[i] = rand();
else
o4[i] = rand();
}
in += (req->width+7)/8;
req->height--;
req->dstY++;
}
}
else
{
X_SendError(cl, BadImplementation, req->drawable, X_PutImage, req->format);
}
}
void XR_GetImage(xclient_t *cl, xReq *request)
{
unsigned char *out, *data;
unsigned char *in;
xGetImageReq *req = (xGetImageReq *)request;
xresource_t *drawable;
xGetImageReply rep;
int drwidth;
int drheight;
unsigned char *drbuffer;
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_GetImage, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
rep.visual = 0x22;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
rep.visual = 0;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_GetImage, 0);
return;
}
if (req->x < 0)
{
X_SendError(cl, BadValue, req->drawable, X_GetImage, 0);
return;
}
if (req->y < 0)
{
X_SendError(cl, BadValue, req->drawable, X_GetImage, 0);
return;
}
if (req->width > drwidth - req->x)
{
X_SendError(cl, BadValue, req->drawable, X_GetImage, 0);
return;
}
if (req->height > drheight - req->y)
{
X_SendError(cl, BadValue, req->drawable, X_GetImage, 0);
return;
}
data = out = alloca(req->width*4*req->height);
if (req->format == 2) //32 bit network bandwidth (hideous)
{
while(req->height)
{
in = drbuffer + (req->x + req->y*drwidth)*4;
#if 1
memcpy(out, in, req->width*4);
#else
for (i = 0; i < req->width; i++)
{
out[i*4+0] = in[i*4+0];
out[i*4+1] = in[i*4+1];
out[i*4+2] = in[i*4+2];
}
#endif
out += req->width*4;
req->height--;
req->y++;
}
}
else
{
X_SendError(cl, BadImplementation, req->drawable, X_GetImage, req->format);
return;
}
rep.type = X_Reply;
rep.sequenceNumber = cl->requestnum;
rep.length = (out-data+3)/4;
rep.depth = 24;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
rep.pad6 = 0;
rep.pad7 = 0;
X_SendData(cl, &rep, sizeof(rep));
X_SendData(cl, data, rep.length*4);
}
void XW_PolyLine(unsigned int *dbuffer, int dwidth, int dheight, int x1, int x2, int y1, int y2, xgcontext_t *gc)
{
//FIXME: cap to region.
int len;
int dx, dy;
if (x1 < 0)
return;
if (x2 < 0)
return;
if (y1 < 0)
return;
if (y2 < 0)
return;
if (x1 >= dwidth)
x1 = dwidth-1;
if (x2 >= dwidth)
x2 = dwidth-1;
if (y1 >= dheight)
y1 = dheight-1;
if (y2 >= dheight)
y2 = dheight-1;
dx = (x2 - x1);
dy = (y2 - y1);
len = (int)sqrt(dx*dx+dy*dy);
if (!len)
return;
x1<<=16;
y1<<=16;
dx=(dx<<16)/len;
dy=(dy<<16)/len;
for (; len ; len--)
{
GCFunc(gc->fgcolour, dbuffer[(x1>>16)+dwidth*(y1>>16)], gc->function, dbuffer[(x1>>16)+dwidth*(y1>>16)], 0xffffff);
x1+=dx;
y1+=dy;
}
}
void XR_PolyLine(xclient_t *cl, xReq *request)
{
xPolyLineReq *req = (xPolyLineReq *)request;
xresource_t *drawable;
xgcontext_t *gc;
int pointsleft;
int drwidth;
int drheight;
unsigned char *drbuffer;
INT16 start[2], end[2];
INT16 *points;
points = (INT16 *)(req+1);
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) == x_none)
{
X_SendError(cl, BadGC, req->gc, X_PolyRectangle, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
xrefreshed = true;
if (req->reqType == X_PolySegment)
{
for (pointsleft = req->length/2-3; pointsleft>0; pointsleft--)
{
XW_PolyLine((unsigned int *)drbuffer, drwidth, drheight, points[0], points[2], points[1], points[3], gc);
points+=4;
}
}
else
{
end[0] = 0;
end[1] = 0;
for (pointsleft = req->length-3; pointsleft>0; pointsleft-=2)
{
if (req->coordMode == 1/*Previous*/)
{
start[0] = end[0] + points[0];
start[1] = end[1] + points[1];
end[0] = start[0] + points[2];
end[1] = start[1] + points[3];
}
else
{
start[0] = points[0];
start[1] = points[1];
end[0] = points[2];
end[1] = points[3];
}
XW_PolyLine((unsigned int *)drbuffer, drwidth, drheight, start[0], end[0], start[1], end[1], gc);
points+=4;
}
}
}
void XR_FillPoly(xclient_t *cl, xReq *request)
{
xFillPolyReq *req = (xFillPolyReq *)request;
INT16 *points = (INT16*)(req+1);
int numpoints = req->length-4;
xresource_t *drawable;
xgcontext_t *gc;
int drwidth;
int drheight;
unsigned char *drbuffer;
INT16 start[2], end[2];
points = (INT16 *)(req+1);
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) == x_none)
{
X_SendError(cl, BadGC, req->gc, X_PolyRectangle, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
xrefreshed = true;
{
start[0] = points[(numpoints*2)-2];
start[1] = points[(numpoints*2)-1];
while (numpoints-->0)
{
if (req->coordMode == 1/*Previous*/)
{
end[0] = start[0] + points[0];
end[1] = start[1] + points[1];
}
else
{
end[0] = points[0];
end[1] = points[1];
}
points+=2;
(void)drbuffer, (void)drwidth, (void)drheight;
// XW_PolyLine((unsigned int *)drbuffer, drwidth, drheight, start[0], start[1], end[0], end[1], gc);
points++;
start[0] = end[0];
start[1] = end[1];
}
}
}
void XR_PolyRectangle(xclient_t *cl, xReq *request)
{
unsigned int *out;
xPolyRectangleReq *req = (xPolyRectangleReq *)request;
xresource_t *drawable;
xgcontext_t *gc;
int i;
short *rect;
int rectnum;
int drwidth;
int drheight;
unsigned char *drbuffer;
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) == x_none)
{
X_SendError(cl, BadGC, req->gc, X_PolyRectangle, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0);
return;
}
xrefreshed = true;
rect = (short *)(req+1);
for (rectnum = req->length/2 - 1; rectnum>0; rectnum--)
{
// Con_Printf("polyrect %i %i %i %i %i\n", req->drawable, rect[0], rect[1], rect[2], rect[3]);
if (rect[2] < 0)
{
rect[2] *= -1;
}
if (rect[3] < 0)
{
rect[3] *= -1;
}
if (rect[0] < 0)
{
rect[2] += rect[0];
rect[0] = 0;
}
if (rect[0] >= drwidth)
rect[0] = drwidth-1;
if (rect[1] < 0)
{
rect[3] += rect[1];
rect[1] = 0;
}
if (rect[1] >= drheight)
rect[1] = drheight-1;
if (rect[0] + rect[2] > drwidth)
rect[2] = drwidth - rect[0];
if (rect[1] + rect[3] > drheight)
rect[3] = drheight - rect[1];
if (request->reqType == X_PolyFillRectangle) //fill
{
while(rect[3])
{
out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth);
for (i = 0; i < rect[2]; i++)
{
GCFunc(gc->fgcolour, *(char *)&out[i], gc->function, *(char *)&out[i], 0xff);
}
rect[3]--;
rect[1]++;
}
}
else //outline
{
//top
out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth);
for (i = 1; i < rect[2]-1; i++)
{
GCFunc(gc->fgcolour, out[i], gc->function, out[i], 0xffffff);
}
//bottom
if (rect[3]-1)
{
out = (unsigned int *)drbuffer + (rect[0] + (rect[1]+rect[3]-1)*drwidth);
for (i = 1; i < rect[2]-1; i++)
{
GCFunc(gc->fgcolour, out[i], gc->function, out[i], 0xffffff);
}
}
//left
out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth);
for (i = 0; i < rect[3]; i++)
{
GCFunc(gc->fgcolour, out[i*drwidth], gc->function, out[i*drwidth], 0xffffff);
}
//right
if (rect[2]-1)
{
out = (unsigned int *)drbuffer + (rect[0]+rect[2]-1 + rect[1]*drwidth);
for (i = 0; i < rect[3]; i++)
{
GCFunc(gc->fgcolour, out[i*drwidth], gc->function, out[i*drwidth], 0xffffff);
}
}
}
rect+=4;
}
}
void XR_PolyPoint(xclient_t *cl, xReq *request)
{
xPolyPointReq *req = (xPolyPointReq *)request;
unsigned int *out;
xresource_t *drawable;
xgcontext_t *gc;
short *point;
int pointnum;
int drwidth;
int drheight;
unsigned char *drbuffer;
short lastpoint[2];
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyPoint, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) != x_gcontext)
{
X_SendError(cl, BadGC, req->gc, X_PolyPoint, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, X_PolyPoint, 0);
return;
}
point = (short*)(req+1);
if (req->coordMode) //relative
{
lastpoint[0] = 0; //do the absolute stuff
lastpoint[1] = 0;
for (pointnum = 1; pointnum>0; pointnum--)
{
lastpoint[0] += point[0]; //do the absolute stuff
lastpoint[1] += point[1];
out = (unsigned int *)drbuffer + lastpoint[0] + lastpoint[1]*drwidth;
GCFunc(gc->fgcolour, *out, gc->function, *out, 0xffffff);
point+=2;
}
}
else //absolute
{
for (pointnum = req->length-1; pointnum>0; pointnum--)
{
if (!(point[0] < 0 || point[1] < 0 || point[0] >= drwidth || point[1] >= drheight))
{
out = (unsigned int *)drbuffer + point[0] + point[1]*drwidth;
GCFunc(gc->fgcolour, *out, gc->function, *out, 0xffffff);
}
point+=2;
}
}
}
void Draw_CharToDrawable (int num, unsigned int *drawable, int x, int y, int width, int height, xgcontext_t *gc)
{
int row, col;
unsigned int *source;
int drawline;
int i;
int s, e;
xfont_t *font;
font = gc->font;
if (!font || font->res.restype != x_font)
return;
s = 0;
e = font->charwidth;
if (x<0)
s = s - x;
if (x > width - e)
e = width - x;
if (s > e)
return;
// if (y >= height-e)
// return;
// if (y < -font->charheight)
// return;
if (y <= 0)
drawable += x;
else
drawable += (width*y) + x;
row = num>>4;
col = num&15;
source = font->data + (row*font->rowwidth*font->charheight) + (col*font->charwidth);
if (y < 0)
source -= font->rowwidth*y;
drawline = height-y;
if (drawline > font->charheight)
drawline = font->charheight;
if (y < 0)
drawline += y;
while (drawline-->=0)
{
for (i=s ; i<e ; i++)
if (((qbyte*)(&source[i]))[3] > 128 && source[i])
// GCFunc(gc->fgcolour, drawable[i], gc->function, drawable[i], source[i]);
drawable[i] = source[i];
source += font->rowwidth;
drawable += width;
}
}
void XR_PolyText(xclient_t *cl, xReq *request)
{
unsigned char *str;
xPolyTextReq *req = (xPolyTextReq*)request;
xresource_t *drawable;
xgcontext_t *gc;
int drwidth;
int drheight;
unsigned char *drbuffer;
short charnum;
short numchars;
int xpos, ypos;
if (XS_GetResource(req->drawable, (void**)&drawable) == x_none)
{
X_SendError(cl, BadDrawable, req->drawable, req->reqType, 0);
return;
}
if (XS_GetResource(req->gc, (void**)&gc) != x_gcontext)
{
X_SendError(cl, BadGC, req->gc, req->reqType, 0);
return;
}
if (!gc->font)
{
X_SendError(cl, BadGC, req->gc, req->reqType, 0);
return;
}
if (drawable->restype == x_window)
{
xwindow_t *wnd;
wnd = (xwindow_t *)drawable;
if (!wnd->buffer)
{
wnd->buffer = malloc(wnd->width*wnd->height*4);
XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height);
}
drwidth = wnd->width;
drheight = wnd->height;
drbuffer = wnd->buffer;
}
else if (drawable->restype == x_pixmap)
{
xpixmap_t *pm;
pm = (xpixmap_t *)drawable;
if (!pm->data)
{
pm->data = malloc(pm->width*pm->height*4);
memset(pm->data, rand(), pm->width*pm->height*4);
}
drwidth = pm->width;
drheight = pm->height;
drbuffer = pm->data;
}
else
{
X_SendError(cl, BadDrawable, req->drawable, req->reqType, 0);
return;
}
xrefreshed = true;
xpos = req->x;
ypos = req->y-gc->font->charheight/2;
str = (char*)(req+1);
if (req->reqType == X_ImageText16 || req->reqType == X_ImageText8)
{
while(1)
{
charnum = 0;
charnum |= *str++;
if (req->reqType == X_ImageText16)
charnum |= (*str++)<<8;
if (!charnum)
return;
Draw_CharToDrawable(charnum&255, (unsigned int *)drbuffer, xpos, ypos, drwidth, drheight, gc);
xpos += gc->font->charwidth;
}
}
else
{
numchars = *(short*) str;
str+=2;
while(1)
{
charnum = 0;
if (req->reqType == X_PolyText16)
charnum |= (*str++)<<8;
charnum |= *str++;
if (!numchars--)
return;
Draw_CharToDrawable(charnum, (unsigned int *)drbuffer, xpos, ypos, drwidth, drheight, gc);
xpos += gc->font->charwidth;
}
}
}
void XR_OpenFont(xclient_t *cl, xReq *request) //basically ignored. We only support one font...
{
xOpenFontReq *req = (xOpenFontReq *)request;
char *name;
name = (char *)(req+1);
XS_CreateFont(req->fid, cl, name);
}
void XR_CloseFont(xclient_t *cl, xReq *request) //basically ignored. We only support one font...
{
xResourceReq *req = (xResourceReq *)request;
void *font = XS_GetResourceType(req->id, x_font);
if (font)
XS_DestroyResource(font);
}
void XR_ListFonts(xclient_t *cl, xReq *request) //basically ignored. We only support one font...
{
// xListFontsReq *req = (xListFontsReq *)request;
int buffer[256];
xListFontsReply *reply = (xListFontsReply *)buffer;
reply->type = X_Reply;
reply->sequenceNumber = cl->requestnum;
reply->length = 0;
reply->nFonts = 0;
X_SendData(cl, reply, sizeof(xGenericReply)+reply->length*4);
}
void XR_QueryFont(xclient_t *cl, xReq *request) //basically ignored. We only support one font...
{
xResourceReq *req = (xResourceReq *)request;
char buffer[8192];
int i;
xCharInfo *ci;
xQueryFontReply *rep = (xQueryFontReply *)buffer;
xfont_t *font = XS_GetResourceType(req->id, x_font);
if (!font)
{
X_SendError(cl, BadFont, req->id, req->reqType, 0);
return;
}
rep->type = X_Reply;
rep->pad1 = 0;
rep->sequenceNumber = cl->requestnum;
rep->length = 0; /* definitely > 0, even if "nCharInfos" is 0 */
rep->minBounds.leftSideBearing = 0;
rep->minBounds.rightSideBearing = 0;
rep->minBounds.characterWidth = font->charwidth;
rep->minBounds.ascent = font->charheight/2;
rep->minBounds.descent = font->charheight/2;
rep->minBounds.attributes = 0;
#ifndef WORD64
rep->walign1 = 0;
#endif
rep->maxBounds.leftSideBearing = 0;
rep->maxBounds.rightSideBearing = 0;
rep->maxBounds.characterWidth = font->charwidth;
rep->maxBounds.ascent = font->charheight/2;
rep->maxBounds.descent = font->charheight/2;
rep->maxBounds.attributes = 0;
#ifndef WORD64
rep->walign2 = 0;
#endif
rep->minCharOrByte2 = 0;
rep->maxCharOrByte2 = 0;
rep->defaultChar = 0;
rep->nFontProps = 0; /* followed by this many xFontProp structures */
rep->drawDirection = 0;
rep->minByte1 = 0;
rep->maxByte1 = 0;
rep->allCharsExist = 0;
rep->fontAscent = font->charheight/2;
rep->fontDescent = font->charheight/2;
rep->nCharInfos = 255; /* followed by this many xCharInfo structures */
rep->length = ((sizeof(xQueryFontReply) - sizeof(xGenericReply)) + rep->nFontProps*sizeof(xFontProp) + rep->nCharInfos*sizeof(xCharInfo))/4;
ci = (xCharInfo*)(rep+1);
for (i = 0; i < rep->nCharInfos; i++)
{
ci[i].leftSideBearing = 0;
ci[i].rightSideBearing = 0;
ci[i].characterWidth = font->charwidth;
ci[i].ascent = font->charheight/2;
ci[i].descent = font->charheight/2;
}
X_SendData(cl, rep, sizeof(xGenericReply)+rep->length*4);
}
//esentually just throw it back at them.
void XR_AllocColor(xclient_t *cl, xReq *request)
{
xAllocColorReq *req = (xAllocColorReq *)request;
xAllocColorReply rep;
unsigned char rgb[3] = {req->red>>8, req->green>>8, req->blue>>8};
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.red = req->red;
rep.green = req->green;
rep.blue = req->blue;
rep.pad2 = 0;
rep.pixel = (rgb[0]<<16) | (rgb[1]<<8) | (rgb[2]);
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
void XR_QueryColors(xclient_t *cl, xReq *request)
{
xQueryColorsReq *req = (xQueryColorsReq *)request;
xQueryColorsReply rep;
xrgb rgb[65536];
int n;
int *pixel = (int*)(req+1);
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.nColors = 0;
rep.pad2 = 0;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
rep.pad6 = 0;
rep.pad7 = 0;
for (n = 0; n < req->length - sizeof(*req)/4; n++)
{
rgb[n].red = ((pixel[n]>>16)&0xff)<<8;
rgb[n].green = ((pixel[n]>>8)&0xff)<<8;
rgb[n].blue = ((pixel[n]>>0)&0xff)<<8;
rgb[n].pad = 0;
}
rep.nColors = n;
rep.length = (sizeof(xrgb)*n+3)/4;
X_SendData(cl, &rep, sizeof(rep));
X_SendData(cl, rgb, rep.length*4);
}
void XR_LookupColor(xclient_t *cl, xReq *request)
{
typedef struct {
char *name;
float r, g, b;
} colour_t;
char colourname[256];
colour_t *c, colour[] = {
{"black", 0,0,0},
{"grey", 0.5f,0.5f,0.5f},
{"gray", 0.5f,0.5f,0.5f}, //wmaker uses this one. humour it.
{"gray90", 0.9f,0.9f,0.9f},
{"gray80", 0.8f,0.8f,0.8f},
{"gray70", 0.7f,0.7f,0.7f},
{"gray60", 0.6f,0.6f,0.6f},
{"gray50", 0.5f,0.5f,0.5f},
{"gray40", 0.4f,0.4f,0.4f},
{"gray30", 0.3f,0.3f,0.3f},
{"gray20", 0.2f,0.2f,0.2f},
{"gray10", 0.1f,0.1f,0.1f},
{"grey10", 0.1f,0.1f,0.1f},
{"white", 1,1,1},
{"red", 1,0,0},
{"green", 0,1,0},
{"blue", 0,0,1},
{"blue4", 0,0,0.4f},
{NULL}
};
xLookupColorReq *req = (xLookupColorReq *)request;
xLookupColorReply rep;
if (req->nbytes >= sizeof(colourname))
{
X_SendError(cl, BadName, 0, X_LookupColor, 0);
return;
}
memcpy(colourname, (char *)(req+1), req->nbytes);
colourname[req->nbytes] = '\0';
for (c = colour; c->name; c++)
{
if (!strcasecmp(c->name, colourname))
{
break;
}
}
if (!c->name)
{
X_SendError(cl, BadName, 0, X_LookupColor, 0);
return;
}
rep.type = X_Reply;
rep.pad1 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.exactRed = (unsigned short)(c->r*0xffffu);
rep.exactGreen = (unsigned short)(c->g*0xffffu);
rep.exactBlue = (unsigned short)(c->b*0xffffu);
rep.screenRed = rep.exactRed;
rep.screenGreen = rep.exactGreen;
rep.screenBlue = rep.exactBlue;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
//get's keyboard status stuff.
void XR_GetKeyboardControl(xclient_t *cl, xReq *request)
{
xGetKeyboardControlReply rep;
rep.type = X_Reply;
rep.globalAutoRepeat = false;
rep.sequenceNumber = cl->requestnum;
rep.length = 5;
rep.ledMask = 0;
rep.keyClickPercent = 0;
rep.bellPercent = 0;
rep.bellPitch = 0;
rep.bellDuration = 0;
rep.pad = 0;
memset(rep.map, 0, sizeof(rep.map)); //per key map
X_SendData(cl, &rep, sizeof(rep));
}
void XR_WarpPointer(xclient_t *cl, xReq *request)
{
// xWarpPointerReq *req = (xWarpPointerReq *)request;
// req->m
}
#ifdef XBigReqExtensionName
void XR_BigReq(xclient_t *cl, xReq *request)
{
xBigReqEnableReply rep;
rep.type = X_Reply;
rep.pad0 = 0;
rep.sequenceNumber = cl->requestnum;
rep.length = 0;
rep.max_request_size = 65535*1000;
rep.pad1 = 0;
rep.pad2 = 0;
rep.pad3 = 0;
rep.pad4 = 0;
rep.pad5 = 0;
X_SendData(cl, &rep, sizeof(rep));
}
#endif
#define MAXREQUESTSIZE 65535
//cl -> cl protocol
void XR_SendEvent (xclient_t *cl, xReq *request)
{
int count;
xSendEventReq *req = (xSendEventReq *)request;
xwindow_t *wnd = XS_GetResourceType(req->destination, x_window);
if (!wnd)
{
X_SendError(cl, BadWindow, req->destination, X_SendEvent, 0);
return;
}
if (!req->eventMask) //goes to owner.
{
req->event.u.u.sequenceNumber = cl->requestnum;
X_SendData(wnd->res.owner, &req->event, sizeof(req->event));
}
else
{
xnotificationmask_t *nm;
count = 0;
while(!count)
{
for (nm = wnd->notificationmask; nm; nm = nm->next)
{
if (!(nm->mask & req->eventMask))
continue;
cl = nm->client;
if (cl->stillinitialising)
continue;
count++;
if (cl->tobedropped)
continue;
if (cl->outbufferlen > MAXREQUESTSIZE*4)
{
cl->tobedropped = true;
continue;
}
req->event.u.u.sequenceNumber = cl->requestnum;
X_SendData(cl, &req->event, sizeof(xEvent));
}
if (req->propagate)
wnd = wnd->parent;
else
break;
}
}
}
void XR_GrabServer (xclient_t *cl, xReq *request)
{
xgrabbedclient = cl;
}
void XR_UngrabServer (xclient_t *cl, xReq *request)
{
xgrabbedclient = NULL;
}
xclient_t *xpointergrabclient;
xwindow_t *xpgrabbedwindow;
xwindow_t *xpconfinewindow;
unsigned int xpointergrabmask;
CARD32 xpointergrabcursor;
void XR_GrabPointer (xclient_t *cl, xReq *request)
{
xGrabPointerReq *req = (xGrabPointerReq *)request;
xGrabPointerReply reply;
reply.type = X_Reply;
reply.status = 0;
reply.sequenceNumber = cl->requestnum;
reply.length = 0;
reply.pad1 = 0;
reply.pad2 = 0;
reply.pad3 = 0;
reply.pad4 = 0;
reply.pad5 = 0;
reply.pad6 = 0;
if (xpointergrabclient && xpointergrabclient != cl)
{ //you can't have it.
// if (pointerstatus == Frozen)
// reply.status = GrabFrozen;
// else
reply.status = AlreadyGrabbed;
X_SendData(cl, &reply, sizeof(reply));
return;
}
xpointergrabclient = cl;
XS_GetResource(req->grabWindow, (void**)&xpgrabbedwindow);
XS_GetResource(req->confineTo, (void**)&xpconfinewindow);
xpointergrabmask = req->eventMask;
xpointergrabcursor = req->cursor;
// xpointergrabtime = req->time;
X_EvalutateCursorOwner(NotifyGrab);
reply.status = GrabSuccess;
X_SendData(cl, &reply, sizeof(reply));
}
void XR_ChangeActivePointerGrab (xclient_t *cl, xReq *request)
{
xChangeActivePointerGrabReq *req = (xChangeActivePointerGrabReq *)request;
if (xpointergrabclient != cl)
{ //its not yours to change
return;
}
xpointergrabmask = req->eventMask;
xpointergrabcursor = req->cursor;
// xpointergrabtime = req->time;
}
void XR_UngrabPointer (xclient_t *cl, xReq *request)
{
xpointergrabclient = NULL;
xpgrabbedwindow = NULL;
xpconfinewindow = NULL;
X_EvalutateCursorOwner(NotifyUngrab);
}
void XR_NoOperation (xclient_t *cl, xReq *request)
{
}
void X_InitRequests(void)
{
int ExtentionCode = X_NoOperation+1;
memset(XRequests, 0, sizeof(XRequests));
XRequests[X_QueryExtension] = XR_QueryExtension;
XRequests[X_ListExtensions] = XR_ListExtensions;
XRequests[X_SetCloseDownMode] = XR_SetCloseDownMode;
XRequests[X_GetProperty] = XR_GetProperty;
XRequests[X_ChangeProperty] = XR_ChangeProperty;
XRequests[X_DeleteProperty] = XR_DeleteProperty;
XRequests[X_ListProperties] = XR_ListProperties;
XRequests[X_SetInputFocus] = XR_SetInputFocus;
XRequests[X_GetInputFocus] = XR_GetInputFocus;
XRequests[X_QueryBestSize] = XR_QueryBestSize;
XRequests[X_CreateWindow] = XR_CreateWindow;
XRequests[X_DestroyWindow] = XR_DestroyWindow;
XRequests[X_QueryTree] = XR_QueryTree;
XRequests[X_ChangeWindowAttributes] = XR_ChangeWindowAttributes;
XRequests[X_GetWindowAttributes] = XR_GetWindowAttributes;
XRequests[X_CreateGC] = XR_CreateGC;
XRequests[X_ChangeGC] = XR_ChangeGC;
XRequests[X_CopyGC] = XR_CopyGC;
XRequests[X_FreeGC] = XR_FreeGC;
XRequests[X_CreatePixmap] = XR_CreatePixmap;
XRequests[X_FreePixmap] = XR_FreePixmap;
XRequests[X_MapWindow] = XR_MapWindow;
XRequests[X_MapSubwindows] = XR_MapSubwindows;
XRequests[X_UnmapWindow] = XR_UnmapWindow;
XRequests[X_ClearArea] = XR_ClearArea;
XRequests[X_CopyArea] = XR_CopyArea;
XRequests[X_InternAtom] = XR_InternAtom;
XRequests[X_GetAtomName] = XR_GetAtomName;
XRequests[X_PutImage] = XR_PutImage;
XRequests[X_GetImage] = XR_GetImage;
XRequests[X_PolyRectangle] = XR_PolyRectangle;
XRequests[X_PolyFillRectangle] = XR_PolyRectangle;
XRequests[X_PolyPoint] = XR_PolyPoint;
XRequests[X_PolyLine] = XR_PolyLine;
XRequests[X_PolySegment] = XR_PolyLine;
XRequests[X_QueryPointer] = XR_QueryPointer;
// XRequests[X_ChangeKeyboardMapping] = XR_ChangeKeyboardMapping;
// XRequests[X_SetModifierMapping] = XR_ChangeKeyboardMapping;
XRequests[X_GetKeyboardMapping] = XR_GetKeyboardMapping;
XRequests[X_GetKeyboardControl] = XR_GetKeyboardControl;
XRequests[X_GetModifierMapping] = XR_GetModifierMapping;
XRequests[X_AllocColor] = XR_AllocColor;
XRequests[X_LookupColor] = XR_LookupColor;
XRequests[X_QueryColors] = XR_QueryColors;
XRequests[X_GetGeometry] = XR_GetGeometry;
XRequests[X_CreateCursor] = XR_CreateCursor;
XRequests[X_CreateGlyphCursor] = XR_CreateGlyphCursor;
XRequests[X_RecolorCursor] = XR_RecolorCursor;
XRequests[X_FreeCursor] = XR_FreeCursor;
XRequests[X_GrabButton] = XR_GrabButton;
XRequests[X_UngrabButton] = XR_UngrabButton;
XRequests[X_WarpPointer] = XR_WarpPointer;
XRequests[X_ListFonts] = XR_ListFonts;
XRequests[X_OpenFont] = XR_OpenFont;
XRequests[X_CloseFont] = XR_CloseFont;
XRequests[X_QueryFont] = XR_QueryFont;
XRequests[X_PolyText8] = XR_PolyText;
XRequests[X_PolyText16] = XR_PolyText;
XRequests[X_ImageText8] = XR_PolyText;
XRequests[X_ImageText16] = XR_PolyText;
XRequests[X_ConfigureWindow] = XR_ConfigureWindow;
XRequests[X_ReparentWindow] = XR_ReparentWindow;
XRequests[X_GrabServer] = XR_GrabServer;
XRequests[X_UngrabServer] = XR_UngrabServer;
XRequests[X_GrabPointer] = XR_GrabPointer;
XRequests[X_ChangeActivePointerGrab] = XR_ChangeActivePointerGrab;
XRequests[X_UngrabPointer] = XR_UngrabPointer;
XRequests[X_SendEvent] = XR_SendEvent;
XRequests[X_ConvertSelection] = XR_ConvertSelection;
XRequests[X_GetSelectionOwner] = XR_GetSelectionOwner;
XRequests[X_SetSelectionOwner] = XR_SetSelectionOwner;
XRequests[X_GrabKey] = XR_NoOperation;
XRequests[X_AllowEvents] = XR_NoOperation;
XRequests[X_FillPoly] = XR_FillPoly;
XRequests[X_NoOperation] = XR_NoOperation;
#ifdef XBigReqExtensionName
X_BigReqCode=ExtentionCode++;
XRequests[X_BigReqCode] = XR_BigReq;
#endif
}