static int
attach_slave(ClientPtr client, xXIAttachSlaveInfo *c,
int flags[MAXDEVICES])
{
DeviceIntPtr dev;
DeviceIntPtr newmaster;
int rc;
rc = dixLookupDevice(&dev, c->deviceid, client, DixManageAccess);
if (rc != Success)
goto unwind;
if (IsMaster(dev))
{
client->errorValue = c->deviceid;
rc = BadDevice;
goto unwind;
}
/* Don't allow changes to XTest Devices, these are fixed */
if (IsXTestDevice(dev, NULL))
{
client->errorValue = c->deviceid;
rc = BadDevice;
goto unwind;
}
rc = dixLookupDevice(&newmaster, c->new_master, client, DixAddAccess);
if (rc != Success)
goto unwind;
if (!IsMaster(newmaster))
{
client->errorValue = c->new_master;
rc = BadDevice;
goto unwind;
}
if (!((IsPointerDevice(newmaster) && IsPointerDevice(dev)) ||
(IsKeyboardDevice(newmaster) && IsKeyboardDevice(dev))))
{
rc = BadDevice;
goto unwind;
}
ReleaseButtonsAndKeys(dev);
AttachDevice(client, dev, newmaster);
flags[dev->id] |= XISlaveAttached;
unwind:
return rc;
}
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
ProcXIPassiveGrabDevice(ClientPtr client)
{
DeviceIntPtr dev, mod_dev;
xXIPassiveGrabDeviceReply rep = {
.repType = X_Reply,
.RepType = X_XIPassiveGrabDevice,
.sequenceNumber = client->sequence,
.length = 0,
.num_modifiers = 0
};
int i, ret = Success;
uint32_t *modifiers;
xXIGrabModifierInfo *modifiers_failed;
GrabMask mask = { 0 };
GrabParameters param;
void *tmp;
int mask_len;
REQUEST(xXIPassiveGrabDeviceReq);
REQUEST_FIXED_SIZE(xXIPassiveGrabDeviceReq,
((uint32_t) stuff->mask_len + stuff->num_modifiers) * 4);
if (stuff->deviceid == XIAllDevices)
dev = inputInfo.all_devices;
else if (stuff->deviceid == XIAllMasterDevices)
dev = inputInfo.all_master_devices;
else {
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess);
if (ret != Success) {
client->errorValue = stuff->deviceid;
return ret;
}
}
if (stuff->grab_type != XIGrabtypeButton &&
stuff->grab_type != XIGrabtypeKeycode &&
stuff->grab_type != XIGrabtypeEnter &&
stuff->grab_type != XIGrabtypeFocusIn &&
stuff->grab_type != XIGrabtypeTouchBegin) {
client->errorValue = stuff->grab_type;
return BadValue;
}
if ((stuff->grab_type == XIGrabtypeEnter ||
stuff->grab_type == XIGrabtypeFocusIn ||
stuff->grab_type == XIGrabtypeTouchBegin) && stuff->detail != 0) {
client->errorValue = stuff->detail;
return BadValue;
}
if (stuff->grab_type == XIGrabtypeTouchBegin &&
(stuff->grab_mode != XIGrabModeTouch ||
stuff->paired_device_mode != GrabModeAsync)) {
client->errorValue = stuff->grab_mode;
return BadValue;
}
if (XICheckInvalidMaskBits(client, (unsigned char *) &stuff[1],
stuff->mask_len * 4) != Success)
return BadValue;
mask.xi2mask = xi2mask_new();
if (!mask.xi2mask)
return BadAlloc;
mask_len = min(xi2mask_mask_size(mask.xi2mask), stuff->mask_len * 4);
xi2mask_set_one_mask(mask.xi2mask, stuff->deviceid,
(unsigned char *) &stuff[1], mask_len * 4);
memset(¶m, 0, sizeof(param));
param.grabtype = XI2;
param.ownerEvents = stuff->owner_events;
param.grabWindow = stuff->grab_window;
param.cursor = stuff->cursor;
if (IsKeyboardDevice(dev)) {
param.this_device_mode = stuff->grab_mode;
param.other_devices_mode = stuff->paired_device_mode;
}
else {
param.this_device_mode = stuff->paired_device_mode;
param.other_devices_mode = stuff->grab_mode;
}
if (stuff->cursor != None) {
ret = dixLookupResourceByType(&tmp, stuff->cursor,
RT_CURSOR, client, DixUseAccess);
if (ret != Success) {
client->errorValue = stuff->cursor;
goto out;
}
}
ret =
dixLookupWindow((WindowPtr *) &tmp, stuff->grab_window, client,
DixSetAttrAccess);
if (ret != Success)
goto out;
ret = CheckGrabValues(client, ¶m);
if (ret != Success)
goto out;
modifiers = (uint32_t *) &stuff[1] + stuff->mask_len;
modifiers_failed =
calloc(stuff->num_modifiers, sizeof(xXIGrabModifierInfo));
if (!modifiers_failed) {
ret = BadAlloc;
goto out;
}
mod_dev = (IsFloating(dev)) ? dev : GetMaster(dev, MASTER_KEYBOARD);
for (i = 0; i < stuff->num_modifiers; i++, modifiers++) {
uint8_t status = Success;
param.modifiers = *modifiers;
ret = CheckGrabValues(client, ¶m);
if (ret != Success)
goto out;
switch (stuff->grab_type) {
case XIGrabtypeButton:
status = GrabButton(client, dev, mod_dev, stuff->detail,
¶m, XI2, &mask);
break;
case XIGrabtypeKeycode:
status = GrabKey(client, dev, mod_dev, stuff->detail,
¶m, XI2, &mask);
break;
case XIGrabtypeEnter:
case XIGrabtypeFocusIn:
status = GrabWindow(client, dev, stuff->grab_type, ¶m, &mask);
break;
case XIGrabtypeTouchBegin:
status = GrabTouch(client, dev, mod_dev, ¶m, &mask);
break;
}
if (status != GrabSuccess) {
xXIGrabModifierInfo *info = modifiers_failed + rep.num_modifiers;
info->status = status;
info->modifiers = *modifiers;
if (client->swapped)
swapl(&info->modifiers);
rep.num_modifiers++;
rep.length += bytes_to_int32(sizeof(xXIGrabModifierInfo));
}
}
WriteReplyToClient(client, sizeof(rep), &rep);
if (rep.num_modifiers)
WriteToClient(client, rep.length * 4, modifiers_failed);
free(modifiers_failed);
out:
xi2mask_free(&mask.xi2mask);
return ret;
}
void _X_COLD
SRepXIPassiveGrabDevice(ClientPtr client, int size,
xXIPassiveGrabDeviceReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->num_modifiers);
WriteToClient(client, size, rep);
}
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) {
client->errorValue = stuff->win;
return rc;
}
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 = calloc(rep.buttons_len, 4);
if (!buttons)
return BadAlloc;
buttons_size = rep.buttons_len * 4;
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);
}
