3344 lines
104 KiB
C
3344 lines
104 KiB
C
/************************************************************
|
|
|
|
Copyright 1989, 1998 The Open Group
|
|
|
|
Permission to use, copy, modify, distribute, and sell this software and its
|
|
documentation for any purpose is hereby granted without fee, provided that
|
|
the above copyright notice appear in all copies and that both that
|
|
copyright notice and this permission notice appear in supporting
|
|
documentation.
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of The Open Group shall not be
|
|
used in advertising or otherwise to promote the sale, use or other dealings
|
|
in this Software without prior written authorization from The Open Group.
|
|
|
|
Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the name of Hewlett-Packard not be
|
|
used in advertising or publicity pertaining to distribution of the
|
|
software without specific, written prior permission.
|
|
|
|
HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
|
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
|
HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
|
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
|
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
SOFTWARE.
|
|
|
|
********************************************************/
|
|
|
|
/*
|
|
* Copyright © 2010 Collabora Ltd.
|
|
* Copyright © 2011 Red Hat, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Author: Daniel Stone <daniel@fooishbar.org>
|
|
*/
|
|
|
|
/********************************************************************
|
|
*
|
|
* Routines to register and initialize extension input devices.
|
|
* This also contains ProcessOtherEvent, the routine called from DDX
|
|
* to route extension events.
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include "inputstr.h"
|
|
#include <X11/X.h>
|
|
#include <X11/Xproto.h>
|
|
#include <X11/extensions/XI.h>
|
|
#include <X11/extensions/XIproto.h>
|
|
#include <X11/extensions/XI2proto.h>
|
|
#include <X11/extensions/geproto.h>
|
|
#include "windowstr.h"
|
|
#include "miscstruct.h"
|
|
#include "region.h"
|
|
#include "exevents.h"
|
|
#include "extnsionst.h"
|
|
#include "exglobals.h"
|
|
#include "eventstr.h"
|
|
#include "dixevents.h" /* DeliverFocusedEvent */
|
|
#include "dixgrabs.h" /* CreateGrab() */
|
|
#include "scrnintstr.h"
|
|
#include "listdev.h" /* for CopySwapXXXClass */
|
|
#include "xace.h"
|
|
#include "xiquerydevice.h" /* For List*Info */
|
|
#include "eventconvert.h"
|
|
#include "eventstr.h"
|
|
#include "inpututils.h"
|
|
#include "mi.h"
|
|
|
|
#include <X11/extensions/XKBproto.h>
|
|
#include "xkbsrv.h"
|
|
|
|
#define WID(w) ((w) ? ((w)->drawable.id) : 0)
|
|
#define AllModifiersMask ( \
|
|
ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
|
|
Mod3Mask | Mod4Mask | Mod5Mask )
|
|
#define AllButtonsMask ( \
|
|
Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask )
|
|
|
|
Bool ShouldFreeInputMasks(WindowPtr /* pWin */ ,
|
|
Bool /* ignoreSelectedEvents */
|
|
);
|
|
static Bool MakeInputMasks(WindowPtr /* pWin */
|
|
);
|
|
|
|
/*
|
|
* Only let the given client know of core events which will affect its
|
|
* interpretation of input events, if the client's ClientPointer (or the
|
|
* paired keyboard) is the current device.
|
|
*/
|
|
int
|
|
XIShouldNotify(ClientPtr client, DeviceIntPtr dev)
|
|
{
|
|
DeviceIntPtr current_ptr = PickPointer(client);
|
|
DeviceIntPtr current_kbd = GetMaster(current_ptr, KEYBOARD_OR_FLOAT);
|
|
|
|
if (dev == current_kbd || dev == current_ptr)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
Bool
|
|
IsPointerEvent(InternalEvent *event)
|
|
{
|
|
switch (event->any.type) {
|
|
case ET_ButtonPress:
|
|
case ET_ButtonRelease:
|
|
case ET_Motion:
|
|
/* XXX: enter/leave ?? */
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
Bool
|
|
IsTouchEvent(InternalEvent *event)
|
|
{
|
|
switch (event->any.type) {
|
|
case ET_TouchBegin:
|
|
case ET_TouchUpdate:
|
|
case ET_TouchEnd:
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
Bool
|
|
IsGestureEvent(InternalEvent *event)
|
|
{
|
|
switch (event->any.type) {
|
|
case ET_GesturePinchBegin:
|
|
case ET_GesturePinchUpdate:
|
|
case ET_GesturePinchEnd:
|
|
case ET_GestureSwipeBegin:
|
|
case ET_GestureSwipeUpdate:
|
|
case ET_GestureSwipeEnd:
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
Bool
|
|
IsGestureBeginEvent(InternalEvent *event)
|
|
{
|
|
switch (event->any.type) {
|
|
case ET_GesturePinchBegin:
|
|
case ET_GestureSwipeBegin:
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
Bool
|
|
IsGestureEndEvent(InternalEvent *event)
|
|
{
|
|
switch (event->any.type) {
|
|
case ET_GesturePinchEnd:
|
|
case ET_GestureSwipeEnd:
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* @return the device matching the deviceid of the device set in the event, or
|
|
* NULL if the event is not an XInput event.
|
|
*/
|
|
DeviceIntPtr
|
|
XIGetDevice(xEvent *xE)
|
|
{
|
|
DeviceIntPtr pDev = NULL;
|
|
|
|
if (xE->u.u.type == DeviceButtonPress ||
|
|
xE->u.u.type == DeviceButtonRelease ||
|
|
xE->u.u.type == DeviceMotionNotify ||
|
|
xE->u.u.type == ProximityIn ||
|
|
xE->u.u.type == ProximityOut || xE->u.u.type == DevicePropertyNotify) {
|
|
int rc;
|
|
int id;
|
|
|
|
id = ((deviceKeyButtonPointer *) xE)->deviceid & ~MORE_EVENTS;
|
|
|
|
rc = dixLookupDevice(&pDev, id, serverClient, DixUnknownAccess);
|
|
if (rc != Success)
|
|
ErrorF("[dix] XIGetDevice failed on XACE restrictions (%d)\n", rc);
|
|
}
|
|
return pDev;
|
|
}
|
|
|
|
/**
|
|
* Copy the device->key into master->key and send a mapping notify to the
|
|
* clients if appropriate.
|
|
* master->key needs to be allocated by the caller.
|
|
*
|
|
* Device is the slave device. If it is attached to a master device, we may
|
|
* need to send a mapping notify to the client because it causes the MD
|
|
* to change state.
|
|
*
|
|
* Mapping notify needs to be sent in the following cases:
|
|
* - different slave device on same master
|
|
* - different master
|
|
*
|
|
* XXX: They way how the code is we also send a map notify if the slave device
|
|
* stays the same, but the master changes. This isn't really necessary though.
|
|
*
|
|
* XXX: this gives you funny behaviour with the ClientPointer. When a
|
|
* MappingNotify is sent to the client, the client usually responds with a
|
|
* GetKeyboardMapping. This will retrieve the ClientPointer's keyboard
|
|
* mapping, regardless of which keyboard sent the last mapping notify request.
|
|
* So depending on the CP setting, your keyboard may change layout in each
|
|
* app...
|
|
*
|
|
* This code is basically the old SwitchCoreKeyboard.
|
|
*/
|
|
|
|
void
|
|
CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master)
|
|
{
|
|
KeyClassPtr mk = master->key;
|
|
|
|
if (device == master)
|
|
return;
|
|
|
|
mk->sourceid = device->id;
|
|
|
|
if (!XkbDeviceApplyKeymap(master, device->key->xkbInfo->desc))
|
|
FatalError("Couldn't pivot keymap from device to core!\n");
|
|
}
|
|
|
|
/**
|
|
* Copies the feedback classes from device "from" into device "to". Classes
|
|
* are duplicated (not just flipping the pointers). All feedback classes are
|
|
* linked lists, the full list is duplicated.
|
|
*/
|
|
static void
|
|
DeepCopyFeedbackClasses(DeviceIntPtr from, DeviceIntPtr to)
|
|
{
|
|
ClassesPtr classes;
|
|
|
|
if (from->intfeed) {
|
|
IntegerFeedbackPtr *i, it;
|
|
|
|
if (!to->intfeed) {
|
|
classes = to->unused_classes;
|
|
to->intfeed = classes->intfeed;
|
|
classes->intfeed = NULL;
|
|
}
|
|
|
|
i = &to->intfeed;
|
|
for (it = from->intfeed; it; it = it->next) {
|
|
if (!(*i)) {
|
|
*i = calloc(1, sizeof(IntegerFeedbackClassRec));
|
|
if (!(*i)) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*i)->CtrlProc = it->CtrlProc;
|
|
(*i)->ctrl = it->ctrl;
|
|
|
|
i = &(*i)->next;
|
|
}
|
|
}
|
|
else if (to->intfeed && !from->intfeed) {
|
|
classes = to->unused_classes;
|
|
classes->intfeed = to->intfeed;
|
|
to->intfeed = NULL;
|
|
}
|
|
|
|
if (from->stringfeed) {
|
|
StringFeedbackPtr *s, it;
|
|
|
|
if (!to->stringfeed) {
|
|
classes = to->unused_classes;
|
|
to->stringfeed = classes->stringfeed;
|
|
classes->stringfeed = NULL;
|
|
}
|
|
|
|
s = &to->stringfeed;
|
|
for (it = from->stringfeed; it; it = it->next) {
|
|
if (!(*s)) {
|
|
*s = calloc(1, sizeof(StringFeedbackClassRec));
|
|
if (!(*s)) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*s)->CtrlProc = it->CtrlProc;
|
|
(*s)->ctrl = it->ctrl;
|
|
|
|
s = &(*s)->next;
|
|
}
|
|
}
|
|
else if (to->stringfeed && !from->stringfeed) {
|
|
classes = to->unused_classes;
|
|
classes->stringfeed = to->stringfeed;
|
|
to->stringfeed = NULL;
|
|
}
|
|
|
|
if (from->bell) {
|
|
BellFeedbackPtr *b, it;
|
|
|
|
if (!to->bell) {
|
|
classes = to->unused_classes;
|
|
to->bell = classes->bell;
|
|
classes->bell = NULL;
|
|
}
|
|
|
|
b = &to->bell;
|
|
for (it = from->bell; it; it = it->next) {
|
|
if (!(*b)) {
|
|
*b = calloc(1, sizeof(BellFeedbackClassRec));
|
|
if (!(*b)) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*b)->BellProc = it->BellProc;
|
|
(*b)->CtrlProc = it->CtrlProc;
|
|
(*b)->ctrl = it->ctrl;
|
|
|
|
b = &(*b)->next;
|
|
}
|
|
}
|
|
else if (to->bell && !from->bell) {
|
|
classes = to->unused_classes;
|
|
classes->bell = to->bell;
|
|
to->bell = NULL;
|
|
}
|
|
|
|
if (from->leds) {
|
|
LedFeedbackPtr *l, it;
|
|
|
|
if (!to->leds) {
|
|
classes = to->unused_classes;
|
|
to->leds = classes->leds;
|
|
classes->leds = NULL;
|
|
}
|
|
|
|
l = &to->leds;
|
|
for (it = from->leds; it; it = it->next) {
|
|
if (!(*l)) {
|
|
*l = calloc(1, sizeof(LedFeedbackClassRec));
|
|
if (!(*l)) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*l)->CtrlProc = it->CtrlProc;
|
|
(*l)->ctrl = it->ctrl;
|
|
if ((*l)->xkb_sli)
|
|
XkbFreeSrvLedInfo((*l)->xkb_sli);
|
|
(*l)->xkb_sli = XkbCopySrvLedInfo(from, it->xkb_sli, NULL, *l);
|
|
|
|
l = &(*l)->next;
|
|
}
|
|
}
|
|
else if (to->leds && !from->leds) {
|
|
classes = to->unused_classes;
|
|
classes->leds = to->leds;
|
|
to->leds = NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
DeepCopyKeyboardClasses(DeviceIntPtr from, DeviceIntPtr to)
|
|
{
|
|
ClassesPtr classes;
|
|
|
|
/* XkbInitDevice (->XkbInitIndicatorMap->XkbFindSrvLedInfo) relies on the
|
|
* kbdfeed to be set up properly, so let's do the feedback classes first.
|
|
*/
|
|
if (from->kbdfeed) {
|
|
KbdFeedbackPtr *k, it;
|
|
|
|
if (!to->kbdfeed) {
|
|
classes = to->unused_classes;
|
|
|
|
to->kbdfeed = classes->kbdfeed;
|
|
if (!to->kbdfeed)
|
|
InitKeyboardDeviceStruct(to, NULL, NULL, NULL);
|
|
classes->kbdfeed = NULL;
|
|
}
|
|
|
|
k = &to->kbdfeed;
|
|
for (it = from->kbdfeed; it; it = it->next) {
|
|
if (!(*k)) {
|
|
*k = calloc(1, sizeof(KbdFeedbackClassRec));
|
|
if (!*k) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*k)->BellProc = it->BellProc;
|
|
(*k)->CtrlProc = it->CtrlProc;
|
|
(*k)->ctrl = it->ctrl;
|
|
if ((*k)->xkb_sli)
|
|
XkbFreeSrvLedInfo((*k)->xkb_sli);
|
|
(*k)->xkb_sli = XkbCopySrvLedInfo(from, it->xkb_sli, *k, NULL);
|
|
|
|
k = &(*k)->next;
|
|
}
|
|
}
|
|
else if (to->kbdfeed && !from->kbdfeed) {
|
|
classes = to->unused_classes;
|
|
classes->kbdfeed = to->kbdfeed;
|
|
to->kbdfeed = NULL;
|
|
}
|
|
|
|
if (from->key) {
|
|
if (!to->key) {
|
|
classes = to->unused_classes;
|
|
to->key = classes->key;
|
|
if (!to->key)
|
|
InitKeyboardDeviceStruct(to, NULL, NULL, NULL);
|
|
else
|
|
classes->key = NULL;
|
|
}
|
|
|
|
CopyKeyClass(from, to);
|
|
}
|
|
else if (to->key && !from->key) {
|
|
classes = to->unused_classes;
|
|
classes->key = to->key;
|
|
to->key = NULL;
|
|
}
|
|
|
|
/* If a SrvLedInfoPtr's flags are XkbSLI_IsDefault, the names and maps
|
|
* pointer point into the xkbInfo->desc struct. XkbCopySrvLedInfo
|
|
* didn't update the pointers so we need to do it manually here.
|
|
*/
|
|
if (to->kbdfeed) {
|
|
KbdFeedbackPtr k;
|
|
|
|
for (k = to->kbdfeed; k; k = k->next) {
|
|
if (!k->xkb_sli)
|
|
continue;
|
|
if (k->xkb_sli->flags & XkbSLI_IsDefault) {
|
|
k->xkb_sli->names = to->key->xkbInfo->desc->names->indicators;
|
|
k->xkb_sli->maps = to->key->xkbInfo->desc->indicators->maps;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* We can't just copy over the focus class. When an app sets the focus,
|
|
* it'll do so on the master device. Copying the SDs focus means losing
|
|
* the focus.
|
|
* So we only copy the focus class if the device didn't have one,
|
|
* otherwise we leave it as it is.
|
|
*/
|
|
if (from->focus) {
|
|
if (!to->focus) {
|
|
WindowPtr *oldTrace;
|
|
|
|
classes = to->unused_classes;
|
|
to->focus = classes->focus;
|
|
if (!to->focus) {
|
|
to->focus = calloc(1, sizeof(FocusClassRec));
|
|
if (!to->focus)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
}
|
|
else
|
|
classes->focus = NULL;
|
|
|
|
oldTrace = to->focus->trace;
|
|
memcpy(to->focus, from->focus, sizeof(FocusClassRec));
|
|
to->focus->trace = reallocarray(oldTrace,
|
|
to->focus->traceSize,
|
|
sizeof(WindowPtr));
|
|
if (!to->focus->trace && to->focus->traceSize)
|
|
FatalError("[Xi] no memory for trace.\n");
|
|
memcpy(to->focus->trace, from->focus->trace,
|
|
from->focus->traceSize * sizeof(WindowPtr));
|
|
to->focus->sourceid = from->id;
|
|
}
|
|
}
|
|
else if (to->focus) {
|
|
classes = to->unused_classes;
|
|
classes->focus = to->focus;
|
|
to->focus = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
/* FIXME: this should really be shared with the InitValuatorAxisClassRec and
|
|
* similar */
|
|
static void
|
|
DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
|
|
{
|
|
ClassesPtr classes;
|
|
|
|
/* Feedback classes must be copied first */
|
|
if (from->ptrfeed) {
|
|
PtrFeedbackPtr *p, it;
|
|
|
|
if (!to->ptrfeed) {
|
|
classes = to->unused_classes;
|
|
to->ptrfeed = classes->ptrfeed;
|
|
classes->ptrfeed = NULL;
|
|
}
|
|
|
|
p = &to->ptrfeed;
|
|
for (it = from->ptrfeed; it; it = it->next) {
|
|
if (!(*p)) {
|
|
*p = calloc(1, sizeof(PtrFeedbackClassRec));
|
|
if (!*p) {
|
|
ErrorF("[Xi] Cannot alloc memory for class copy.");
|
|
return;
|
|
}
|
|
}
|
|
(*p)->CtrlProc = it->CtrlProc;
|
|
(*p)->ctrl = it->ctrl;
|
|
|
|
p = &(*p)->next;
|
|
}
|
|
}
|
|
else if (to->ptrfeed && !from->ptrfeed) {
|
|
classes = to->unused_classes;
|
|
classes->ptrfeed = to->ptrfeed;
|
|
to->ptrfeed = NULL;
|
|
}
|
|
|
|
if (from->valuator) {
|
|
ValuatorClassPtr v;
|
|
|
|
if (!to->valuator) {
|
|
classes = to->unused_classes;
|
|
to->valuator = classes->valuator;
|
|
if (to->valuator)
|
|
classes->valuator = NULL;
|
|
}
|
|
|
|
v = AllocValuatorClass(to->valuator, from->valuator->numAxes);
|
|
|
|
if (!v)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
|
|
to->valuator = v;
|
|
memcpy(v->axes, from->valuator->axes, v->numAxes * sizeof(AxisInfo));
|
|
|
|
v->sourceid = from->id;
|
|
}
|
|
else if (to->valuator && !from->valuator) {
|
|
classes = to->unused_classes;
|
|
classes->valuator = to->valuator;
|
|
to->valuator = NULL;
|
|
}
|
|
|
|
if (from->button) {
|
|
if (!to->button) {
|
|
classes = to->unused_classes;
|
|
to->button = classes->button;
|
|
if (!to->button) {
|
|
to->button = calloc(1, sizeof(ButtonClassRec));
|
|
if (!to->button)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
}
|
|
else
|
|
classes->button = NULL;
|
|
}
|
|
|
|
if (from->button->xkb_acts) {
|
|
if (!to->button->xkb_acts) {
|
|
to->button->xkb_acts = calloc(1, sizeof(XkbAction));
|
|
if (!to->button->xkb_acts)
|
|
FatalError("[Xi] not enough memory for xkb_acts.\n");
|
|
}
|
|
memcpy(to->button->xkb_acts, from->button->xkb_acts,
|
|
sizeof(XkbAction));
|
|
}
|
|
else
|
|
free(to->button->xkb_acts);
|
|
|
|
memcpy(to->button->labels, from->button->labels,
|
|
from->button->numButtons * sizeof(Atom));
|
|
to->button->sourceid = from->id;
|
|
}
|
|
else if (to->button && !from->button) {
|
|
classes = to->unused_classes;
|
|
classes->button = to->button;
|
|
to->button = NULL;
|
|
}
|
|
|
|
if (from->proximity) {
|
|
if (!to->proximity) {
|
|
classes = to->unused_classes;
|
|
to->proximity = classes->proximity;
|
|
if (!to->proximity) {
|
|
to->proximity = calloc(1, sizeof(ProximityClassRec));
|
|
if (!to->proximity)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
}
|
|
else
|
|
classes->proximity = NULL;
|
|
}
|
|
memcpy(to->proximity, from->proximity, sizeof(ProximityClassRec));
|
|
to->proximity->sourceid = from->id;
|
|
}
|
|
else if (to->proximity) {
|
|
classes = to->unused_classes;
|
|
classes->proximity = to->proximity;
|
|
to->proximity = NULL;
|
|
}
|
|
|
|
if (from->touch) {
|
|
TouchClassPtr t, f;
|
|
|
|
if (!to->touch) {
|
|
classes = to->unused_classes;
|
|
to->touch = classes->touch;
|
|
if (!to->touch) {
|
|
int i;
|
|
|
|
to->touch = calloc(1, sizeof(TouchClassRec));
|
|
if (!to->touch)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
to->touch->num_touches = from->touch->num_touches;
|
|
to->touch->touches = calloc(to->touch->num_touches,
|
|
sizeof(TouchPointInfoRec));
|
|
for (i = 0; i < to->touch->num_touches; i++)
|
|
TouchInitTouchPoint(to->touch, to->valuator, i);
|
|
if (!to->touch)
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
}
|
|
else
|
|
classes->touch = NULL;
|
|
}
|
|
|
|
t = to->touch;
|
|
f = from->touch;
|
|
t->sourceid = f->sourceid;
|
|
t->max_touches = f->max_touches;
|
|
t->mode = f->mode;
|
|
t->buttonsDown = f->buttonsDown;
|
|
t->state = f->state;
|
|
t->motionMask = f->motionMask;
|
|
/* to->touches and to->num_touches are separate on the master,
|
|
* don't copy */
|
|
}
|
|
/* Don't remove touch class if from->touch is non-existent. The to device
|
|
* may have an active touch grab, so we need to keep the touch class record
|
|
* around. */
|
|
|
|
if (from->gesture) {
|
|
if (!to->gesture) {
|
|
classes = to->unused_classes;
|
|
to->gesture = classes->gesture;
|
|
if (!to->gesture) {
|
|
if (!InitGestureClassDeviceStruct(to, from->gesture->max_touches))
|
|
FatalError("[Xi] no memory for class shift.\n");
|
|
}
|
|
else
|
|
classes->gesture = NULL;
|
|
}
|
|
|
|
to->gesture->sourceid = from->gesture->sourceid;
|
|
/* to->gesture->gesture is separate on the master, don't copy */
|
|
}
|
|
/* Don't remove gesture class if from->gesture is non-existent. The to device
|
|
* may have an active gesture grab, so we need to keep the gesture class record
|
|
* around. */
|
|
}
|
|
|
|
/**
|
|
* Copies the CONTENT of the classes of device from into the classes in device
|
|
* to. From and to are identical after finishing.
|
|
*
|
|
* If to does not have classes from currently has, the classes are stored in
|
|
* to's devPrivates system. Later, we recover it again from there if needed.
|
|
* Saves a few memory allocations.
|
|
*/
|
|
void
|
|
DeepCopyDeviceClasses(DeviceIntPtr from, DeviceIntPtr to,
|
|
DeviceChangedEvent *dce)
|
|
{
|
|
input_lock();
|
|
|
|
/* generic feedback classes, not tied to pointer and/or keyboard */
|
|
DeepCopyFeedbackClasses(from, to);
|
|
|
|
if ((dce->flags & DEVCHANGE_KEYBOARD_EVENT))
|
|
DeepCopyKeyboardClasses(from, to);
|
|
if ((dce->flags & DEVCHANGE_POINTER_EVENT))
|
|
DeepCopyPointerClasses(from, to);
|
|
|
|
input_unlock();
|
|
}
|
|
|
|
/**
|
|
* Send an XI2 DeviceChangedEvent to all interested clients.
|
|
*/
|
|
void
|
|
XISendDeviceChangedEvent(DeviceIntPtr device, DeviceChangedEvent *dce)
|
|
{
|
|
xXIDeviceChangedEvent *dcce;
|
|
int rc;
|
|
|
|
rc = EventToXI2((InternalEvent *) dce, (xEvent **) &dcce);
|
|
if (rc != Success) {
|
|
ErrorF("[Xi] event conversion from DCE failed with code %d\n", rc);
|
|
return;
|
|
}
|
|
|
|
/* we don't actually swap if there's a NullClient, swapping is done
|
|
* later when event is delivered. */
|
|
SendEventToAllWindows(device, XI_DeviceChangedMask, (xEvent *) dcce, 1);
|
|
free(dcce);
|
|
}
|
|
|
|
static void
|
|
ChangeMasterDeviceClasses(DeviceIntPtr device, DeviceChangedEvent *dce)
|
|
{
|
|
DeviceIntPtr slave;
|
|
int rc;
|
|
|
|
/* For now, we don't have devices that change physically. */
|
|
if (!IsMaster(device))
|
|
return;
|
|
|
|
rc = dixLookupDevice(&slave, dce->sourceid, serverClient, DixReadAccess);
|
|
|
|
if (rc != Success)
|
|
return; /* Device has disappeared */
|
|
|
|
if (IsMaster(slave))
|
|
return;
|
|
|
|
if (IsFloating(slave))
|
|
return; /* set floating since the event */
|
|
|
|
if (GetMaster(slave, MASTER_ATTACHED)->id != dce->masterid)
|
|
return; /* not our slave anymore, don't care */
|
|
|
|
/* FIXME: we probably need to send a DCE for the new slave now */
|
|
|
|
device->public.devicePrivate = slave->public.devicePrivate;
|
|
|
|
/* FIXME: the classes may have changed since we generated the event. */
|
|
DeepCopyDeviceClasses(slave, device, dce);
|
|
dce->deviceid = device->id;
|
|
XISendDeviceChangedEvent(device, dce);
|
|
}
|
|
|
|
/**
|
|
* Add state and motionMask to the filter for this event. The protocol
|
|
* supports some extra masks for motion when a button is down:
|
|
* ButtonXMotionMask and the DeviceButtonMotionMask to trigger only when at
|
|
* least one button (or that specific button is down). These masks need to
|
|
* be added to the filters for core/XI motion events.
|
|
*
|
|
* @param device The device to update the mask for
|
|
* @param state The current button state mask
|
|
* @param motion_mask The motion mask (DeviceButtonMotionMask or 0)
|
|
*/
|
|
static void
|
|
UpdateDeviceMotionMask(DeviceIntPtr device, unsigned short state,
|
|
Mask motion_mask)
|
|
{
|
|
Mask mask;
|
|
|
|
mask = PointerMotionMask | state | motion_mask;
|
|
SetMaskForEvent(device->id, mask, DeviceMotionNotify);
|
|
SetMaskForEvent(device->id, mask, MotionNotify);
|
|
}
|
|
|
|
static void
|
|
IncreaseButtonCount(DeviceIntPtr dev, int key, CARD8 *buttons_down,
|
|
Mask *motion_mask, unsigned short *state)
|
|
{
|
|
if (dev->valuator)
|
|
dev->valuator->motionHintWindow = NullWindow;
|
|
|
|
(*buttons_down)++;
|
|
*motion_mask = DeviceButtonMotionMask;
|
|
if (dev->button->map[key] <= 5)
|
|
*state |= (Button1Mask >> 1) << dev->button->map[key];
|
|
}
|
|
|
|
static void
|
|
DecreaseButtonCount(DeviceIntPtr dev, int key, CARD8 *buttons_down,
|
|
Mask *motion_mask, unsigned short *state)
|
|
{
|
|
if (dev->valuator)
|
|
dev->valuator->motionHintWindow = NullWindow;
|
|
|
|
if (*buttons_down >= 1 && !--(*buttons_down))
|
|
*motion_mask = 0;
|
|
if (dev->button->map[key] <= 5)
|
|
*state &= ~((Button1Mask >> 1) << dev->button->map[key]);
|
|
}
|
|
|
|
/**
|
|
* Update the device state according to the data in the event.
|
|
*
|
|
* return values are
|
|
* DEFAULT ... process as normal
|
|
* DONT_PROCESS ... return immediately from caller
|
|
*/
|
|
#define DEFAULT 0
|
|
#define DONT_PROCESS 1
|
|
int
|
|
UpdateDeviceState(DeviceIntPtr device, DeviceEvent *event)
|
|
{
|
|
int i;
|
|
int key = 0, last_valuator;
|
|
|
|
KeyClassPtr k = NULL;
|
|
ButtonClassPtr b = NULL;
|
|
ValuatorClassPtr v = NULL;
|
|
TouchClassPtr t = NULL;
|
|
|
|
/* This event is always the first we get, before the actual events with
|
|
* the data. However, the way how the DDX is set up, "device" will
|
|
* actually be the slave device that caused the event.
|
|
*/
|
|
switch (event->type) {
|
|
case ET_DeviceChanged:
|
|
ChangeMasterDeviceClasses(device, (DeviceChangedEvent *) event);
|
|
return DONT_PROCESS; /* event has been sent already */
|
|
case ET_Motion:
|
|
case ET_ButtonPress:
|
|
case ET_ButtonRelease:
|
|
case ET_KeyPress:
|
|
case ET_KeyRelease:
|
|
case ET_ProximityIn:
|
|
case ET_ProximityOut:
|
|
case ET_TouchBegin:
|
|
case ET_TouchUpdate:
|
|
case ET_TouchEnd:
|
|
break;
|
|
default:
|
|
/* other events don't update the device */
|
|
return DEFAULT;
|
|
}
|
|
|
|
k = device->key;
|
|
v = device->valuator;
|
|
b = device->button;
|
|
t = device->touch;
|
|
|
|
key = event->detail.key;
|
|
|
|
/* Update device axis */
|
|
/* Check valuators first */
|
|
last_valuator = -1;
|
|
for (i = 0; i < MAX_VALUATORS; i++) {
|
|
if (BitIsOn(&event->valuators.mask, i)) {
|
|
if (!v) {
|
|
ErrorF("[Xi] Valuators reported for non-valuator device '%s'. "
|
|
"Ignoring event.\n", device->name);
|
|
return DONT_PROCESS;
|
|
}
|
|
else if (v->numAxes < i) {
|
|
ErrorF("[Xi] Too many valuators reported for device '%s'. "
|
|
"Ignoring event.\n", device->name);
|
|
return DONT_PROCESS;
|
|
}
|
|
last_valuator = i;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i <= last_valuator && i < v->numAxes; i++) {
|
|
/* XXX: Relative/Absolute mode */
|
|
if (BitIsOn(&event->valuators.mask, i))
|
|
v->axisVal[i] = event->valuators.data[i];
|
|
}
|
|
|
|
if (event->type == ET_KeyPress) {
|
|
if (!k)
|
|
return DONT_PROCESS;
|
|
|
|
/* don't allow ddx to generate multiple downs, but repeats are okay */
|
|
if (key_is_down(device, key, KEY_PROCESSED) && !event->key_repeat)
|
|
return DONT_PROCESS;
|
|
|
|
if (device->valuator)
|
|
device->valuator->motionHintWindow = NullWindow;
|
|
set_key_down(device, key, KEY_PROCESSED);
|
|
}
|
|
else if (event->type == ET_KeyRelease) {
|
|
if (!k)
|
|
return DONT_PROCESS;
|
|
|
|
if (!key_is_down(device, key, KEY_PROCESSED)) /* guard against duplicates */
|
|
return DONT_PROCESS;
|
|
if (device->valuator)
|
|
device->valuator->motionHintWindow = NullWindow;
|
|
set_key_up(device, key, KEY_PROCESSED);
|
|
}
|
|
else if (event->type == ET_ButtonPress) {
|
|
if (!b)
|
|
return DONT_PROCESS;
|
|
|
|
if (button_is_down(device, key, BUTTON_PROCESSED))
|
|
return DONT_PROCESS;
|
|
|
|
set_button_down(device, key, BUTTON_PROCESSED);
|
|
|
|
if (!b->map[key])
|
|
return DONT_PROCESS;
|
|
|
|
IncreaseButtonCount(device, key, &b->buttonsDown, &b->motionMask,
|
|
&b->state);
|
|
UpdateDeviceMotionMask(device, b->state, b->motionMask);
|
|
}
|
|
else if (event->type == ET_ButtonRelease) {
|
|
if (!b)
|
|
return DONT_PROCESS;
|
|
|
|
if (!button_is_down(device, key, BUTTON_PROCESSED))
|
|
return DONT_PROCESS;
|
|
if (IsMaster(device)) {
|
|
DeviceIntPtr sd;
|
|
|
|
/*
|
|
* Leave the button down if any slave has the
|
|
* button still down. Note that this depends on the
|
|
* event being delivered through the slave first
|
|
*/
|
|
for (sd = inputInfo.devices; sd; sd = sd->next) {
|
|
if (IsMaster(sd) || GetMaster(sd, MASTER_POINTER) != device)
|
|
continue;
|
|
if (!sd->button)
|
|
continue;
|
|
for (i = 1; i <= sd->button->numButtons; i++)
|
|
if (sd->button->map[i] == key &&
|
|
button_is_down(sd, i, BUTTON_PROCESSED))
|
|
return DONT_PROCESS;
|
|
}
|
|
}
|
|
set_button_up(device, key, BUTTON_PROCESSED);
|
|
if (!b->map[key])
|
|
return DONT_PROCESS;
|
|
|
|
DecreaseButtonCount(device, key, &b->buttonsDown, &b->motionMask,
|
|
&b->state);
|
|
UpdateDeviceMotionMask(device, b->state, b->motionMask);
|
|
}
|
|
else if (event->type == ET_ProximityIn)
|
|
device->proximity->in_proximity = TRUE;
|
|
else if (event->type == ET_ProximityOut)
|
|
device->proximity->in_proximity = FALSE;
|
|
else if (event->type == ET_TouchBegin) {
|
|
BUG_RETURN_VAL(!b || !v, DONT_PROCESS);
|
|
BUG_RETURN_VAL(!t, DONT_PROCESS);
|
|
|
|
if (!b->map[key])
|
|
return DONT_PROCESS;
|
|
|
|
if (!(event->flags & TOUCH_POINTER_EMULATED) ||
|
|
(event->flags & TOUCH_REPLAYING))
|
|
return DONT_PROCESS;
|
|
|
|
IncreaseButtonCount(device, key, &t->buttonsDown, &t->motionMask,
|
|
&t->state);
|
|
UpdateDeviceMotionMask(device, t->state, DeviceButtonMotionMask);
|
|
}
|
|
else if (event->type == ET_TouchEnd) {
|
|
BUG_RETURN_VAL(!b || !v, DONT_PROCESS);
|
|
BUG_RETURN_VAL(!t, DONT_PROCESS);
|
|
|
|
if (t->buttonsDown <= 0 || !b->map[key])
|
|
return DONT_PROCESS;
|
|
|
|
if (!(event->flags & TOUCH_POINTER_EMULATED))
|
|
return DONT_PROCESS;
|
|
|
|
DecreaseButtonCount(device, key, &t->buttonsDown, &t->motionMask,
|
|
&t->state);
|
|
UpdateDeviceMotionMask(device, t->state, DeviceButtonMotionMask);
|
|
}
|
|
|
|
return DEFAULT;
|
|
}
|
|
|
|
/**
|
|
* A client that does not have the TouchOwnership mask set may not receive a
|
|
* TouchBegin event if there is at least one grab active.
|
|
*
|
|
* @return TRUE if the client selected for ownership events on the given
|
|
* window for this device, FALSE otherwise
|
|
*/
|
|
static inline Bool
|
|
TouchClientWantsOwnershipEvents(ClientPtr client, DeviceIntPtr dev,
|
|
WindowPtr win)
|
|
{
|
|
InputClients *iclient;
|
|
|
|
nt_list_for_each_entry(iclient, wOtherInputMasks(win)->inputClients, next) {
|
|
if (rClient(iclient) != client)
|
|
continue;
|
|
|
|
return xi2mask_isset(iclient->xi2mask, dev, XI_TouchOwnership);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
TouchSendOwnershipEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, int reason,
|
|
XID resource)
|
|
{
|
|
int nev, i;
|
|
InternalEvent *tel = InitEventList(GetMaximumEventsNum());
|
|
|
|
nev = GetTouchOwnershipEvents(tel, dev, ti, reason, resource, 0);
|
|
for (i = 0; i < nev; i++)
|
|
mieqProcessDeviceEvent(dev, tel + i, NULL);
|
|
|
|
FreeEventList(tel, GetMaximumEventsNum());
|
|
}
|
|
|
|
/**
|
|
* Attempts to deliver a touch event to the given client.
|
|
*/
|
|
static Bool
|
|
DeliverOneTouchEvent(ClientPtr client, DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
GrabPtr grab, WindowPtr win, InternalEvent *ev)
|
|
{
|
|
int err;
|
|
xEvent *xi2;
|
|
Mask filter;
|
|
Window child = DeepestSpriteWin(&ti->sprite)->drawable.id;
|
|
|
|
/* FIXME: owner event handling */
|
|
|
|
/* If the client does not have the ownership mask set and is not
|
|
* the current owner of the touch, only pretend we delivered */
|
|
if (!grab && ti->num_grabs != 0 &&
|
|
!TouchClientWantsOwnershipEvents(client, dev, win))
|
|
return TRUE;
|
|
|
|
/* If we fail here, we're going to leave a client hanging. */
|
|
err = EventToXI2(ev, &xi2);
|
|
if (err != Success)
|
|
FatalError("[Xi] %s: XI2 conversion failed in %s"
|
|
" (%d)\n", dev->name, __func__, err);
|
|
|
|
FixUpEventFromWindow(&ti->sprite, xi2, win, child, FALSE);
|
|
filter = GetEventFilter(dev, xi2);
|
|
if (XaceHook(XACE_RECEIVE_ACCESS, client, win, xi2, 1) != Success)
|
|
return FALSE;
|
|
err = TryClientEvents(client, dev, xi2, 1, filter, filter, NullGrab);
|
|
free(xi2);
|
|
|
|
/* Returning the value from TryClientEvents isn't useful, since all our
|
|
* resource-gone cleanups will update the delivery list anyway. */
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
ActivateEarlyAccept(DeviceIntPtr dev, TouchPointInfoPtr ti)
|
|
{
|
|
ClientPtr client;
|
|
XID error;
|
|
GrabPtr grab = ti->listeners[0].grab;
|
|
|
|
BUG_RETURN(ti->listeners[0].type != TOUCH_LISTENER_GRAB &&
|
|
ti->listeners[0].type != TOUCH_LISTENER_POINTER_GRAB);
|
|
BUG_RETURN(!grab);
|
|
|
|
client = rClient(grab);
|
|
|
|
if (TouchAcceptReject(client, dev, XIAcceptTouch, ti->client_id,
|
|
ti->listeners[0].window->drawable.id, &error) != Success)
|
|
ErrorF("[Xi] Failed to accept touch grab after early acceptance.\n");
|
|
}
|
|
|
|
/**
|
|
* Find the oldest touch that still has a pointer emulation client.
|
|
*
|
|
* Pointer emulation can only be performed for the oldest touch. Otherwise, the
|
|
* order of events seen by the client will be wrong. This function helps us find
|
|
* the next touch to be emulated.
|
|
*
|
|
* @param dev The device to find touches for.
|
|
*/
|
|
static TouchPointInfoPtr
|
|
FindOldestPointerEmulatedTouch(DeviceIntPtr dev)
|
|
{
|
|
TouchPointInfoPtr oldest = NULL;
|
|
int i;
|
|
|
|
for (i = 0; i < dev->touch->num_touches; i++) {
|
|
TouchPointInfoPtr ti = dev->touch->touches + i;
|
|
int j;
|
|
|
|
if (!ti->active || !ti->emulate_pointer)
|
|
continue;
|
|
|
|
for (j = 0; j < ti->num_listeners; j++) {
|
|
if (ti->listeners[j].type == TOUCH_LISTENER_POINTER_GRAB ||
|
|
ti->listeners[j].type == TOUCH_LISTENER_POINTER_REGULAR)
|
|
break;
|
|
}
|
|
if (j == ti->num_listeners)
|
|
continue;
|
|
|
|
if (!oldest) {
|
|
oldest = ti;
|
|
continue;
|
|
}
|
|
|
|
if (oldest->client_id - ti->client_id < UINT_MAX / 2)
|
|
oldest = ti;
|
|
}
|
|
|
|
return oldest;
|
|
}
|
|
|
|
/**
|
|
* If the current owner has rejected the event, deliver the
|
|
* TouchOwnership/TouchBegin to the next item in the sprite stack.
|
|
*/
|
|
static void
|
|
TouchPuntToNextOwner(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
TouchOwnershipEvent *ev)
|
|
{
|
|
TouchListener *listener = &ti->listeners[0]; /* new owner */
|
|
int accepted_early = listener->state == TOUCH_LISTENER_EARLY_ACCEPT;
|
|
|
|
/* Deliver the ownership */
|
|
if (listener->state == TOUCH_LISTENER_AWAITING_OWNER || accepted_early)
|
|
DeliverTouchEvents(dev, ti, (InternalEvent *) ev,
|
|
listener->listener);
|
|
else if (listener->state == TOUCH_LISTENER_AWAITING_BEGIN) {
|
|
/* We can't punt to a pointer listener unless all older pointer
|
|
* emulated touches have been seen already. */
|
|
if ((listener->type == TOUCH_LISTENER_POINTER_GRAB ||
|
|
listener->type == TOUCH_LISTENER_POINTER_REGULAR) &&
|
|
ti != FindOldestPointerEmulatedTouch(dev))
|
|
return;
|
|
|
|
TouchEventHistoryReplay(ti, dev, listener->listener);
|
|
}
|
|
|
|
/* New owner has Begin/Update but not end. If touch is pending_finish,
|
|
* emulate the TouchEnd now */
|
|
if (ti->pending_finish) {
|
|
TouchEmitTouchEnd(dev, ti, 0, 0);
|
|
|
|
/* If the last owner is not a touch grab, finalise the touch, we
|
|
won't get more correspondence on this.
|
|
*/
|
|
if (ti->num_listeners == 1 &&
|
|
(ti->num_grabs == 0 ||
|
|
listener->grab->grabtype != XI2 ||
|
|
!xi2mask_isset(listener->grab->xi2mask, dev, XI_TouchBegin))) {
|
|
TouchEndTouch(dev, ti);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (accepted_early)
|
|
ActivateEarlyAccept(dev, ti);
|
|
}
|
|
|
|
/**
|
|
* Check the oldest touch to see if it needs to be replayed to its pointer
|
|
* owner.
|
|
*
|
|
* Touch event propagation is paused if it hits a pointer listener while an
|
|
* older touch with a pointer listener is waiting on accept or reject. This
|
|
* function will restart propagation of a paused touch if needed.
|
|
*
|
|
* @param dev The device to check touches for.
|
|
*/
|
|
static void
|
|
CheckOldestTouch(DeviceIntPtr dev)
|
|
{
|
|
TouchPointInfoPtr oldest = FindOldestPointerEmulatedTouch(dev);
|
|
|
|
if (oldest && oldest->listeners[0].state == TOUCH_LISTENER_AWAITING_BEGIN)
|
|
TouchPuntToNextOwner(dev, oldest, NULL);
|
|
}
|
|
|
|
/**
|
|
* Process a touch rejection.
|
|
*
|
|
* @param sourcedev The source device of the touch sequence.
|
|
* @param ti The touchpoint info record.
|
|
* @param resource The resource of the client rejecting the touch.
|
|
* @param ev TouchOwnership event to send. Set to NULL if no event should be
|
|
* sent.
|
|
*/
|
|
void
|
|
TouchRejected(DeviceIntPtr sourcedev, TouchPointInfoPtr ti, XID resource,
|
|
TouchOwnershipEvent *ev)
|
|
{
|
|
Bool was_owner = (resource == ti->listeners[0].listener);
|
|
int i;
|
|
|
|
/* Send a TouchEnd event to the resource being removed, but only if they
|
|
* haven't received one yet already */
|
|
for (i = 0; i < ti->num_listeners; i++) {
|
|
if (ti->listeners[i].listener == resource) {
|
|
if (ti->listeners[i].state != TOUCH_LISTENER_HAS_END)
|
|
TouchEmitTouchEnd(sourcedev, ti, TOUCH_REJECT, resource);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Remove the resource from the listener list, updating
|
|
* ti->num_listeners, as well as ti->num_grabs if it was a grab. */
|
|
TouchRemoveListener(ti, resource);
|
|
|
|
/* If the current owner was removed and there are further listeners, deliver
|
|
* the TouchOwnership or TouchBegin event to the new owner. */
|
|
if (ev && ti->num_listeners > 0 && was_owner)
|
|
TouchPuntToNextOwner(sourcedev, ti, ev);
|
|
else if (ti->num_listeners == 0)
|
|
TouchEndTouch(sourcedev, ti);
|
|
|
|
CheckOldestTouch(sourcedev);
|
|
}
|
|
|
|
/**
|
|
* Processes a TouchOwnership event, indicating a grab has accepted the touch
|
|
* it currently owns, or a grab or selection has been removed. Will generate
|
|
* and send TouchEnd events to all clients removed from the delivery list, as
|
|
* well as possibly sending the new TouchOwnership event. May end the
|
|
* touchpoint if it is pending finish.
|
|
*/
|
|
static void
|
|
ProcessTouchOwnershipEvent(TouchOwnershipEvent *ev,
|
|
DeviceIntPtr dev)
|
|
{
|
|
TouchPointInfoPtr ti = TouchFindByClientID(dev, ev->touchid);
|
|
|
|
if (!ti) {
|
|
DebugF("[Xi] %s: Failed to get event %d for touchpoint %d\n",
|
|
dev->name, ev->type, ev->touchid);
|
|
return;
|
|
}
|
|
|
|
if (ev->reason == XIRejectTouch)
|
|
TouchRejected(dev, ti, ev->resource, ev);
|
|
else if (ev->reason == XIAcceptTouch) {
|
|
int i;
|
|
|
|
|
|
/* For pointer-emulated listeners that ungrabbed the active grab,
|
|
* the state was forced to TOUCH_LISTENER_HAS_END. Still go
|
|
* through the motions of ending the touch if the listener has
|
|
* already seen the end. This ensures that the touch record is ended in
|
|
* the server.
|
|
*/
|
|
if (ti->listeners[0].state == TOUCH_LISTENER_HAS_END)
|
|
TouchEmitTouchEnd(dev, ti, TOUCH_ACCEPT, ti->listeners[0].listener);
|
|
|
|
/* The touch owner has accepted the touch. Send TouchEnd events to
|
|
* everyone else, and truncate the list of listeners. */
|
|
for (i = 1; i < ti->num_listeners; i++)
|
|
TouchEmitTouchEnd(dev, ti, TOUCH_ACCEPT, ti->listeners[i].listener);
|
|
|
|
while (ti->num_listeners > 1)
|
|
TouchRemoveListener(ti, ti->listeners[1].listener);
|
|
/* Owner accepted after receiving end */
|
|
if (ti->listeners[0].state == TOUCH_LISTENER_HAS_END)
|
|
TouchEndTouch(dev, ti);
|
|
else
|
|
ti->listeners[0].state = TOUCH_LISTENER_HAS_ACCEPTED;
|
|
}
|
|
else { /* this is the very first ownership event for a grab */
|
|
DeliverTouchEvents(dev, ti, (InternalEvent *) ev, ev->resource);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Copy the event's valuator information into the touchpoint, we may need
|
|
* this for emulated TouchEnd events.
|
|
*/
|
|
static void
|
|
TouchCopyValuatorData(DeviceEvent *ev, TouchPointInfoPtr ti)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ev->valuators.data); i++)
|
|
if (BitIsOn(ev->valuators.mask, i))
|
|
valuator_mask_set_double(ti->valuators, i, ev->valuators.data[i]);
|
|
}
|
|
|
|
/**
|
|
* Given a touch event and a potential listener, retrieve info needed for
|
|
* processing the event.
|
|
*
|
|
* @param dev The device generating the touch event.
|
|
* @param ti The touch point info record for the touch event.
|
|
* @param ev The touch event to process.
|
|
* @param listener The touch event listener that may receive the touch event.
|
|
* @param[out] client The client that should receive the touch event.
|
|
* @param[out] win The window to deliver the event on.
|
|
* @param[out] grab The grab to deliver the event through, if any.
|
|
* @param[out] mask The XI 2.x event mask of the grab or selection, if any.
|
|
* @return TRUE if an event should be delivered to the listener, FALSE
|
|
* otherwise.
|
|
*/
|
|
static Bool
|
|
RetrieveTouchDeliveryData(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
InternalEvent *ev, TouchListener * listener,
|
|
ClientPtr *client, WindowPtr *win, GrabPtr *grab,
|
|
XI2Mask **mask)
|
|
{
|
|
int rc;
|
|
InputClients *iclients = NULL;
|
|
*mask = NULL;
|
|
|
|
if (listener->type == TOUCH_LISTENER_GRAB ||
|
|
listener->type == TOUCH_LISTENER_POINTER_GRAB) {
|
|
*grab = listener->grab;
|
|
|
|
BUG_RETURN_VAL(!*grab, FALSE);
|
|
|
|
*client = rClient(*grab);
|
|
*win = (*grab)->window;
|
|
*mask = (*grab)->xi2mask;
|
|
}
|
|
else {
|
|
rc = dixLookupResourceByType((void **) win, listener->listener,
|
|
listener->resource_type,
|
|
serverClient, DixSendAccess);
|
|
if (rc != Success)
|
|
return FALSE;
|
|
|
|
if (listener->level == XI2) {
|
|
int evtype;
|
|
|
|
if (ti->emulate_pointer &&
|
|
listener->type == TOUCH_LISTENER_POINTER_REGULAR)
|
|
evtype = GetXI2Type(TouchGetPointerEventType(ev));
|
|
else
|
|
evtype = GetXI2Type(ev->any.type);
|
|
|
|
nt_list_for_each_entry(iclients,
|
|
wOtherInputMasks(*win)->inputClients, next)
|
|
if (xi2mask_isset(iclients->xi2mask, dev, evtype))
|
|
break;
|
|
|
|
BUG_RETURN_VAL(!iclients, FALSE);
|
|
|
|
*mask = iclients->xi2mask;
|
|
*client = rClient(iclients);
|
|
}
|
|
else if (listener->level == XI) {
|
|
int xi_type = GetXIType(TouchGetPointerEventType(ev));
|
|
Mask xi_filter = event_get_filter_from_type(dev, xi_type);
|
|
|
|
nt_list_for_each_entry(iclients,
|
|
wOtherInputMasks(*win)->inputClients, next)
|
|
if (iclients->mask[dev->id] & xi_filter)
|
|
break;
|
|
BUG_RETURN_VAL(!iclients, FALSE);
|
|
|
|
*client = rClient(iclients);
|
|
}
|
|
else {
|
|
int coretype = GetCoreType(TouchGetPointerEventType(ev));
|
|
Mask core_filter = event_get_filter_from_type(dev, coretype);
|
|
OtherClients *oclients;
|
|
|
|
/* all others */
|
|
nt_list_for_each_entry(oclients,
|
|
(OtherClients *) wOtherClients(*win), next)
|
|
if (oclients->mask & core_filter)
|
|
break;
|
|
|
|
/* if owner selected, oclients is NULL */
|
|
*client = oclients ? rClient(oclients) : wClient(*win);
|
|
}
|
|
|
|
*grab = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int
|
|
DeliverTouchEmulatedEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
InternalEvent *ev, TouchListener * listener,
|
|
ClientPtr client, WindowPtr win, GrabPtr grab,
|
|
XI2Mask *xi2mask)
|
|
{
|
|
InternalEvent motion, button;
|
|
InternalEvent *ptrev = &motion;
|
|
int nevents;
|
|
DeviceIntPtr kbd;
|
|
|
|
/* There may be a pointer grab on the device */
|
|
if (!grab) {
|
|
grab = dev->deviceGrab.grab;
|
|
if (grab) {
|
|
win = grab->window;
|
|
xi2mask = grab->xi2mask;
|
|
client = rClient(grab);
|
|
}
|
|
}
|
|
|
|
/* We don't deliver pointer events to non-owners */
|
|
if (!TouchResourceIsOwner(ti, listener->listener))
|
|
return !Success;
|
|
|
|
if (!ti->emulate_pointer)
|
|
return !Success;
|
|
|
|
nevents = TouchConvertToPointerEvent(ev, &motion, &button);
|
|
BUG_RETURN_VAL(nevents == 0, BadValue);
|
|
|
|
/* Note that here we deliver only part of the events that are generated by the touch event:
|
|
*
|
|
* TouchBegin results in ButtonPress (motion is handled in DeliverEmulatedMotionEvent)
|
|
* TouchUpdate results in Motion
|
|
* TouchEnd results in ButtonRelease (motion is handled in DeliverEmulatedMotionEvent)
|
|
*/
|
|
if (nevents > 1)
|
|
ptrev = &button;
|
|
|
|
kbd = GetMaster(dev, KEYBOARD_OR_FLOAT);
|
|
event_set_state(dev, kbd, &ptrev->device_event);
|
|
ptrev->device_event.corestate = event_get_corestate(dev, kbd);
|
|
|
|
if (grab) {
|
|
/* this side-steps the usual activation mechanisms, but... */
|
|
if (ev->any.type == ET_TouchBegin && !dev->deviceGrab.grab)
|
|
ActivatePassiveGrab(dev, grab, ptrev, ev); /* also delivers the event */
|
|
else {
|
|
int deliveries = 0;
|
|
|
|
/* 'grab' is the passive grab, but if the grab isn't active,
|
|
* don't deliver */
|
|
if (!dev->deviceGrab.grab)
|
|
return !Success;
|
|
|
|
if (grab->ownerEvents) {
|
|
WindowPtr focus = NullWindow;
|
|
WindowPtr sprite_win = DeepestSpriteWin(dev->spriteInfo->sprite);
|
|
|
|
deliveries = DeliverDeviceEvents(sprite_win, ptrev, grab, focus, dev);
|
|
}
|
|
|
|
if (!deliveries)
|
|
deliveries = DeliverOneGrabbedEvent(ptrev, dev, grab->grabtype);
|
|
|
|
/* We must accept the touch sequence once a pointer listener has
|
|
* received one event past ButtonPress. */
|
|
if (deliveries && ev->any.type != ET_TouchBegin &&
|
|
!(ev->device_event.flags & TOUCH_CLIENT_ID))
|
|
TouchListenerAcceptReject(dev, ti, 0, XIAcceptTouch);
|
|
|
|
if (ev->any.type == ET_TouchEnd &&
|
|
ti->num_listeners == 1 &&
|
|
!dev->button->buttonsDown &&
|
|
dev->deviceGrab.fromPassiveGrab && GrabIsPointerGrab(grab)) {
|
|
(*dev->deviceGrab.DeactivateGrab) (dev);
|
|
CheckOldestTouch(dev);
|
|
return Success;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
GrabPtr devgrab = dev->deviceGrab.grab;
|
|
WindowPtr sprite_win = DeepestSpriteWin(dev->spriteInfo->sprite);
|
|
|
|
DeliverDeviceEvents(sprite_win, ptrev, grab, win, dev);
|
|
/* FIXME: bad hack
|
|
* Implicit passive grab activated in response to this event. Store
|
|
* the event.
|
|
*/
|
|
if (!devgrab && dev->deviceGrab.grab && dev->deviceGrab.implicitGrab) {
|
|
TouchListener *l;
|
|
GrabPtr g;
|
|
|
|
devgrab = dev->deviceGrab.grab;
|
|
g = AllocGrab(devgrab);
|
|
BUG_WARN(!g);
|
|
|
|
*dev->deviceGrab.sync.event = *ev;
|
|
|
|
/* The listener array has a sequence of grabs and then one event
|
|
* selection. Implicit grab activation occurs through delivering an
|
|
* event selection. Thus, we update the last listener in the array.
|
|
*/
|
|
l = &ti->listeners[ti->num_listeners - 1];
|
|
l->listener = g->resource;
|
|
l->grab = g;
|
|
//l->resource_type = RT_NONE;
|
|
|
|
if (devgrab->grabtype != XI2 || devgrab->type != XI_TouchBegin)
|
|
l->type = TOUCH_LISTENER_POINTER_GRAB;
|
|
else
|
|
l->type = TOUCH_LISTENER_GRAB;
|
|
}
|
|
|
|
}
|
|
if (ev->any.type == ET_TouchBegin)
|
|
listener->state = TOUCH_LISTENER_IS_OWNER;
|
|
else if (ev->any.type == ET_TouchEnd)
|
|
listener->state = TOUCH_LISTENER_HAS_END;
|
|
|
|
return Success;
|
|
}
|
|
|
|
static void
|
|
DeliverEmulatedMotionEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
InternalEvent *ev)
|
|
{
|
|
DeviceEvent motion;
|
|
|
|
if (ti->num_listeners) {
|
|
ClientPtr client;
|
|
WindowPtr win;
|
|
GrabPtr grab;
|
|
XI2Mask *mask;
|
|
|
|
if (ti->listeners[0].type != TOUCH_LISTENER_POINTER_REGULAR &&
|
|
ti->listeners[0].type != TOUCH_LISTENER_POINTER_GRAB)
|
|
return;
|
|
|
|
motion = ev->device_event;
|
|
motion.type = ET_TouchUpdate;
|
|
motion.detail.button = 0;
|
|
|
|
if (!RetrieveTouchDeliveryData(dev, ti, (InternalEvent*)&motion,
|
|
&ti->listeners[0], &client, &win, &grab,
|
|
&mask))
|
|
return;
|
|
|
|
DeliverTouchEmulatedEvent(dev, ti, (InternalEvent*)&motion, &ti->listeners[0], client,
|
|
win, grab, mask);
|
|
}
|
|
else {
|
|
InternalEvent button;
|
|
int converted;
|
|
|
|
converted = TouchConvertToPointerEvent(ev, (InternalEvent*)&motion, &button);
|
|
|
|
BUG_WARN(converted == 0);
|
|
if (converted)
|
|
ProcessOtherEvent((InternalEvent*)&motion, dev);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Processes and delivers a TouchBegin, TouchUpdate, or a
|
|
* TouchEnd event.
|
|
*
|
|
* Due to having rather different delivery semantics (see the Xi 2.2 protocol
|
|
* spec for more information), this implements its own grab and event-selection
|
|
* delivery logic.
|
|
*/
|
|
static void
|
|
ProcessTouchEvent(InternalEvent *ev, DeviceIntPtr dev)
|
|
{
|
|
TouchClassPtr t = dev->touch;
|
|
TouchPointInfoPtr ti;
|
|
uint32_t touchid;
|
|
int type = ev->any.type;
|
|
int emulate_pointer = ! !(ev->device_event.flags & TOUCH_POINTER_EMULATED);
|
|
DeviceIntPtr kbd;
|
|
|
|
if (!t)
|
|
return;
|
|
|
|
touchid = ev->device_event.touchid;
|
|
|
|
if (type == ET_TouchBegin && !(ev->device_event.flags & TOUCH_REPLAYING)) {
|
|
ti = TouchBeginTouch(dev, ev->device_event.sourceid, touchid,
|
|
emulate_pointer);
|
|
}
|
|
else
|
|
ti = TouchFindByClientID(dev, touchid);
|
|
|
|
/* Active pointer grab */
|
|
if (emulate_pointer && dev->deviceGrab.grab && !dev->deviceGrab.fromPassiveGrab &&
|
|
(dev->deviceGrab.grab->grabtype == CORE ||
|
|
dev->deviceGrab.grab->grabtype == XI ||
|
|
!xi2mask_isset(dev->deviceGrab.grab->xi2mask, dev, XI_TouchBegin)))
|
|
{
|
|
/* Active pointer grab on touch point and we get a TouchEnd - claim this
|
|
* touchpoint accepted, otherwise clients waiting for ownership will
|
|
* wait on this touchpoint until this client ungrabs, or the cows come
|
|
* home, whichever is earlier */
|
|
if (ti && type == ET_TouchEnd)
|
|
TouchListenerAcceptReject(dev, ti, 0, XIAcceptTouch);
|
|
else if (!ti && type != ET_TouchBegin) {
|
|
/* Under the following circumstances we create a new touch record for an
|
|
* existing touch:
|
|
*
|
|
* - The touch may be pointer emulated
|
|
* - An explicit grab is active on the device
|
|
* - The grab is a pointer grab
|
|
*
|
|
* This allows for an explicit grab to receive pointer events for an already
|
|
* active touch.
|
|
*/
|
|
ti = TouchBeginTouch(dev, ev->device_event.sourceid, touchid,
|
|
emulate_pointer);
|
|
if (!ti) {
|
|
DebugF("[Xi] %s: Failed to create new dix record for explicitly "
|
|
"grabbed touchpoint %d\n",
|
|
dev->name, touchid);
|
|
return;
|
|
}
|
|
|
|
TouchBuildSprite(dev, ti, ev);
|
|
TouchSetupListeners(dev, ti, ev);
|
|
}
|
|
}
|
|
|
|
if (!ti) {
|
|
DebugF("[Xi] %s: Failed to get event %d for touchpoint %d\n",
|
|
dev->name, type, touchid);
|
|
goto out;
|
|
}
|
|
|
|
/* if emulate_pointer is set, emulate the motion event right
|
|
* here, so we can ignore it for button event emulation. TouchUpdate
|
|
* events which _only_ emulate motion just work normally */
|
|
if (emulate_pointer && (ev->any.type == ET_TouchBegin ||
|
|
(ev->any.type == ET_TouchEnd && ti->num_listeners > 0)))
|
|
DeliverEmulatedMotionEvent(dev, ti, ev);
|
|
|
|
if (emulate_pointer && IsMaster(dev))
|
|
CheckMotion(&ev->device_event, dev);
|
|
|
|
kbd = GetMaster(dev, KEYBOARD_OR_FLOAT);
|
|
event_set_state(NULL, kbd, &ev->device_event);
|
|
ev->device_event.corestate = event_get_corestate(NULL, kbd);
|
|
|
|
/* Make sure we have a valid window trace for event delivery; must be
|
|
* called after event type mutation. Touch end events are always processed
|
|
* in order to end touch records. */
|
|
/* FIXME: check this */
|
|
if ((type == ET_TouchBegin &&
|
|
!(ev->device_event.flags & TOUCH_REPLAYING) &&
|
|
!TouchBuildSprite(dev, ti, ev)) ||
|
|
(type != ET_TouchEnd && ti->sprite.spriteTraceGood == 0))
|
|
return;
|
|
|
|
TouchCopyValuatorData(&ev->device_event, ti);
|
|
/* WARNING: the event type may change to TouchUpdate in
|
|
* DeliverTouchEvents if a TouchEnd was delivered to a grabbing
|
|
* owner */
|
|
DeliverTouchEvents(dev, ti, ev, ev->device_event.resource);
|
|
if (ev->any.type == ET_TouchEnd)
|
|
TouchEndTouch(dev, ti);
|
|
|
|
out:
|
|
if (emulate_pointer)
|
|
UpdateDeviceState(dev, &ev->device_event);
|
|
}
|
|
|
|
static void
|
|
ProcessBarrierEvent(InternalEvent *e, DeviceIntPtr dev)
|
|
{
|
|
Mask filter;
|
|
WindowPtr pWin;
|
|
BarrierEvent *be = &e->barrier_event;
|
|
xEvent *ev;
|
|
int rc;
|
|
GrabPtr grab = dev->deviceGrab.grab;
|
|
|
|
if (!IsMaster(dev))
|
|
return;
|
|
|
|
if (dixLookupWindow(&pWin, be->window, serverClient, DixReadAccess) != Success)
|
|
return;
|
|
|
|
if (grab)
|
|
be->flags |= XIBarrierDeviceIsGrabbed;
|
|
|
|
rc = EventToXI2(e, &ev);
|
|
if (rc != Success) {
|
|
ErrorF("[Xi] event conversion from %s failed with code %d\n", __func__, rc);
|
|
return;
|
|
}
|
|
|
|
/* A client has a grab, deliver to this client if the grab_window is the
|
|
barrier window.
|
|
|
|
Otherwise, deliver normally to the client.
|
|
*/
|
|
if (grab &&
|
|
CLIENT_ID(be->barrierid) == CLIENT_ID(grab->resource) &&
|
|
grab->window->drawable.id == be->window) {
|
|
DeliverGrabbedEvent(e, dev, FALSE);
|
|
} else {
|
|
filter = GetEventFilter(dev, ev);
|
|
|
|
DeliverEventsToWindow(dev, pWin, ev, 1,
|
|
filter, NullGrab);
|
|
}
|
|
free(ev);
|
|
}
|
|
|
|
static BOOL
|
|
IsAnotherGestureActiveOnMaster(DeviceIntPtr dev, InternalEvent* ev)
|
|
{
|
|
GestureClassPtr g = dev->gesture;
|
|
if (g->gesture.active && g->gesture.sourceid != ev->gesture_event.sourceid) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Processes and delivers a Gesture{Pinch,Swipe}{Begin,Update,End}.
|
|
*
|
|
* Due to having rather different delivery semantics (see the Xi 2.4 protocol
|
|
* spec for more information), this implements its own grab and event-selection
|
|
* delivery logic.
|
|
*/
|
|
void
|
|
ProcessGestureEvent(InternalEvent *ev, DeviceIntPtr dev)
|
|
{
|
|
GestureInfoPtr gi;
|
|
DeviceIntPtr kbd;
|
|
Bool deactivateGestureGrab = FALSE;
|
|
|
|
if (!dev->gesture)
|
|
return;
|
|
|
|
if (IsMaster(dev) && IsAnotherGestureActiveOnMaster(dev, ev))
|
|
return;
|
|
|
|
if (IsGestureBeginEvent(ev))
|
|
gi = GestureBeginGesture(dev, ev);
|
|
else
|
|
gi = GestureFindActiveByEventType(dev, ev->any.type);
|
|
|
|
if (!gi) {
|
|
/* This may happen if gesture is no longer active or was never started. */
|
|
return;
|
|
}
|
|
|
|
kbd = GetMaster(dev, KEYBOARD_OR_FLOAT);
|
|
event_set_state_gesture(kbd, &ev->gesture_event);
|
|
|
|
if (IsGestureBeginEvent(ev))
|
|
GestureSetupListener(dev, gi, ev);
|
|
|
|
if (IsGestureEndEvent(ev) &&
|
|
dev->deviceGrab.grab &&
|
|
dev->deviceGrab.fromPassiveGrab &&
|
|
GrabIsGestureGrab(dev->deviceGrab.grab))
|
|
deactivateGestureGrab = TRUE;
|
|
|
|
DeliverGestureEventToOwner(dev, gi, ev);
|
|
|
|
if (IsGestureEndEvent(ev))
|
|
GestureEndGesture(gi);
|
|
|
|
if (deactivateGestureGrab)
|
|
(*dev->deviceGrab.DeactivateGrab) (dev);
|
|
}
|
|
|
|
/**
|
|
* Process DeviceEvents and DeviceChangedEvents.
|
|
*/
|
|
static void
|
|
ProcessDeviceEvent(InternalEvent *ev, DeviceIntPtr device)
|
|
{
|
|
GrabPtr grab;
|
|
Bool deactivateDeviceGrab = FALSE;
|
|
int key = 0, rootX, rootY;
|
|
ButtonClassPtr b;
|
|
int ret = 0;
|
|
int corestate;
|
|
DeviceIntPtr mouse = NULL, kbd = NULL;
|
|
DeviceEvent *event = &ev->device_event;
|
|
|
|
if (IsPointerDevice(device)) {
|
|
kbd = GetMaster(device, KEYBOARD_OR_FLOAT);
|
|
mouse = device;
|
|
if (!kbd->key) /* can happen with floating SDs */
|
|
kbd = NULL;
|
|
}
|
|
else {
|
|
mouse = GetMaster(device, POINTER_OR_FLOAT);
|
|
kbd = device;
|
|
if (!mouse->valuator || !mouse->button) /* may be float. SDs */
|
|
mouse = NULL;
|
|
}
|
|
|
|
corestate = event_get_corestate(mouse, kbd);
|
|
event_set_state(mouse, kbd, event);
|
|
|
|
ret = UpdateDeviceState(device, event);
|
|
if (ret == DONT_PROCESS)
|
|
return;
|
|
|
|
b = device->button;
|
|
|
|
if (IsMaster(device) || IsFloating(device))
|
|
CheckMotion(event, device);
|
|
|
|
switch (event->type) {
|
|
case ET_Motion:
|
|
case ET_ButtonPress:
|
|
case ET_ButtonRelease:
|
|
case ET_KeyPress:
|
|
case ET_KeyRelease:
|
|
case ET_ProximityIn:
|
|
case ET_ProximityOut:
|
|
GetSpritePosition(device, &rootX, &rootY);
|
|
event->root_x = rootX;
|
|
event->root_y = rootY;
|
|
NoticeEventTime((InternalEvent *) event, device);
|
|
event->corestate = corestate;
|
|
key = event->detail.key;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* send KeyPress and KeyRelease events to XACE plugins */
|
|
if (XaceHookIsSet(XACE_KEY_AVAIL) &&
|
|
(event->type == ET_KeyPress || event->type == ET_KeyRelease)) {
|
|
xEvent *core;
|
|
int count;
|
|
|
|
if (EventToCore(ev, &core, &count) == Success && count > 0) {
|
|
XaceHook(XACE_KEY_AVAIL, core, device, 0);
|
|
free(core);
|
|
}
|
|
}
|
|
|
|
if (DeviceEventCallback && !syncEvents.playingEvents) {
|
|
DeviceEventInfoRec eventinfo;
|
|
SpritePtr pSprite = device->spriteInfo->sprite;
|
|
|
|
/* see comment in EnqueueEvents regarding the next three lines */
|
|
if (ev->any.type == ET_Motion)
|
|
ev->device_event.root = pSprite->hotPhys.pScreen->root->drawable.id;
|
|
|
|
eventinfo.device = device;
|
|
eventinfo.event = ev;
|
|
CallCallbacks(&DeviceEventCallback, (void *) &eventinfo);
|
|
}
|
|
|
|
grab = device->deviceGrab.grab;
|
|
|
|
switch (event->type) {
|
|
case ET_KeyPress:
|
|
/* Don't deliver focus events (e.g. from KeymapNotify when running
|
|
* nested) to clients. */
|
|
if (event->source_type == EVENT_SOURCE_FOCUS)
|
|
return;
|
|
if (!grab && CheckDeviceGrabs(device, event, 0))
|
|
return;
|
|
break;
|
|
case ET_KeyRelease:
|
|
if (grab && device->deviceGrab.fromPassiveGrab &&
|
|
(key == device->deviceGrab.activatingKey) &&
|
|
GrabIsKeyboardGrab(device->deviceGrab.grab))
|
|
deactivateDeviceGrab = TRUE;
|
|
break;
|
|
case ET_ButtonPress:
|
|
if (b->map[key] == 0) /* there's no button 0 */
|
|
return;
|
|
event->detail.button = b->map[key];
|
|
if (!grab && CheckDeviceGrabs(device, event, 0)) {
|
|
/* if a passive grab was activated, the event has been sent
|
|
* already */
|
|
return;
|
|
}
|
|
break;
|
|
case ET_ButtonRelease:
|
|
if (b->map[key] == 0) /* there's no button 0 */
|
|
return;
|
|
event->detail.button = b->map[key];
|
|
if (grab && !b->buttonsDown &&
|
|
device->deviceGrab.fromPassiveGrab &&
|
|
GrabIsPointerGrab(device->deviceGrab.grab))
|
|
deactivateDeviceGrab = TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Don't deliver focus events (e.g. from KeymapNotify when running
|
|
* nested) to clients. */
|
|
if (event->source_type != EVENT_SOURCE_FOCUS) {
|
|
if (grab)
|
|
DeliverGrabbedEvent((InternalEvent *) event, device,
|
|
deactivateDeviceGrab);
|
|
else if (device->focus && !IsPointerEvent(ev))
|
|
DeliverFocusedEvent(device, (InternalEvent *) event,
|
|
GetSpriteWindow(device));
|
|
else
|
|
DeliverDeviceEvents(GetSpriteWindow(device), (InternalEvent *) event,
|
|
NullGrab, NullWindow, device);
|
|
}
|
|
|
|
if (deactivateDeviceGrab == TRUE) {
|
|
(*device->deviceGrab.DeactivateGrab) (device);
|
|
|
|
if (!IsMaster (device) && !IsFloating (device)) {
|
|
int flags, num_events = 0;
|
|
InternalEvent dce;
|
|
|
|
flags = (IsPointerDevice (device)) ?
|
|
DEVCHANGE_POINTER_EVENT : DEVCHANGE_KEYBOARD_EVENT;
|
|
UpdateFromMaster (&dce, device, flags, &num_events);
|
|
BUG_WARN(num_events > 1);
|
|
|
|
if (num_events == 1)
|
|
ChangeMasterDeviceClasses(GetMaster (device, MASTER_ATTACHED),
|
|
&dce.changed_event);
|
|
}
|
|
|
|
}
|
|
|
|
event->detail.key = key;
|
|
}
|
|
|
|
/**
|
|
* Main device event processing function.
|
|
* Called from when processing the events from the event queue.
|
|
*
|
|
*/
|
|
void
|
|
ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
|
|
{
|
|
verify_internal_event(ev);
|
|
|
|
switch (ev->any.type) {
|
|
case ET_RawKeyPress:
|
|
case ET_RawKeyRelease:
|
|
case ET_RawButtonPress:
|
|
case ET_RawButtonRelease:
|
|
case ET_RawMotion:
|
|
case ET_RawTouchBegin:
|
|
case ET_RawTouchUpdate:
|
|
case ET_RawTouchEnd:
|
|
DeliverRawEvent(&ev->raw_event, device);
|
|
break;
|
|
case ET_TouchBegin:
|
|
case ET_TouchUpdate:
|
|
case ET_TouchEnd:
|
|
ProcessTouchEvent(ev, device);
|
|
break;
|
|
case ET_TouchOwnership:
|
|
/* TouchOwnership events are handled separately from the rest, as they
|
|
* have more complex semantics. */
|
|
ProcessTouchOwnershipEvent(&ev->touch_ownership_event, device);
|
|
break;
|
|
case ET_BarrierHit:
|
|
case ET_BarrierLeave:
|
|
ProcessBarrierEvent(ev, device);
|
|
break;
|
|
case ET_GesturePinchBegin:
|
|
case ET_GesturePinchUpdate:
|
|
case ET_GesturePinchEnd:
|
|
case ET_GestureSwipeBegin:
|
|
case ET_GestureSwipeUpdate:
|
|
case ET_GestureSwipeEnd:
|
|
ProcessGestureEvent(ev, device);
|
|
break;
|
|
default:
|
|
ProcessDeviceEvent(ev, device);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int
|
|
DeliverTouchBeginEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
InternalEvent *ev, TouchListener * listener,
|
|
ClientPtr client, WindowPtr win, GrabPtr grab,
|
|
XI2Mask *xi2mask)
|
|
{
|
|
enum TouchListenerState state;
|
|
int rc = Success;
|
|
Bool has_ownershipmask;
|
|
|
|
if (listener->type == TOUCH_LISTENER_POINTER_REGULAR ||
|
|
listener->type == TOUCH_LISTENER_POINTER_GRAB) {
|
|
rc = DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win,
|
|
grab, xi2mask);
|
|
if (rc == Success) {
|
|
listener->state = TOUCH_LISTENER_IS_OWNER;
|
|
/* async grabs cannot replay, so automatically accept this touch */
|
|
if (listener->type == TOUCH_LISTENER_POINTER_GRAB &&
|
|
dev->deviceGrab.grab &&
|
|
dev->deviceGrab.fromPassiveGrab &&
|
|
dev->deviceGrab.grab->pointerMode == GrabModeAsync)
|
|
ActivateEarlyAccept(dev, ti);
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
has_ownershipmask = xi2mask_isset(xi2mask, dev, XI_TouchOwnership);
|
|
|
|
if (TouchResourceIsOwner(ti, listener->listener) || has_ownershipmask)
|
|
rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
|
|
if (!TouchResourceIsOwner(ti, listener->listener)) {
|
|
if (has_ownershipmask)
|
|
state = TOUCH_LISTENER_AWAITING_OWNER;
|
|
else
|
|
state = TOUCH_LISTENER_AWAITING_BEGIN;
|
|
}
|
|
else {
|
|
if (has_ownershipmask)
|
|
TouchSendOwnershipEvent(dev, ti, 0, listener->listener);
|
|
|
|
if (listener->type == TOUCH_LISTENER_REGULAR)
|
|
state = TOUCH_LISTENER_HAS_ACCEPTED;
|
|
else
|
|
state = TOUCH_LISTENER_IS_OWNER;
|
|
}
|
|
listener->state = state;
|
|
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
DeliverTouchEndEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
|
|
TouchListener * listener, ClientPtr client,
|
|
WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
|
|
{
|
|
int rc = Success;
|
|
|
|
if (listener->type == TOUCH_LISTENER_POINTER_REGULAR ||
|
|
listener->type == TOUCH_LISTENER_POINTER_GRAB) {
|
|
/* Note: If the active grab was ungrabbed, we already changed the
|
|
* state to TOUCH_LISTENER_HAS_END but still get here. So we mustn't
|
|
* actually send the event.
|
|
* This is part two of the hack in DeactivatePointerGrab
|
|
*/
|
|
if (listener->state != TOUCH_LISTENER_HAS_END) {
|
|
rc = DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win,
|
|
grab, xi2mask);
|
|
|
|
/* Once we send a TouchEnd to a legacy listener, we're already well
|
|
* past the accepting/rejecting stage (can only happen on
|
|
* GrabModeSync + replay. This listener now gets the end event,
|
|
* and we can continue.
|
|
*/
|
|
if (rc == Success)
|
|
listener->state = TOUCH_LISTENER_HAS_END;
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
/* A client is waiting for the begin, don't give it a TouchEnd */
|
|
if (listener->state == TOUCH_LISTENER_AWAITING_BEGIN) {
|
|
listener->state = TOUCH_LISTENER_HAS_END;
|
|
goto out;
|
|
}
|
|
|
|
/* Event in response to reject */
|
|
if (ev->device_event.flags & TOUCH_REJECT ||
|
|
(ev->device_event.flags & TOUCH_ACCEPT && !TouchResourceIsOwner(ti, listener->listener))) {
|
|
/* Touch has been rejected, or accepted by its owner which is not this listener */
|
|
if (listener->state != TOUCH_LISTENER_HAS_END)
|
|
rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
|
|
listener->state = TOUCH_LISTENER_HAS_END;
|
|
}
|
|
else if (TouchResourceIsOwner(ti, listener->listener)) {
|
|
Bool normal_end = !(ev->device_event.flags & TOUCH_ACCEPT);
|
|
|
|
/* FIXME: what about early acceptance */
|
|
if (normal_end && listener->state != TOUCH_LISTENER_HAS_END)
|
|
rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
|
|
|
|
if ((ti->num_listeners > 1 ||
|
|
(ti->num_grabs > 0 && listener->state != TOUCH_LISTENER_HAS_ACCEPTED)) &&
|
|
(ev->device_event.flags & (TOUCH_ACCEPT | TOUCH_REJECT)) == 0) {
|
|
ev->any.type = ET_TouchUpdate;
|
|
ev->device_event.flags |= TOUCH_PENDING_END;
|
|
ti->pending_finish = TRUE;
|
|
}
|
|
|
|
if (normal_end)
|
|
listener->state = TOUCH_LISTENER_HAS_END;
|
|
}
|
|
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
DeliverTouchEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
|
|
TouchListener * listener, ClientPtr client,
|
|
WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
|
|
{
|
|
Bool has_ownershipmask = FALSE;
|
|
int rc = Success;
|
|
|
|
if (xi2mask)
|
|
has_ownershipmask = xi2mask_isset(xi2mask, dev, XI_TouchOwnership);
|
|
|
|
if (ev->any.type == ET_TouchOwnership) {
|
|
ev->touch_ownership_event.deviceid = dev->id;
|
|
if (!TouchResourceIsOwner(ti, listener->listener))
|
|
goto out;
|
|
rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
|
|
listener->state = TOUCH_LISTENER_IS_OWNER;
|
|
}
|
|
else
|
|
ev->device_event.deviceid = dev->id;
|
|
|
|
if (ev->any.type == ET_TouchBegin) {
|
|
rc = DeliverTouchBeginEvent(dev, ti, ev, listener, client, win, grab,
|
|
xi2mask);
|
|
}
|
|
else if (ev->any.type == ET_TouchUpdate) {
|
|
if (listener->type == TOUCH_LISTENER_POINTER_REGULAR ||
|
|
listener->type == TOUCH_LISTENER_POINTER_GRAB)
|
|
DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win, grab,
|
|
xi2mask);
|
|
else if (TouchResourceIsOwner(ti, listener->listener) ||
|
|
has_ownershipmask)
|
|
rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
|
|
}
|
|
else if (ev->any.type == ET_TouchEnd)
|
|
rc = DeliverTouchEndEvent(dev, ti, ev, listener, client, win, grab,
|
|
xi2mask);
|
|
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Delivers a touch events to all interested clients. For TouchBegin events,
|
|
* will update ti->listeners, ti->num_listeners, and ti->num_grabs.
|
|
* May also mutate ev (type and flags) upon successful delivery. If
|
|
* @resource is non-zero, will only attempt delivery to the owner of that
|
|
* resource.
|
|
*
|
|
* @return TRUE if the event was delivered at least once, FALSE otherwise
|
|
*/
|
|
void
|
|
DeliverTouchEvents(DeviceIntPtr dev, TouchPointInfoPtr ti,
|
|
InternalEvent *ev, XID resource)
|
|
{
|
|
int i;
|
|
|
|
if (ev->any.type == ET_TouchBegin &&
|
|
!(ev->device_event.flags & (TOUCH_CLIENT_ID | TOUCH_REPLAYING)))
|
|
TouchSetupListeners(dev, ti, ev);
|
|
|
|
TouchEventHistoryPush(ti, &ev->device_event);
|
|
|
|
for (i = 0; i < ti->num_listeners; i++) {
|
|
GrabPtr grab = NULL;
|
|
ClientPtr client;
|
|
WindowPtr win;
|
|
XI2Mask *mask;
|
|
TouchListener *listener = &ti->listeners[i];
|
|
|
|
if (resource && listener->listener != resource)
|
|
continue;
|
|
|
|
if (!RetrieveTouchDeliveryData(dev, ti, ev, listener, &client, &win,
|
|
&grab, &mask))
|
|
continue;
|
|
|
|
DeliverTouchEvent(dev, ti, ev, listener, client, win, grab, mask);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempts to deliver a gesture event to the given client.
|
|
*/
|
|
static Bool
|
|
DeliverOneGestureEvent(ClientPtr client, DeviceIntPtr dev, GestureInfoPtr gi,
|
|
GrabPtr grab, WindowPtr win, InternalEvent *ev)
|
|
{
|
|
int err;
|
|
xEvent *xi2;
|
|
Mask filter;
|
|
Window child = DeepestSpriteWin(&gi->sprite)->drawable.id;
|
|
|
|
/* If we fail here, we're going to leave a client hanging. */
|
|
err = EventToXI2(ev, &xi2);
|
|
if (err != Success)
|
|
FatalError("[Xi] %s: XI2 conversion failed in %s"
|
|
" (%d)\n", dev->name, __func__, err);
|
|
|
|
FixUpEventFromWindow(&gi->sprite, xi2, win, child, FALSE);
|
|
filter = GetEventFilter(dev, xi2);
|
|
if (XaceHook(XACE_RECEIVE_ACCESS, client, win, xi2, 1) != Success)
|
|
return FALSE;
|
|
err = TryClientEvents(client, dev, xi2, 1, filter, filter, NullGrab);
|
|
free(xi2);
|
|
|
|
/* Returning the value from TryClientEvents isn't useful, since all our
|
|
* resource-gone cleanups will update the delivery list anyway. */
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Given a gesture event and a potential listener, retrieve info needed for processing the event.
|
|
*
|
|
* @param dev The device generating the gesture event.
|
|
* @param ev The gesture event to process.
|
|
* @param listener The gesture event listener that may receive the gesture event.
|
|
* @param[out] client The client that should receive the gesture event.
|
|
* @param[out] win The window to deliver the event on.
|
|
* @param[out] grab The grab to deliver the event through, if any.
|
|
* @return TRUE if an event should be delivered to the listener, FALSE
|
|
* otherwise.
|
|
*/
|
|
static Bool
|
|
RetrieveGestureDeliveryData(DeviceIntPtr dev, InternalEvent *ev, GestureListener* listener,
|
|
ClientPtr *client, WindowPtr *win, GrabPtr *grab)
|
|
{
|
|
int rc;
|
|
int evtype;
|
|
InputClients *iclients = NULL;
|
|
*grab = NULL;
|
|
|
|
if (listener->type == GESTURE_LISTENER_GRAB ||
|
|
listener->type == GESTURE_LISTENER_NONGESTURE_GRAB) {
|
|
*grab = listener->grab;
|
|
|
|
BUG_RETURN_VAL(!*grab, FALSE);
|
|
|
|
*client = rClient(*grab);
|
|
*win = (*grab)->window;
|
|
}
|
|
else {
|
|
rc = dixLookupResourceByType((void **) win, listener->listener, listener->resource_type,
|
|
serverClient, DixSendAccess);
|
|
if (rc != Success)
|
|
return FALSE;
|
|
|
|
/* note that we only will have XI2 listeners as
|
|
listener->type == GESTURE_LISTENER_REGULAR */
|
|
evtype = GetXI2Type(ev->any.type);
|
|
|
|
nt_list_for_each_entry(iclients, wOtherInputMasks(*win)->inputClients, next)
|
|
if (xi2mask_isset(iclients->xi2mask, dev, evtype))
|
|
break;
|
|
|
|
BUG_RETURN_VAL(!iclients, FALSE);
|
|
|
|
*client = rClient(iclients);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Delivers a gesture to the owner, if possible and needed. Returns whether
|
|
* an event was delivered.
|
|
*/
|
|
Bool
|
|
DeliverGestureEventToOwner(DeviceIntPtr dev, GestureInfoPtr gi, InternalEvent *ev)
|
|
{
|
|
GrabPtr grab = NULL;
|
|
ClientPtr client;
|
|
WindowPtr win;
|
|
|
|
if (!gi->has_listener || gi->listener.type == GESTURE_LISTENER_NONGESTURE_GRAB) {
|
|
return 0;
|
|
}
|
|
|
|
if (!RetrieveGestureDeliveryData(dev, ev, &gi->listener, &client, &win, &grab))
|
|
return 0;
|
|
|
|
ev->gesture_event.deviceid = dev->id;
|
|
|
|
return DeliverOneGestureEvent(client, dev, gi, grab, win, ev);
|
|
}
|
|
|
|
int
|
|
InitProximityClassDeviceStruct(DeviceIntPtr dev)
|
|
{
|
|
ProximityClassPtr proxc;
|
|
|
|
BUG_RETURN_VAL(dev == NULL, FALSE);
|
|
BUG_RETURN_VAL(dev->proximity != NULL, FALSE);
|
|
|
|
proxc = (ProximityClassPtr) malloc(sizeof(ProximityClassRec));
|
|
if (!proxc)
|
|
return FALSE;
|
|
proxc->sourceid = dev->id;
|
|
proxc->in_proximity = TRUE;
|
|
dev->proximity = proxc;
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Initialise the device's valuators. The memory must already be allocated,
|
|
* this function merely inits the matching axis (specified through axnum) to
|
|
* sane values.
|
|
*
|
|
* It is a condition that (minval < maxval).
|
|
*
|
|
* @see InitValuatorClassDeviceStruct
|
|
*/
|
|
Bool
|
|
InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval,
|
|
int maxval, int resolution, int min_res, int max_res,
|
|
int mode)
|
|
{
|
|
AxisInfoPtr ax;
|
|
|
|
BUG_RETURN_VAL(dev == NULL, FALSE);
|
|
BUG_RETURN_VAL(dev->valuator == NULL, FALSE);
|
|
BUG_RETURN_VAL(axnum >= dev->valuator->numAxes, FALSE);
|
|
BUG_RETURN_VAL(minval > maxval && mode == Absolute, FALSE);
|
|
|
|
ax = dev->valuator->axes + axnum;
|
|
|
|
ax->min_value = minval;
|
|
ax->max_value = maxval;
|
|
ax->resolution = resolution;
|
|
ax->min_resolution = min_res;
|
|
ax->max_resolution = max_res;
|
|
ax->label = label;
|
|
ax->mode = mode;
|
|
|
|
if (mode & OutOfProximity)
|
|
dev->proximity->in_proximity = FALSE;
|
|
|
|
return SetScrollValuator(dev, axnum, SCROLL_TYPE_NONE, 0, SCROLL_FLAG_NONE);
|
|
}
|
|
|
|
/**
|
|
* Set the given axis number as a scrolling valuator.
|
|
*/
|
|
Bool
|
|
SetScrollValuator(DeviceIntPtr dev, int axnum, enum ScrollType type,
|
|
double increment, int flags)
|
|
{
|
|
AxisInfoPtr ax;
|
|
int *current_ax;
|
|
InternalEvent dce;
|
|
DeviceIntPtr master;
|
|
|
|
BUG_RETURN_VAL(dev == NULL, FALSE);
|
|
BUG_RETURN_VAL(dev->valuator == NULL, FALSE);
|
|
BUG_RETURN_VAL(axnum >= dev->valuator->numAxes, FALSE);
|
|
|
|
switch (type) {
|
|
case SCROLL_TYPE_VERTICAL:
|
|
current_ax = &dev->valuator->v_scroll_axis;
|
|
break;
|
|
case SCROLL_TYPE_HORIZONTAL:
|
|
current_ax = &dev->valuator->h_scroll_axis;
|
|
break;
|
|
case SCROLL_TYPE_NONE:
|
|
ax = &dev->valuator->axes[axnum];
|
|
ax->scroll.type = type;
|
|
return TRUE;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
if (increment == 0.0)
|
|
return FALSE;
|
|
|
|
if (*current_ax != -1 && axnum != *current_ax) {
|
|
ax = &dev->valuator->axes[*current_ax];
|
|
if (ax->scroll.type == type &&
|
|
(flags & SCROLL_FLAG_PREFERRED) &&
|
|
(ax->scroll.flags & SCROLL_FLAG_PREFERRED))
|
|
return FALSE;
|
|
}
|
|
*current_ax = axnum;
|
|
|
|
ax = &dev->valuator->axes[axnum];
|
|
ax->scroll.type = type;
|
|
ax->scroll.increment = increment;
|
|
ax->scroll.flags = flags;
|
|
|
|
master = GetMaster(dev, MASTER_ATTACHED);
|
|
CreateClassesChangedEvent(&dce, master, dev,
|
|
DEVCHANGE_POINTER_EVENT |
|
|
DEVCHANGE_DEVICE_CHANGE);
|
|
XISendDeviceChangedEvent(dev, &dce.changed_event);
|
|
|
|
/* if the current slave is us, update the master. If not, we'll update
|
|
* whenever the next slave switch happens anyway. CMDC sends the event
|
|
* for us */
|
|
if (master && master->lastSlave == dev)
|
|
ChangeMasterDeviceClasses(master, &dce.changed_event);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
CheckGrabValues(ClientPtr client, GrabParameters *param)
|
|
{
|
|
if (param->grabtype != CORE &&
|
|
param->grabtype != XI && param->grabtype != XI2) {
|
|
ErrorF("[Xi] grabtype is invalid. This is a bug.\n");
|
|
return BadImplementation;
|
|
}
|
|
|
|
if ((param->this_device_mode != GrabModeSync) &&
|
|
(param->this_device_mode != GrabModeAsync) &&
|
|
(param->this_device_mode != XIGrabModeTouch)) {
|
|
client->errorValue = param->this_device_mode;
|
|
return BadValue;
|
|
}
|
|
if ((param->other_devices_mode != GrabModeSync) &&
|
|
(param->other_devices_mode != GrabModeAsync) &&
|
|
(param->other_devices_mode != XIGrabModeTouch)) {
|
|
client->errorValue = param->other_devices_mode;
|
|
return BadValue;
|
|
}
|
|
|
|
if (param->modifiers != AnyModifier &&
|
|
param->modifiers != XIAnyModifier &&
|
|
(param->modifiers & ~AllModifiersMask)) {
|
|
client->errorValue = param->modifiers;
|
|
return BadValue;
|
|
}
|
|
|
|
if ((param->ownerEvents != xFalse) && (param->ownerEvents != xTrue)) {
|
|
client->errorValue = param->ownerEvents;
|
|
return BadValue;
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
GrabButton(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
|
|
int button, GrabParameters *param, enum InputLevel grabtype,
|
|
GrabMask *mask)
|
|
{
|
|
WindowPtr pWin, confineTo;
|
|
CursorPtr cursor;
|
|
GrabPtr grab;
|
|
int rc, type = -1;
|
|
Mask access_mode = DixGrabAccess;
|
|
|
|
rc = CheckGrabValues(client, param);
|
|
if (rc != Success)
|
|
return rc;
|
|
if (param->confineTo == None)
|
|
confineTo = NullWindow;
|
|
else {
|
|
rc = dixLookupWindow(&confineTo, param->confineTo, client,
|
|
DixSetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
}
|
|
if (param->cursor == None)
|
|
cursor = NullCursor;
|
|
else {
|
|
rc = dixLookupResourceByType((void **) &cursor, param->cursor,
|
|
RT_CURSOR, client, DixUseAccess);
|
|
if (rc != Success) {
|
|
client->errorValue = param->cursor;
|
|
return rc;
|
|
}
|
|
access_mode |= DixForceAccess;
|
|
}
|
|
if (param->this_device_mode == GrabModeSync ||
|
|
param->other_devices_mode == GrabModeSync)
|
|
access_mode |= DixFreezeAccess;
|
|
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
|
|
if (rc != Success)
|
|
return rc;
|
|
rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
if (grabtype == XI)
|
|
type = DeviceButtonPress;
|
|
else if (grabtype == XI2)
|
|
type = XI_ButtonPress;
|
|
|
|
grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
|
|
mask, param, type, button, confineTo, cursor);
|
|
if (!grab)
|
|
return BadAlloc;
|
|
return AddPassiveGrabToList(client, grab);
|
|
}
|
|
|
|
/**
|
|
* Grab the given key.
|
|
*/
|
|
int
|
|
GrabKey(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
|
|
int key, GrabParameters *param, enum InputLevel grabtype,
|
|
GrabMask *mask)
|
|
{
|
|
WindowPtr pWin;
|
|
GrabPtr grab;
|
|
KeyClassPtr k = dev->key;
|
|
Mask access_mode = DixGrabAccess;
|
|
int rc, type = -1;
|
|
|
|
rc = CheckGrabValues(client, param);
|
|
if (rc != Success)
|
|
return rc;
|
|
if ((dev->id != XIAllDevices && dev->id != XIAllMasterDevices) && k == NULL)
|
|
return BadMatch;
|
|
if (grabtype == XI) {
|
|
if ((key > k->xkbInfo->desc->max_key_code ||
|
|
key < k->xkbInfo->desc->min_key_code)
|
|
&& (key != AnyKey)) {
|
|
client->errorValue = key;
|
|
return BadValue;
|
|
}
|
|
type = DeviceKeyPress;
|
|
}
|
|
else if (grabtype == XI2)
|
|
type = XI_KeyPress;
|
|
|
|
rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
if (param->this_device_mode == GrabModeSync ||
|
|
param->other_devices_mode == GrabModeSync)
|
|
access_mode |= DixFreezeAccess;
|
|
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
|
|
mask, param, type, key, NULL, NULL);
|
|
if (!grab)
|
|
return BadAlloc;
|
|
return AddPassiveGrabToList(client, grab);
|
|
}
|
|
|
|
/* Enter/FocusIn grab */
|
|
int
|
|
GrabWindow(ClientPtr client, DeviceIntPtr dev, int type,
|
|
GrabParameters *param, GrabMask *mask)
|
|
{
|
|
WindowPtr pWin;
|
|
CursorPtr cursor;
|
|
GrabPtr grab;
|
|
Mask access_mode = DixGrabAccess;
|
|
int rc;
|
|
|
|
rc = CheckGrabValues(client, param);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
if (param->cursor == None)
|
|
cursor = NullCursor;
|
|
else {
|
|
rc = dixLookupResourceByType((void **) &cursor, param->cursor,
|
|
RT_CURSOR, client, DixUseAccess);
|
|
if (rc != Success) {
|
|
client->errorValue = param->cursor;
|
|
return rc;
|
|
}
|
|
access_mode |= DixForceAccess;
|
|
}
|
|
if (param->this_device_mode == GrabModeSync ||
|
|
param->other_devices_mode == GrabModeSync)
|
|
access_mode |= DixFreezeAccess;
|
|
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
grab = CreateGrab(client->index, dev, dev, pWin, XI2,
|
|
mask, param,
|
|
(type == XIGrabtypeEnter) ? XI_Enter : XI_FocusIn, 0,
|
|
NULL, cursor);
|
|
|
|
if (!grab)
|
|
return BadAlloc;
|
|
|
|
return AddPassiveGrabToList(client, grab);
|
|
}
|
|
|
|
/* Touch grab */
|
|
int
|
|
GrabTouchOrGesture(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr mod_dev,
|
|
int type, GrabParameters *param, GrabMask *mask)
|
|
{
|
|
WindowPtr pWin;
|
|
GrabPtr grab;
|
|
int rc;
|
|
|
|
rc = CheckGrabValues(client, param);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixGrabAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
grab = CreateGrab(client->index, dev, mod_dev, pWin, XI2,
|
|
mask, param, type, 0, NullWindow, NullCursor);
|
|
if (!grab)
|
|
return BadAlloc;
|
|
|
|
return AddPassiveGrabToList(client, grab);
|
|
}
|
|
|
|
int
|
|
SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client,
|
|
Mask mask, Mask exclusivemasks)
|
|
{
|
|
int mskidx = dev->id;
|
|
int i, ret;
|
|
Mask check;
|
|
InputClientsPtr others;
|
|
|
|
check = (mask & exclusivemasks);
|
|
if (wOtherInputMasks(pWin)) {
|
|
if (check & wOtherInputMasks(pWin)->inputEvents[mskidx]) {
|
|
/* It is illegal for two different clients to select on any of
|
|
* the events for maskcheck. However, it is OK, for some client
|
|
* to continue selecting on one of those events.
|
|
*/
|
|
for (others = wOtherInputMasks(pWin)->inputClients; others;
|
|
others = others->next) {
|
|
if (!SameClient(others, client) && (check &
|
|
others->mask[mskidx]))
|
|
return BadAccess;
|
|
}
|
|
}
|
|
for (others = wOtherInputMasks(pWin)->inputClients; others;
|
|
others = others->next) {
|
|
if (SameClient(others, client)) {
|
|
check = others->mask[mskidx];
|
|
others->mask[mskidx] = mask;
|
|
if (mask == 0) {
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
if (i != mskidx && others->mask[i] != 0)
|
|
break;
|
|
if (i == EMASKSIZE) {
|
|
RecalculateDeviceDeliverableEvents(pWin);
|
|
if (ShouldFreeInputMasks(pWin, FALSE))
|
|
FreeResource(others->resource, RT_NONE);
|
|
return Success;
|
|
}
|
|
}
|
|
goto maskSet;
|
|
}
|
|
}
|
|
}
|
|
check = 0;
|
|
if ((ret = AddExtensionClient(pWin, client, mask, mskidx)) != Success)
|
|
return ret;
|
|
maskSet:
|
|
if (dev->valuator)
|
|
if ((dev->valuator->motionHintWindow == pWin) &&
|
|
(mask & DevicePointerMotionHintMask) &&
|
|
!(check & DevicePointerMotionHintMask) && !dev->deviceGrab.grab)
|
|
dev->valuator->motionHintWindow = NullWindow;
|
|
RecalculateDeviceDeliverableEvents(pWin);
|
|
return Success;
|
|
}
|
|
|
|
static void
|
|
FreeInputClient(InputClientsPtr * other)
|
|
{
|
|
xi2mask_free(&(*other)->xi2mask);
|
|
free(*other);
|
|
*other = NULL;
|
|
}
|
|
|
|
static InputClientsPtr
|
|
AllocInputClient(void)
|
|
{
|
|
return calloc(1, sizeof(InputClients));
|
|
}
|
|
|
|
int
|
|
AddExtensionClient(WindowPtr pWin, ClientPtr client, Mask mask, int mskidx)
|
|
{
|
|
InputClientsPtr others;
|
|
|
|
if (!pWin->optional && !MakeWindowOptional(pWin))
|
|
return BadAlloc;
|
|
others = AllocInputClient();
|
|
if (!others)
|
|
return BadAlloc;
|
|
if (!pWin->optional->inputMasks && !MakeInputMasks(pWin))
|
|
goto bail;
|
|
others->xi2mask = xi2mask_new();
|
|
if (!others->xi2mask)
|
|
goto bail;
|
|
others->mask[mskidx] = mask;
|
|
others->resource = FakeClientID(client->index);
|
|
others->next = pWin->optional->inputMasks->inputClients;
|
|
pWin->optional->inputMasks->inputClients = others;
|
|
if (!AddResource(others->resource, RT_INPUTCLIENT, (void *) pWin))
|
|
goto bail;
|
|
return Success;
|
|
|
|
bail:
|
|
FreeInputClient(&others);
|
|
return BadAlloc;
|
|
}
|
|
|
|
static Bool
|
|
MakeInputMasks(WindowPtr pWin)
|
|
{
|
|
struct _OtherInputMasks *imasks;
|
|
|
|
imasks = calloc(1, sizeof(struct _OtherInputMasks));
|
|
if (!imasks)
|
|
return FALSE;
|
|
imasks->xi2mask = xi2mask_new();
|
|
if (!imasks->xi2mask) {
|
|
free(imasks);
|
|
return FALSE;
|
|
}
|
|
pWin->optional->inputMasks = imasks;
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
FreeInputMask(OtherInputMasks ** imask)
|
|
{
|
|
xi2mask_free(&(*imask)->xi2mask);
|
|
free(*imask);
|
|
*imask = NULL;
|
|
}
|
|
|
|
#define XIPropagateMask (KeyPressMask | \
|
|
KeyReleaseMask | \
|
|
ButtonPressMask | \
|
|
ButtonReleaseMask | \
|
|
PointerMotionMask)
|
|
|
|
void
|
|
RecalculateDeviceDeliverableEvents(WindowPtr pWin)
|
|
{
|
|
InputClientsPtr others;
|
|
struct _OtherInputMasks *inputMasks; /* default: NULL */
|
|
WindowPtr pChild, tmp;
|
|
int i;
|
|
|
|
pChild = pWin;
|
|
while (1) {
|
|
if ((inputMasks = wOtherInputMasks(pChild)) != 0) {
|
|
xi2mask_zero(inputMasks->xi2mask, -1);
|
|
for (others = inputMasks->inputClients; others;
|
|
others = others->next) {
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
inputMasks->inputEvents[i] |= others->mask[i];
|
|
xi2mask_merge(inputMasks->xi2mask, others->xi2mask);
|
|
}
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
inputMasks->deliverableEvents[i] = inputMasks->inputEvents[i];
|
|
for (tmp = pChild->parent; tmp; tmp = tmp->parent)
|
|
if (wOtherInputMasks(tmp))
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
inputMasks->deliverableEvents[i] |=
|
|
(wOtherInputMasks(tmp)->deliverableEvents[i]
|
|
& ~inputMasks->dontPropagateMask[i] &
|
|
XIPropagateMask);
|
|
}
|
|
if (pChild->firstChild) {
|
|
pChild = pChild->firstChild;
|
|
continue;
|
|
}
|
|
while (!pChild->nextSib && (pChild != pWin))
|
|
pChild = pChild->parent;
|
|
if (pChild == pWin)
|
|
break;
|
|
pChild = pChild->nextSib;
|
|
}
|
|
}
|
|
|
|
int
|
|
InputClientGone(WindowPtr pWin, XID id)
|
|
{
|
|
InputClientsPtr other, prev;
|
|
|
|
if (!wOtherInputMasks(pWin))
|
|
return Success;
|
|
prev = 0;
|
|
for (other = wOtherInputMasks(pWin)->inputClients; other;
|
|
other = other->next) {
|
|
if (other->resource == id) {
|
|
if (prev) {
|
|
prev->next = other->next;
|
|
FreeInputClient(&other);
|
|
}
|
|
else if (!(other->next)) {
|
|
if (ShouldFreeInputMasks(pWin, TRUE)) {
|
|
OtherInputMasks *mask = wOtherInputMasks(pWin);
|
|
|
|
mask->inputClients = other->next;
|
|
FreeInputMask(&mask);
|
|
pWin->optional->inputMasks = (OtherInputMasks *) NULL;
|
|
CheckWindowOptionalNeed(pWin);
|
|
FreeInputClient(&other);
|
|
}
|
|
else {
|
|
other->resource = FakeClientID(0);
|
|
if (!AddResource(other->resource, RT_INPUTCLIENT,
|
|
(void *) pWin))
|
|
return BadAlloc;
|
|
}
|
|
}
|
|
else {
|
|
wOtherInputMasks(pWin)->inputClients = other->next;
|
|
FreeInputClient(&other);
|
|
}
|
|
RecalculateDeviceDeliverableEvents(pWin);
|
|
return Success;
|
|
}
|
|
prev = other;
|
|
}
|
|
FatalError("client not on device event list");
|
|
}
|
|
|
|
/**
|
|
* Search for window in each touch trace for each device. Remove the window
|
|
* and all its subwindows from the trace when found. The initial window
|
|
* order is preserved.
|
|
*/
|
|
void
|
|
WindowGone(WindowPtr win)
|
|
{
|
|
DeviceIntPtr dev;
|
|
|
|
for (dev = inputInfo.devices; dev; dev = dev->next) {
|
|
TouchClassPtr t = dev->touch;
|
|
int i;
|
|
|
|
if (!t)
|
|
continue;
|
|
|
|
for (i = 0; i < t->num_touches; i++) {
|
|
SpritePtr sprite = &t->touches[i].sprite;
|
|
int j;
|
|
|
|
for (j = 0; j < sprite->spriteTraceGood; j++) {
|
|
if (sprite->spriteTrace[j] == win) {
|
|
sprite->spriteTraceGood = j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
|
|
xEvent *ev, Mask mask, int count)
|
|
{
|
|
WindowPtr pWin;
|
|
WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */
|
|
WindowPtr spriteWin = GetSpriteWindow(d);
|
|
|
|
if (dest == PointerWindow)
|
|
pWin = spriteWin;
|
|
else if (dest == InputFocus) {
|
|
WindowPtr inputFocus;
|
|
|
|
if (!d->focus)
|
|
inputFocus = spriteWin;
|
|
else
|
|
inputFocus = d->focus->win;
|
|
|
|
if (inputFocus == FollowKeyboardWin)
|
|
inputFocus = inputInfo.keyboard->focus->win;
|
|
|
|
if (inputFocus == NoneWin)
|
|
return Success;
|
|
|
|
/* If the input focus is PointerRootWin, send the event to where
|
|
* the pointer is if possible, then perhaps propagate up to root. */
|
|
if (inputFocus == PointerRootWin)
|
|
inputFocus = GetCurrentRootWindow(d);
|
|
|
|
if (IsParent(inputFocus, spriteWin)) {
|
|
effectiveFocus = inputFocus;
|
|
pWin = spriteWin;
|
|
}
|
|
else
|
|
effectiveFocus = pWin = inputFocus;
|
|
}
|
|
else
|
|
dixLookupWindow(&pWin, dest, client, DixSendAccess);
|
|
if (!pWin)
|
|
return BadWindow;
|
|
if ((propagate != xFalse) && (propagate != xTrue)) {
|
|
client->errorValue = propagate;
|
|
return BadValue;
|
|
}
|
|
ev->u.u.type |= 0x80;
|
|
if (propagate) {
|
|
for (; pWin; pWin = pWin->parent) {
|
|
if (DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab))
|
|
return Success;
|
|
if (pWin == effectiveFocus)
|
|
return Success;
|
|
if (wOtherInputMasks(pWin))
|
|
mask &= ~wOtherInputMasks(pWin)->dontPropagateMask[d->id];
|
|
if (!mask)
|
|
break;
|
|
}
|
|
}
|
|
else if (!XaceHook(XACE_SEND_ACCESS, client, NULL, pWin, ev, count))
|
|
DeliverEventsToWindow(d, pWin, ev, count, mask, NullGrab);
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
SetButtonMapping(ClientPtr client, DeviceIntPtr dev, int nElts, BYTE * map)
|
|
{
|
|
int i;
|
|
ButtonClassPtr b = dev->button;
|
|
|
|
if (b == NULL)
|
|
return BadMatch;
|
|
|
|
if (nElts != b->numButtons) {
|
|
client->errorValue = nElts;
|
|
return BadValue;
|
|
}
|
|
if (BadDeviceMap(&map[0], nElts, 1, 255, &client->errorValue))
|
|
return BadValue;
|
|
for (i = 0; i < nElts; i++)
|
|
if ((b->map[i + 1] != map[i]) && BitIsOn(b->down, i + 1))
|
|
return MappingBusy;
|
|
for (i = 0; i < nElts; i++)
|
|
b->map[i + 1] = map[i];
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
ChangeKeyMapping(ClientPtr client,
|
|
DeviceIntPtr dev,
|
|
unsigned len,
|
|
int type,
|
|
KeyCode firstKeyCode,
|
|
CARD8 keyCodes, CARD8 keySymsPerKeyCode, KeySym * map)
|
|
{
|
|
KeySymsRec keysyms;
|
|
KeyClassPtr k = dev->key;
|
|
|
|
if (k == NULL)
|
|
return BadMatch;
|
|
|
|
if (len != (keyCodes * keySymsPerKeyCode))
|
|
return BadLength;
|
|
|
|
if ((firstKeyCode < k->xkbInfo->desc->min_key_code) ||
|
|
(firstKeyCode + keyCodes - 1 > k->xkbInfo->desc->max_key_code)) {
|
|
client->errorValue = firstKeyCode;
|
|
return BadValue;
|
|
}
|
|
if (keySymsPerKeyCode == 0) {
|
|
client->errorValue = 0;
|
|
return BadValue;
|
|
}
|
|
keysyms.minKeyCode = firstKeyCode;
|
|
keysyms.maxKeyCode = firstKeyCode + keyCodes - 1;
|
|
keysyms.mapWidth = keySymsPerKeyCode;
|
|
keysyms.map = map;
|
|
|
|
XkbApplyMappingChange(dev, &keysyms, firstKeyCode, keyCodes, NULL,
|
|
serverClient);
|
|
|
|
return Success;
|
|
}
|
|
|
|
static void
|
|
DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
|
|
{
|
|
WindowPtr parent;
|
|
|
|
/* Deactivate any grabs performed on this window, before making
|
|
* any input focus changes.
|
|
* Deactivating a device grab should cause focus events. */
|
|
|
|
if (dev->deviceGrab.grab && (dev->deviceGrab.grab->window == pWin))
|
|
(*dev->deviceGrab.DeactivateGrab) (dev);
|
|
|
|
/* If the focus window is a root window (ie. has no parent)
|
|
* then don't delete the focus from it. */
|
|
|
|
if (dev->focus && (pWin == dev->focus->win) && (pWin->parent != NullWindow)) {
|
|
int focusEventMode = NotifyNormal;
|
|
|
|
/* If a grab is in progress, then alter the mode of focus events. */
|
|
|
|
if (dev->deviceGrab.grab)
|
|
focusEventMode = NotifyWhileGrabbed;
|
|
|
|
switch (dev->focus->revert) {
|
|
case RevertToNone:
|
|
if (!ActivateFocusInGrab(dev, pWin, NoneWin))
|
|
DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
|
|
dev->focus->win = NoneWin;
|
|
dev->focus->traceGood = 0;
|
|
break;
|
|
case RevertToParent:
|
|
parent = pWin;
|
|
do {
|
|
parent = parent->parent;
|
|
dev->focus->traceGood--;
|
|
}
|
|
while (!parent->realized);
|
|
if (!ActivateFocusInGrab(dev, pWin, parent))
|
|
DoFocusEvents(dev, pWin, parent, focusEventMode);
|
|
dev->focus->win = parent;
|
|
dev->focus->revert = RevertToNone;
|
|
break;
|
|
case RevertToPointerRoot:
|
|
if (!ActivateFocusInGrab(dev, pWin, PointerRootWin))
|
|
DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
|
|
dev->focus->win = PointerRootWin;
|
|
dev->focus->traceGood = 0;
|
|
break;
|
|
case RevertToFollowKeyboard:
|
|
{
|
|
DeviceIntPtr kbd = GetMaster(dev, MASTER_KEYBOARD);
|
|
|
|
if (!kbd || (kbd == dev && kbd != inputInfo.keyboard))
|
|
kbd = inputInfo.keyboard;
|
|
if (kbd->focus->win) {
|
|
if (!ActivateFocusInGrab(dev, pWin, kbd->focus->win))
|
|
DoFocusEvents(dev, pWin, kbd->focus->win, focusEventMode);
|
|
dev->focus->win = FollowKeyboardWin;
|
|
dev->focus->traceGood = 0;
|
|
}
|
|
else {
|
|
if (!ActivateFocusInGrab(dev, pWin, NoneWin))
|
|
DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
|
|
dev->focus->win = NoneWin;
|
|
dev->focus->traceGood = 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dev->valuator)
|
|
if (dev->valuator->motionHintWindow == pWin)
|
|
dev->valuator->motionHintWindow = NullWindow;
|
|
}
|
|
|
|
void
|
|
DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
|
|
{
|
|
int i;
|
|
DeviceIntPtr dev;
|
|
InputClientsPtr ic;
|
|
struct _OtherInputMasks *inputMasks;
|
|
|
|
for (dev = inputInfo.devices; dev; dev = dev->next) {
|
|
DeleteDeviceFromAnyExtEvents(pWin, dev);
|
|
}
|
|
|
|
for (dev = inputInfo.off_devices; dev; dev = dev->next)
|
|
DeleteDeviceFromAnyExtEvents(pWin, dev);
|
|
|
|
if (freeResources)
|
|
while ((inputMasks = wOtherInputMasks(pWin)) != 0) {
|
|
ic = inputMasks->inputClients;
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
inputMasks->dontPropagateMask[i] = 0;
|
|
FreeResource(ic->resource, RT_NONE);
|
|
}
|
|
}
|
|
|
|
int
|
|
MaybeSendDeviceMotionNotifyHint(deviceKeyButtonPointer *pEvents, Mask mask)
|
|
{
|
|
DeviceIntPtr dev;
|
|
|
|
dixLookupDevice(&dev, pEvents->deviceid & DEVICE_BITS, serverClient,
|
|
DixReadAccess);
|
|
if (!dev)
|
|
return 0;
|
|
|
|
if (pEvents->type == DeviceMotionNotify) {
|
|
if (mask & DevicePointerMotionHintMask) {
|
|
if (WID(dev->valuator->motionHintWindow) == pEvents->event) {
|
|
return 1; /* don't send, but pretend we did */
|
|
}
|
|
pEvents->detail = NotifyHint;
|
|
}
|
|
else {
|
|
pEvents->detail = NotifyNormal;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
|
|
deviceKeyButtonPointer *xE, GrabPtr grab,
|
|
ClientPtr client, Mask deliveryMask)
|
|
{
|
|
DeviceIntPtr dev;
|
|
|
|
dixLookupDevice(&dev, xE->deviceid & DEVICE_BITS, serverClient,
|
|
DixGrabAccess);
|
|
if (!dev)
|
|
return;
|
|
|
|
if (type == DeviceMotionNotify)
|
|
dev->valuator->motionHintWindow = pWin;
|
|
else if ((type == DeviceButtonPress) && (!grab) &&
|
|
(deliveryMask & DeviceButtonGrabMask)) {
|
|
GrabPtr tempGrab;
|
|
|
|
tempGrab = AllocGrab(NULL);
|
|
if (!tempGrab)
|
|
return;
|
|
|
|
tempGrab->device = dev;
|
|
tempGrab->resource = client->clientAsMask;
|
|
tempGrab->window = pWin;
|
|
tempGrab->ownerEvents =
|
|
(deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
|
|
tempGrab->eventMask = deliveryMask;
|
|
tempGrab->keyboardMode = GrabModeAsync;
|
|
tempGrab->pointerMode = GrabModeAsync;
|
|
tempGrab->confineTo = NullWindow;
|
|
tempGrab->cursor = NullCursor;
|
|
tempGrab->next = NULL;
|
|
(*dev->deviceGrab.ActivateGrab) (dev, tempGrab, currentTime, TRUE);
|
|
FreeGrab(tempGrab);
|
|
}
|
|
}
|
|
|
|
static Mask
|
|
DeviceEventMaskForClient(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
|
|
{
|
|
InputClientsPtr other;
|
|
|
|
if (!wOtherInputMasks(pWin))
|
|
return 0;
|
|
for (other = wOtherInputMasks(pWin)->inputClients; other;
|
|
other = other->next) {
|
|
if (SameClient(other, client))
|
|
return other->mask[dev->id];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
MaybeStopDeviceHint(DeviceIntPtr dev, ClientPtr client)
|
|
{
|
|
WindowPtr pWin;
|
|
GrabPtr grab = dev->deviceGrab.grab;
|
|
|
|
pWin = dev->valuator->motionHintWindow;
|
|
|
|
if ((grab && SameClient(grab, client) &&
|
|
((grab->eventMask & DevicePointerMotionHintMask) ||
|
|
(grab->ownerEvents &&
|
|
(DeviceEventMaskForClient(dev, pWin, client) &
|
|
DevicePointerMotionHintMask)))) ||
|
|
(!grab &&
|
|
(DeviceEventMaskForClient(dev, pWin, client) &
|
|
DevicePointerMotionHintMask)))
|
|
dev->valuator->motionHintWindow = NullWindow;
|
|
}
|
|
|
|
int
|
|
DeviceEventSuppressForWindow(WindowPtr pWin, ClientPtr client, Mask mask,
|
|
int maskndx)
|
|
{
|
|
struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
|
|
|
|
if (mask & ~XIPropagateMask) {
|
|
client->errorValue = mask;
|
|
return BadValue;
|
|
}
|
|
|
|
if (mask == 0) {
|
|
if (inputMasks)
|
|
inputMasks->dontPropagateMask[maskndx] = mask;
|
|
}
|
|
else {
|
|
if (!inputMasks)
|
|
AddExtensionClient(pWin, client, 0, 0);
|
|
inputMasks = wOtherInputMasks(pWin);
|
|
inputMasks->dontPropagateMask[maskndx] = mask;
|
|
}
|
|
RecalculateDeviceDeliverableEvents(pWin);
|
|
if (ShouldFreeInputMasks(pWin, FALSE))
|
|
FreeResource(inputMasks->inputClients->resource, RT_NONE);
|
|
return Success;
|
|
}
|
|
|
|
Bool
|
|
ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
|
|
{
|
|
int i;
|
|
Mask allInputEventMasks = 0;
|
|
struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
|
|
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
allInputEventMasks |= inputMasks->dontPropagateMask[i];
|
|
if (!ignoreSelectedEvents)
|
|
for (i = 0; i < EMASKSIZE; i++)
|
|
allInputEventMasks |= inputMasks->inputEvents[i];
|
|
if (allInputEventMasks == 0)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
*
|
|
* Walk through the window tree, finding all clients that want to know
|
|
* about the Event.
|
|
*
|
|
*/
|
|
|
|
static void
|
|
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
|
|
xEvent *ev, int count)
|
|
{
|
|
WindowPtr p2;
|
|
|
|
while (p1) {
|
|
p2 = p1->firstChild;
|
|
DeliverEventsToWindow(dev, p1, ev, count, mask, NullGrab);
|
|
FindInterestedChildren(dev, p2, mask, ev, count);
|
|
p1 = p1->nextSib;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
*
|
|
* Send an event to interested clients in all windows on all screens.
|
|
*
|
|
*/
|
|
|
|
void
|
|
SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent *ev, int count)
|
|
{
|
|
int i;
|
|
WindowPtr pWin, p1;
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++) {
|
|
pWin = screenInfo.screens[i]->root;
|
|
if (!pWin)
|
|
continue;
|
|
DeliverEventsToWindow(dev, pWin, ev, count, mask, NullGrab);
|
|
p1 = pWin->firstChild;
|
|
FindInterestedChildren(dev, p1, mask, ev, count);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the XI2 mask for the given client on the given window.
|
|
* @param dev The device to set the mask for.
|
|
* @param win The window to set the mask on.
|
|
* @param client The client setting the mask.
|
|
* @param len Number of bytes in mask.
|
|
* @param mask Event mask in the form of (1 << eventtype)
|
|
*/
|
|
int
|
|
XISetEventMask(DeviceIntPtr dev, WindowPtr win, ClientPtr client,
|
|
unsigned int len, unsigned char *mask)
|
|
{
|
|
OtherInputMasks *masks;
|
|
InputClientsPtr others = NULL;
|
|
|
|
masks = wOtherInputMasks(win);
|
|
if (masks) {
|
|
for (others = wOtherInputMasks(win)->inputClients; others;
|
|
others = others->next) {
|
|
if (SameClient(others, client)) {
|
|
xi2mask_zero(others->xi2mask, dev->id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (len && !others) {
|
|
if (AddExtensionClient(win, client, 0, 0) != Success)
|
|
return BadAlloc;
|
|
others = wOtherInputMasks(win)->inputClients;
|
|
}
|
|
|
|
if (others) {
|
|
xi2mask_zero(others->xi2mask, dev->id);
|
|
len = min(len, xi2mask_mask_size(others->xi2mask));
|
|
}
|
|
|
|
if (len) {
|
|
xi2mask_set_one_mask(others->xi2mask, dev->id, mask, len);
|
|
}
|
|
|
|
RecalculateDeviceDeliverableEvents(win);
|
|
|
|
return Success;
|
|
}
|