int ProcXGetDeviceButtonMapping(register ClientPtr client) { DeviceIntPtr dev; xGetDeviceButtonMappingReply rep; ButtonClassPtr b; REQUEST(xGetDeviceButtonMappingReq); REQUEST_SIZE_MATCH(xGetDeviceButtonMappingReq); rep.repType = X_Reply; rep.RepType = X_GetDeviceButtonMapping; rep.nElts = 0; rep.length = 0; rep.sequenceNumber = client->sequence; dev = LookupDeviceIntRec(stuff->deviceid); if (dev == NULL) { SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, BadDevice); return Success; } b = dev->button; if (b == NULL) { SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, BadMatch); return Success; } rep.nElts = b->numButtons; rep.length = (rep.nElts + (4 - 1)) / 4; WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep); (void)WriteToClient(client, rep.nElts, (char *)&b->map[1]); return Success; }
int ProcXCloseDevice(register ClientPtr client) { int i; WindowPtr pWin, p1; DeviceIntPtr d; REQUEST(xCloseDeviceReq); REQUEST_SIZE_MATCH(xCloseDeviceReq); d = LookupDeviceIntRec(stuff->deviceid); if (d == NULL) { SendErrorToClient(client, IReqCode, X_CloseDevice, 0, BadDevice); return Success; } if (d->grab && SameClient(d->grab, client)) (*d->DeactivateGrab) (d); /* release active grab */ /* Remove event selections from all windows for events from this device * and selected by this client. * Delete passive grabs from all windows for this device. */ for (i = 0; i < screenInfo.numScreens; i++) { pWin = WindowTable[i]; DeleteDeviceEvents(d, pWin, client); p1 = pWin->firstChild; DeleteEventsFromChildren(d, p1, client); } CloseInputDevice(d, client); return Success; }
int ProcXSetDeviceModifierMapping(ClientPtr client) { int ret; xSetDeviceModifierMappingReply rep; DeviceIntPtr dev; KeyClassPtr kp; REQUEST(xSetDeviceModifierMappingReq); REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq); dev = LookupDeviceIntRec(stuff->deviceid); if (dev == NULL) { SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0, BadDevice); return Success; } rep.repType = X_Reply; rep.RepType = X_SetDeviceModifierMapping; rep.length = 0; rep.sequenceNumber = client->sequence; ret = SetModifierMapping(client, dev, stuff->length, (sizeof(xSetDeviceModifierMappingReq) >> 2), stuff->numKeyPerModifier, (BYTE *) & stuff[1], &kp); if (ret == MappingSuccess || ret == MappingBusy || ret == MappingFailed) { rep.success = ret; if (ret == MappingSuccess) SendDeviceMappingNotify(client, MappingModifier, 0, 0, dev); WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply), &rep); } else { if (ret == -1) ret = BadValue; SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0, ret); } return Success; }
int ProcXOpenDevice(ClientPtr client) { xInputClassInfo evbase[numInputClasses]; int j = 0; int status = Success; xOpenDeviceReply rep; DeviceIntPtr dev; REQUEST(xOpenDeviceReq); REQUEST_SIZE_MATCH(xOpenDeviceReq); if (stuff->deviceid == inputInfo.pointer->id || stuff->deviceid == inputInfo.keyboard->id) { SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice); return Success; } if ((dev = LookupDeviceIntRec(stuff->deviceid)) == NULL) { /* not open */ for (dev = inputInfo.off_devices; dev; dev = dev->next) if (dev->id == stuff->deviceid) break; if (dev == NULL) { SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice); return Success; } } OpenInputDevice(dev, client, &status); if (status != Success) { SendErrorToClient(client, IReqCode, X_OpenDevice, 0, status); return Success; } rep.repType = X_Reply; rep.RepType = X_OpenDevice; rep.sequenceNumber = client->sequence; if (dev->key != NULL) { evbase[j].class = KeyClass; evbase[j++].event_type_base = event_base[KeyClass]; }
int ProcXDeviceBell(register ClientPtr client) { DeviceIntPtr dev; KbdFeedbackPtr k; BellFeedbackPtr b; int base; int newpercent; CARD8 class; pointer ctrl; BellProcPtr proc; REQUEST(xDeviceBellReq); REQUEST_SIZE_MATCH(xDeviceBellReq); dev = LookupDeviceIntRec(stuff->deviceid); if (dev == NULL) { client->errorValue = stuff->deviceid; SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadDevice); return Success; } if (stuff->percent < -100 || stuff->percent > 100) { client->errorValue = stuff->percent; SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue); return Success; } if (stuff->feedbackclass == KbdFeedbackClass) { for (k = dev->kbdfeed; k; k = k->next) if (k->ctrl.id == stuff->feedbackid) break; if (!k) { client->errorValue = stuff->feedbackid; SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue); return Success; } base = k->ctrl.bell; proc = k->BellProc; ctrl = (pointer) & (k->ctrl); class = KbdFeedbackClass; } else if (stuff->feedbackclass == BellFeedbackClass) {
int ProcXSetDeviceFocus(ClientPtr client) { int ret; DeviceIntPtr dev; REQUEST(xSetDeviceFocusReq); REQUEST_SIZE_MATCH(xSetDeviceFocusReq); dev = LookupDeviceIntRec(stuff->device); if (dev == NULL || !dev->focus) { SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, BadDevice); return Success; } ret = SetInputFocus(client, dev, stuff->focus, stuff->revertTo, stuff->time, TRUE); if (ret != Success) SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, ret); return Success; }
int SProcXvDispatch(ClientPtr client) { REQUEST(xReq); UpdateCurrentTime(); if (stuff->data >= xvNumRequests) { SendErrorToClient(client, XvReqCode, stuff->data, 0, BadRequest); return BadRequest; } return SXvProcVector[stuff->data](client); }
int ProcXUngrabDevice(ClientPtr client) { DeviceIntPtr dev; GrabPtr grab; TimeStamp time; REQUEST(xUngrabDeviceReq); REQUEST_SIZE_MATCH(xUngrabDeviceReq); dev = LookupDeviceIntRec(stuff->deviceid); if (dev == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDevice, 0, BadDevice); return Success; } grab = dev->grab; time = ClientTimeToServerTime(stuff->time); if ((CompareTimeStamps(time, currentTime) != LATER) && (CompareTimeStamps(time, dev->grabTime) != EARLIER) && (grab) && SameClient(grab, client)) (*dev->DeactivateGrab) (dev); return Success; }
int SProcIDispatch(register ClientPtr client) { REQUEST(xReq); if (stuff->data == X_GetExtensionVersion) return (SProcXGetExtensionVersion(client)); if (stuff->data == X_ListInputDevices) return (SProcXListInputDevices(client)); else if (stuff->data == X_OpenDevice) return (SProcXOpenDevice(client)); else if (stuff->data == X_CloseDevice) return (SProcXCloseDevice(client)); else if (stuff->data == X_SetDeviceMode) return (SProcXSetDeviceMode(client)); else if (stuff->data == X_SelectExtensionEvent) return (SProcXSelectExtensionEvent(client)); else if (stuff->data == X_GetSelectedExtensionEvents) return (SProcXGetSelectedExtensionEvents(client)); else if (stuff->data == X_ChangeDeviceDontPropagateList) return (SProcXChangeDeviceDontPropagateList(client)); else if (stuff->data == X_GetDeviceDontPropagateList) return (SProcXGetDeviceDontPropagateList(client)); else if (stuff->data == X_GetDeviceMotionEvents) return (SProcXGetDeviceMotionEvents(client)); else if (stuff->data == X_ChangeKeyboardDevice) return (SProcXChangeKeyboardDevice(client)); else if (stuff->data == X_ChangePointerDevice) return (SProcXChangePointerDevice(client)); else if (stuff->data == X_GrabDevice) return (SProcXGrabDevice(client)); else if (stuff->data == X_UngrabDevice) return (SProcXUngrabDevice(client)); else if (stuff->data == X_GrabDeviceKey) return (SProcXGrabDeviceKey(client)); else if (stuff->data == X_UngrabDeviceKey) return (SProcXUngrabDeviceKey(client)); else if (stuff->data == X_GrabDeviceButton) return (SProcXGrabDeviceButton(client)); else if (stuff->data == X_UngrabDeviceButton) return (SProcXUngrabDeviceButton(client)); else if (stuff->data == X_AllowDeviceEvents) return (SProcXAllowDeviceEvents(client)); else if (stuff->data == X_GetDeviceFocus) return (SProcXGetDeviceFocus(client)); else if (stuff->data == X_SetDeviceFocus) return (SProcXSetDeviceFocus(client)); else if (stuff->data == X_GetFeedbackControl) return (SProcXGetFeedbackControl(client)); else if (stuff->data == X_ChangeFeedbackControl) return (SProcXChangeFeedbackControl(client)); else if (stuff->data == X_GetDeviceKeyMapping) return (SProcXGetDeviceKeyMapping(client)); else if (stuff->data == X_ChangeDeviceKeyMapping) return (SProcXChangeDeviceKeyMapping(client)); else if (stuff->data == X_GetDeviceModifierMapping) return (SProcXGetDeviceModifierMapping(client)); else if (stuff->data == X_SetDeviceModifierMapping) return (SProcXSetDeviceModifierMapping(client)); else if (stuff->data == X_GetDeviceButtonMapping) return (SProcXGetDeviceButtonMapping(client)); else if (stuff->data == X_SetDeviceButtonMapping) return (SProcXSetDeviceButtonMapping(client)); else if (stuff->data == X_QueryDeviceState) return (SProcXQueryDeviceState(client)); else if (stuff->data == X_SendExtensionEvent) return (SProcXSendExtensionEvent(client)); else if (stuff->data == X_DeviceBell) return (SProcXDeviceBell(client)); else if (stuff->data == X_SetDeviceValuators) return (SProcXSetDeviceValuators(client)); else if (stuff->data == X_GetDeviceControl) return (SProcXGetDeviceControl(client)); else if (stuff->data == X_ChangeDeviceControl) return (SProcXChangeDeviceControl(client)); else { SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest); } return (BadRequest); }
int ProcXUngrabDeviceKey(ClientPtr client) { DeviceIntPtr dev; DeviceIntPtr mdev; WindowPtr pWin; GrabRec temporaryGrab; REQUEST(xUngrabDeviceKeyReq); REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq); dev = LookupDeviceIntRec(stuff->grabbed_device); if (dev == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadDevice); return Success; } if (dev->key == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch); return Success; } if (stuff->modifier_device != UseXKeyboard) { mdev = LookupDeviceIntRec(stuff->modifier_device); if (mdev == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadDevice); return Success; } if (mdev->key == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch); return Success; } } else mdev = (DeviceIntPtr) LookupKeyboardDevice(); pWin = LookupWindow(stuff->grabWindow, client); if (!pWin) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadWindow); return Success; } if (((stuff->key > dev->key->curKeySyms.maxKeyCode) || (stuff->key < dev->key->curKeySyms.minKeyCode)) && (stuff->key != AnyKey)) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue); return Success; } if ((stuff->modifiers != AnyModifier) && (stuff->modifiers & ~AllModifiersMask)) { SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue); return Success; } temporaryGrab.resource = client->clientAsMask; temporaryGrab.device = dev; temporaryGrab.window = pWin; temporaryGrab.type = DeviceKeyPress; temporaryGrab.modifierDevice = mdev; temporaryGrab.modifiersDetail.exact = stuff->modifiers; temporaryGrab.modifiersDetail.pMask = NULL; temporaryGrab.detail.exact = stuff->key; temporaryGrab.detail.pMask = NULL; DeletePassiveGrabFromList(&temporaryGrab); return Success; }
int ProcXUngrabDeviceButton(ClientPtr client) { DeviceIntPtr dev; DeviceIntPtr mdev; WindowPtr pWin; GrabRec temporaryGrab; int rc; REQUEST(xUngrabDeviceButtonReq); REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq); dev = LookupDeviceIntRec(stuff->grabbed_device); if (dev == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadDevice); return Success; } if (dev->button == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadMatch); return Success; } if (stuff->modifier_device != UseXKeyboard) { mdev = LookupDeviceIntRec(stuff->modifier_device); if (mdev == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadDevice); return Success; } if (mdev->key == NULL) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadMatch); return Success; } } else mdev = (DeviceIntPtr) LookupKeyboardDevice(); rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixUnknownAccess); if (rc != Success) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, rc); return Success; } if ((stuff->modifiers != AnyModifier) && (stuff->modifiers & ~AllModifiersMask)) { SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadValue); return Success; } temporaryGrab.resource = client->clientAsMask; temporaryGrab.device = dev; temporaryGrab.window = pWin; temporaryGrab.type = DeviceButtonPress; temporaryGrab.modifierDevice = mdev; temporaryGrab.modifiersDetail.exact = stuff->modifiers; temporaryGrab.modifiersDetail.pMask = NULL; temporaryGrab.detail.exact = stuff->button; temporaryGrab.detail.pMask = NULL; DeletePassiveGrabFromList(&temporaryGrab); return Success; }
/* redefined here since it's not in any header file */ typedef struct _ShmDesc { struct _ShmDesc *next; int shmid; int refcnt; char *addr; Bool writable; unsigned long size; } ShmDescRec, *ShmDescPtr; extern RESTYPE ShmSegType; extern int ShmCompletionCode; static int ProcXvShmPutImage(ClientPtr client) { ShmDescPtr shmdesc; DrawablePtr pDraw; XvPortPtr pPort; XvImagePtr pImage = NULL; GCPtr pGC; int status, size_needed, i; CARD16 width, height; REQUEST(xvShmPutImageReq); REQUEST_SIZE_MATCH(xvShmPutImageReq); VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess); VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess); if ((status = _AllocatePort(stuff->port, pPort)) != Success) { client->errorValue = stuff->port; return status; } if (!(pPort->pAdaptor->type & XvImageMask) || !(pPort->pAdaptor->type & XvInputMask)) { client->errorValue = stuff->port; return BadMatch; } status = XvdiMatchPort(pPort, pDraw); if (status != Success) { return status; } for(i = 0; i < pPort->pAdaptor->nImages; i++) { if(pPort->pAdaptor->pImages[i].id == stuff->id) { pImage = &(pPort->pAdaptor->pImages[i]); break; } } if(!pImage) return BadMatch; status = dixLookupResourceByType((pointer *)&shmdesc, stuff->shmseg, ShmSegType, serverClient, DixReadAccess); if (status != Success) return status; width = stuff->width; height = stuff->height; size_needed = (*pPort->pAdaptor->ddQueryImageAttributes)(client, pPort, pImage, &width, &height, NULL, NULL); if((size_needed + stuff->offset) > shmdesc->size) return BadAccess; if((width < stuff->width) || (height < stuff->height)) return BadValue; status = XvdiPutImage(client, pDraw, pPort, pGC, stuff->src_x, stuff->src_y, stuff->src_w, stuff->src_h, stuff->drw_x, stuff->drw_y, stuff->drw_w, stuff->drw_h, pImage, (unsigned char *)shmdesc->addr + stuff->offset, stuff->send_event, stuff->width, stuff->height); if((status == Success) && stuff->send_event) { xShmCompletionEvent ev; ev.type = ShmCompletionCode; ev.drawable = stuff->drawable; ev.minorEvent = xv_ShmPutImage; ev.majorEvent = XvReqCode; ev.shmseg = stuff->shmseg; ev.offset = stuff->offset; WriteEventsToClient(client, 1, (xEvent *) &ev); } return status; } #else /* !MITSHM */ static int ProcXvShmPutImage(ClientPtr client) { SendErrorToClient(client, XvReqCode, xv_ShmPutImage, 0, BadImplementation); return BadImplementation; }
int ProcXIQueryPointer(ClientPtr client) { int rc; xXIQueryPointerReply rep; DeviceIntPtr pDev, kbd; WindowPtr pWin, t; SpritePtr pSprite; XkbStatePtr state; char *buttons = NULL; int buttons_size = 0; /* size of buttons array */ REQUEST(xXIQueryPointerReq); REQUEST_SIZE_MATCH(xXIQueryPointerReq); rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixReadAccess); if (rc != Success) { client->errorValue = stuff->deviceid; return rc; } if (pDev->valuator == NULL || IsKeyboardDevice(pDev) || (!IsMaster(pDev) && pDev->u.master)) /* no attached devices */ { client->errorValue = stuff->deviceid; return BadDevice; } rc = dixLookupWindow(&pWin, stuff->win, client, DixGetAttrAccess); if (rc != Success) { SendErrorToClient(client, IReqCode, X_XIQueryPointer, stuff->win, rc); return Success; } if (pDev->valuator->motionHintWindow) MaybeStopHint(pDev, client); if (IsMaster(pDev)) kbd = GetPairedDevice(pDev); else kbd = (pDev->key) ? pDev : NULL; pSprite = pDev->spriteInfo->sprite; memset(&rep, 0, sizeof(rep)); rep.repType = X_Reply; rep.RepType = X_XIQueryPointer; rep.length = 6; rep.sequenceNumber = client->sequence; rep.root = (GetCurrentRootWindow(pDev))->drawable.id; rep.root_x = FP1616(pSprite->hot.x, 0); rep.root_y = FP1616(pSprite->hot.y, 0); rep.child = None; if (kbd) { state = &kbd->key->xkbInfo->prev_state; rep.mods.base_mods = state->base_mods; rep.mods.latched_mods = state->latched_mods; rep.mods.locked_mods = state->locked_mods; rep.group.base_group = state->base_group; rep.group.latched_group = state->latched_group; rep.group.locked_group = state->locked_group; } if (pDev->button) { int i, down; rep.buttons_len = bytes_to_int32(bits_to_bytes(pDev->button->numButtons)); rep.length += rep.buttons_len; buttons_size = rep.buttons_len * 4; buttons = xcalloc(1, buttons_size); if (!buttons) return BadAlloc; down = pDev->button->buttonsDown; for (i = 0; i < pDev->button->numButtons && down; i++) { if (BitIsOn(pDev->button->down, i)) { SetBit(buttons, i); down--; } } } else rep.buttons_len = 0; if (pSprite->hot.pScreen == pWin->drawable.pScreen) { rep.same_screen = xTrue; rep.win_x = FP1616(pSprite->hot.x - pWin->drawable.x, 0); rep.win_y = FP1616(pSprite->hot.y - pWin->drawable.y, 0); for (t = pSprite->win; t; t = t->parent) if (t->parent == pWin) { rep.child = t->drawable.id; break; } } else { rep.same_screen = xFalse; rep.win_x = 0; rep.win_y = 0; } #ifdef PANORAMIX if(!noPanoramiXExtension) { rep.root_x += FP1616(panoramiXdataPtr[0].x, 0); rep.root_y += FP1616(panoramiXdataPtr[0].y, 0); if (stuff->win == rep.root) { rep.win_x += FP1616(panoramiXdataPtr[0].x, 0); rep.win_y += FP1616(panoramiXdataPtr[0].y, 0); } } #endif WriteReplyToClient(client, sizeof(xXIQueryPointerReply), &rep); if (buttons) WriteToClient(client, buttons_size, buttons); xfree(buttons); return Success; }
int ProcXIQueryPointer(ClientPtr client) { int rc; xXIQueryPointerReply rep; DeviceIntPtr pDev, kbd; WindowPtr pWin, t; SpritePtr pSprite; XkbStatePtr state; char *buttons = NULL; int buttons_size = 0; /* size of buttons array */ XIClientPtr xi_client; Bool have_xi22 = FALSE; REQUEST(xXIQueryPointerReq); REQUEST_SIZE_MATCH(xXIQueryPointerReq); /* Check if client is compliant with XInput 2.2 or later. Earlier clients * do not know about touches, so we must report emulated button presses. 2.2 * and later clients are aware of touches, so we don't include emulated * button presses in the reply. */ xi_client = dixLookupPrivate(&client->devPrivates, XIClientPrivateKey); if (version_compare(xi_client->major_version, xi_client->minor_version, 2, 2) >= 0) have_xi22 = TRUE; rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixReadAccess); if (rc != Success) { client->errorValue = stuff->deviceid; return rc; } if (pDev->valuator == NULL || IsKeyboardDevice(pDev) || (!IsMaster(pDev) && !IsFloating(pDev))) { /* no attached devices */ client->errorValue = stuff->deviceid; return BadDevice; } rc = dixLookupWindow(&pWin, stuff->win, client, DixGetAttrAccess); if (rc != Success) { SendErrorToClient(client, IReqCode, X_XIQueryPointer, stuff->win, rc); return Success; } if (pDev->valuator->motionHintWindow) MaybeStopHint(pDev, client); if (IsMaster(pDev)) kbd = GetMaster(pDev, MASTER_KEYBOARD); else kbd = (pDev->key) ? pDev : NULL; pSprite = pDev->spriteInfo->sprite; rep = (xXIQueryPointerReply) { .repType = X_Reply, .RepType = X_XIQueryPointer, .sequenceNumber = client->sequence, .length = 6, .root = (GetCurrentRootWindow(pDev))->drawable.id, .root_x = double_to_fp1616(pSprite->hot.x), .root_y = double_to_fp1616(pSprite->hot.y), .child = None }; if (kbd) { state = &kbd->key->xkbInfo->state; rep.mods.base_mods = state->base_mods; rep.mods.latched_mods = state->latched_mods; rep.mods.locked_mods = state->locked_mods; rep.group.base_group = state->base_group; rep.group.latched_group = state->latched_group; rep.group.locked_group = state->locked_group; } if (pDev->button) { int i; rep.buttons_len = bytes_to_int32(bits_to_bytes(pDev->button->numButtons)); rep.length += rep.buttons_len; buttons_size = rep.buttons_len * 4; buttons = calloc(1, buttons_size); if (!buttons) return BadAlloc; for (i = 1; i < pDev->button->numButtons; i++) if (BitIsOn(pDev->button->down, i)) SetBit(buttons, pDev->button->map[i]); if (!have_xi22 && pDev->touch && pDev->touch->buttonsDown > 0) SetBit(buttons, pDev->button->map[1]); } else rep.buttons_len = 0; if (pSprite->hot.pScreen == pWin->drawable.pScreen) { rep.same_screen = xTrue; rep.win_x = double_to_fp1616(pSprite->hot.x - pWin->drawable.x); rep.win_y = double_to_fp1616(pSprite->hot.y - pWin->drawable.y); for (t = pSprite->win; t; t = t->parent) if (t->parent == pWin) { rep.child = t->drawable.id; break; } } else { rep.same_screen = xFalse; rep.win_x = 0; rep.win_y = 0; } #ifdef PANORAMIX if (!noPanoramiXExtension) { rep.root_x += double_to_fp1616(screenInfo.screens[0]->x); rep.root_y += double_to_fp1616(screenInfo.screens[0]->y); if (stuff->win == rep.root) { rep.win_x += double_to_fp1616(screenInfo.screens[0]->x); rep.win_y += double_to_fp1616(screenInfo.screens[0]->y); } } #endif WriteReplyToClient(client, sizeof(xXIQueryPointerReply), &rep); if (buttons) WriteToClient(client, buttons_size, buttons); free(buttons); return Success; } /*********************************************************************** * * This procedure writes the reply for the XIQueryPointer function, * if the client and server have a different byte ordering. * */ void SRepXIQueryPointer(ClientPtr client, int size, xXIQueryPointerReply * rep) { swaps(&rep->sequenceNumber); swapl(&rep->length); swapl(&rep->root); swapl(&rep->child); swapl(&rep->root_x); swapl(&rep->root_y); swapl(&rep->win_x); swapl(&rep->win_y); swaps(&rep->buttons_len); WriteToClient(client, size, rep); }
int ProcXGetSelectedExtensionEvents(register ClientPtr client) { int i; int total_length = 0; xGetSelectedExtensionEventsReply rep; WindowPtr pWin; XEventClass *buf = NULL; XEventClass *tclient; XEventClass *aclient; OtherInputMasks *pOthers; InputClientsPtr others; REQUEST(xGetSelectedExtensionEventsReq); REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq); rep.repType = X_Reply; rep.RepType = X_GetSelectedExtensionEvents; rep.length = 0; rep.sequenceNumber = client->sequence; rep.this_client_count = 0; rep.all_clients_count = 0; if (!(pWin = LookupWindow(stuff->window, client))) { SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0, BadWindow); return Success; } if ((pOthers = wOtherInputMasks(pWin)) != 0) { for (others = pOthers->inputClients; others; others = others->next) for (i = 0; i < EMASKSIZE; i++) tclient = ClassFromMask(NULL, others->mask[i], i, &rep.all_clients_count, COUNT); for (others = pOthers->inputClients; others; others = others->next) if (SameClient(others, client)) { for (i = 0; i < EMASKSIZE; i++) tclient = ClassFromMask(NULL, others->mask[i], i, &rep.this_client_count, COUNT); break; } total_length = (rep.all_clients_count + rep.this_client_count) * sizeof(XEventClass); rep.length = (total_length + 3) >> 2; buf = (XEventClass *) xalloc(total_length); tclient = buf; aclient = buf + rep.this_client_count; if (others) for (i = 0; i < EMASKSIZE; i++) tclient = ClassFromMask(tclient, others->mask[i], i, NULL, CREATE); for (others = pOthers->inputClients; others; others = others->next) for (i = 0; i < EMASKSIZE; i++) aclient = ClassFromMask(aclient, others->mask[i], i, NULL, CREATE); } WriteReplyToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep); if (total_length) { client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; WriteSwappedDataToClient(client, total_length, buf); xfree(buf); } return Success; }