frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

input: reshuffle CreateGrab and friends to take a GrabParameters param. 

This is cleaning up work in preparation for XI2 passive grabs.
This commit is contained in:
Peter Hutterer 2009-04-28 16:49:45 +10:00
parent e8e26f700c
commit 6a618929a0
8 changed files with 209 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
Xi/exevents.c
View File

@ -1349,36 +1349,34 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
} }
} }
static int int
CheckGrabValues(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode, CheckGrabValues(ClientPtr client, GrabParameters* param)
BYTE other_devices_mode, CARD16 modifiers, BOOL ownerEvents)
{ {
if ((this_device_mode != GrabModeSync) && if ((param->this_device_mode != GrabModeSync) &&
(this_device_mode != GrabModeAsync)) { (param->this_device_mode != GrabModeAsync)) {
client->errorValue = this_device_mode; client->errorValue = param->this_device_mode;
return BadValue; return BadValue;
} }
if ((other_devices_mode != GrabModeSync) && if ((param->other_devices_mode != GrabModeSync) &&
(other_devices_mode != GrabModeAsync)) { (param->other_devices_mode != GrabModeAsync)) {
client->errorValue = other_devices_mode; client->errorValue = param->other_devices_mode;
return BadValue; return BadValue;
} }
if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) { if ((param->modifiers != AnyModifier) && (param->modifiers & ~AllModifiersMask)) {
client->errorValue = modifiers; client->errorValue = param->modifiers;
return BadValue; return BadValue;
} }
if ((ownerEvents != xFalse) && (ownerEvents != xTrue)) { if ((param->ownerEvents != xFalse) && (param->ownerEvents != xTrue)) {
client->errorValue = ownerEvents; client->errorValue = param->ownerEvents;
return BadValue; return BadValue;
} }
return Success; return Success;
} }
int int
GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode, GrabButton(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
BYTE other_devices_mode, CARD16 modifiers, int button, GrabParameters *param, GrabType grabtype,
DeviceIntPtr modifier_device, CARD8 button, Window grabWindow, GrabMask *mask)
BOOL ownerEvents, Cursor rcursor, Window rconfineTo, Mask eventMask)
{ {
WindowPtr pWin, confineTo; WindowPtr pWin, confineTo;
CursorPtr cursor; CursorPtr cursor;
@ -1386,53 +1384,48 @@ GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
int rc; int rc;
Mask access_mode = DixGrabAccess; Mask access_mode = DixGrabAccess;
rc = CheckGrabValues(client, dev, this_device_mode, other_devices_mode, rc = CheckGrabValues(client, param);
modifiers, ownerEvents);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (rconfineTo == None) if (param->confineTo == None)
confineTo = NullWindow; confineTo = NullWindow;
else { else {
rc = dixLookupWindow(&confineTo, rconfineTo, client, DixSetAttrAccess); rc = dixLookupWindow(&confineTo, param->confineTo, client, DixSetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
} }
if (rcursor == None) if (param->cursor == None)
cursor = NullCursor; cursor = NullCursor;
else { else {
rc = dixLookupResourceByType((pointer *)&cursor, rcursor, RT_CURSOR, rc = dixLookupResourceByType((pointer *)&cursor, param->cursor,
client, DixUseAccess); RT_CURSOR, client, DixUseAccess);
if (rc != Success) if (rc != Success)
{ {
client->errorValue = rcursor; client->errorValue = param->cursor;
return (rc == BadValue) ? BadCursor : rc; return (rc == BadValue) ? BadCursor : rc;
} }
access_mode |= DixForceAccess; access_mode |= DixForceAccess;
} }
if (this_device_mode == GrabModeSync || other_devices_mode == GrabModeSync) if (param->this_device_mode == GrabModeSync || param->other_devices_mode == GrabModeSync)
access_mode |= DixFreezeAccess; access_mode |= DixFreezeAccess;
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode); rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
if (rc != Success) if (rc != Success)
return rc; return rc;
rc = dixLookupWindow(&pWin, grabWindow, client, DixSetAttrAccess); rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
grab = CreateGrab(client->index, dev, pWin, eventMask, grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
(Bool) ownerEvents, (Bool) this_device_mode, mask, param, DeviceButtonPress, button, confineTo, cursor);
(Bool) other_devices_mode, modifier_device, modifiers,
DeviceButtonPress, GRABTYPE_XI, button, confineTo, cursor);
if (!grab) if (!grab)
return BadAlloc; return BadAlloc;
return AddPassiveGrabToList(client, grab); return AddPassiveGrabToList(client, grab);
} }
int int
GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode, GrabKey(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
BYTE other_devices_mode, CARD16 modifiers, int key, GrabParameters *param, GrabType grabtype, GrabMask *mask)
DeviceIntPtr modifier_device, CARD8 key, Window grabWindow,
BOOL ownerEvents, Mask mask)
{ {
WindowPtr pWin; WindowPtr pWin;
GrabPtr grab; GrabPtr grab;
@ -1440,8 +1433,7 @@ GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
Mask access_mode = DixGrabAccess; Mask access_mode = DixGrabAccess;
int rc; int rc;
rc = CheckGrabValues(client, dev, this_device_mode, other_devices_mode, rc = CheckGrabValues(client, param);
modifiers, ownerEvents);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (k == NULL) if (k == NULL)
@ -1452,19 +1444,17 @@ GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
client->errorValue = key; client->errorValue = key;
return BadValue; return BadValue;
} }
rc = dixLookupWindow(&pWin, grabWindow, client, DixSetAttrAccess); rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (this_device_mode == GrabModeSync || other_devices_mode == GrabModeSync) if (param->this_device_mode == GrabModeSync || param->other_devices_mode == GrabModeSync)
access_mode |= DixFreezeAccess; access_mode |= DixFreezeAccess;
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode); rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, access_mode);
if (rc != Success) if (rc != Success)
return rc; return rc;
grab = CreateGrab(client->index, dev, pWin, grab = CreateGrab(client->index, dev, modifier_device, pWin, grabtype,
mask, ownerEvents, this_device_mode, other_devices_mode, mask, param, DeviceKeyPress, key, NULL, NULL);
modifier_device, modifiers, DeviceKeyPress, GRABTYPE_XI,
key, NullWindow, NullCursor);
if (!grab) if (!grab)
return BadAlloc; return BadAlloc;
return AddPassiveGrabToList(client, grab); return AddPassiveGrabToList(client, grab);

17
Xi/grabdevb.c
View File

@ -103,6 +103,8 @@ ProcXGrabDeviceButton(ClientPtr client)
DeviceIntPtr mdev; DeviceIntPtr mdev;
XEventClass *class; XEventClass *class;
struct tmask tmp[EMASKSIZE]; struct tmask tmp[EMASKSIZE];
GrabParameters param;
GrabMask mask;
REQUEST(xGrabDeviceButtonReq); REQUEST(xGrabDeviceButtonReq);
REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq); REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
@ -135,10 +137,17 @@ ProcXGrabDeviceButton(ClientPtr client)
stuff->event_count, tmp, dev, stuff->event_count, tmp, dev,
X_GrabDeviceButton)) != Success) X_GrabDeviceButton)) != Success)
return ret; return ret;
ret = GrabButton(client, dev, stuff->this_device_mode,
stuff->other_devices_mode, stuff->modifiers, mdev, memset(&param, 0, sizeof(param));
stuff->button, stuff->grabWindow, stuff->ownerEvents, param.ownerEvents = stuff->ownerEvents;
(Cursor) 0, (Window) 0, tmp[stuff->grabbed_device].mask); param.this_device_mode = stuff->this_device_mode;
param.other_devices_mode = stuff->other_devices_mode;
param.grabWindow = stuff->grabWindow;
param.modifiers = stuff->modifiers;
mask.xi = tmp[stuff->grabbed_device].mask;
ret = GrabButton(client, dev, mdev, stuff->button, &param,
GRABTYPE_XI, &mask);
return ret; return ret;
} }

16
Xi/grabdevk.c
View File

@ -101,6 +101,8 @@ ProcXGrabDeviceKey(ClientPtr client)
DeviceIntPtr mdev; DeviceIntPtr mdev;
XEventClass *class; XEventClass *class;
struct tmask tmp[EMASKSIZE]; struct tmask tmp[EMASKSIZE];
GrabParameters param;
GrabMask mask;
REQUEST(xGrabDeviceKeyReq); REQUEST(xGrabDeviceKeyReq);
REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq); REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
@ -133,10 +135,16 @@ ProcXGrabDeviceKey(ClientPtr client)
X_GrabDeviceKey)) != Success) X_GrabDeviceKey)) != Success)
return ret; return ret;
ret = GrabKey(client, dev, stuff->this_device_mode,
stuff->other_devices_mode, stuff->modifiers, mdev, memset(&param, 0, sizeof(param));
stuff->key, stuff->grabWindow, stuff->ownerEvents, param.ownerEvents = stuff->ownerEvents;
tmp[stuff->grabbed_device].mask); param.this_device_mode = stuff->this_device_mode;
param.other_devices_mode = stuff->other_devices_mode;
param.grabWindow = stuff->grabWindow;
param.modifiers = stuff->modifiers;
mask.xi = tmp[stuff->grabbed_device].mask;
ret = GrabKey(client, dev, mdev, stuff->key, &param, GRABTYPE_XI, &mask);
return ret; return ret;
} }

64
dix/events.c
View File

@ -5022,25 +5022,21 @@ ProcGrabKey(ClientPtr client)
GrabPtr grab; GrabPtr grab;
DeviceIntPtr keybd = PickKeyboard(client); DeviceIntPtr keybd = PickKeyboard(client);
int rc; int rc;
GrabParameters param;
GrabMask mask;
REQUEST_SIZE_MATCH(xGrabKeyReq); REQUEST_SIZE_MATCH(xGrabKeyReq);
if ((stuff->ownerEvents != xTrue) && (stuff->ownerEvents != xFalse))
{ memset(&param, 0, sizeof(param));
client->errorValue = stuff->ownerEvents; param.ownerEvents = stuff->ownerEvents;
return(BadValue); param.this_device_mode = stuff->keyboardMode;
} param.other_devices_mode = stuff->pointerMode;
if ((stuff->pointerMode != GrabModeSync) && param.modifiers = stuff->modifiers;
(stuff->pointerMode != GrabModeAsync))
{ rc = CheckGrabValues(client, &param);
client->errorValue = stuff->pointerMode; if (rc != Success)
return BadValue; return rc;
}
if ((stuff->keyboardMode != GrabModeSync) &&
(stuff->keyboardMode != GrabModeAsync))
{
client->errorValue = stuff->keyboardMode;
return BadValue;
}
if (((stuff->key > keybd->key->xkbInfo->desc->max_key_code) || if (((stuff->key > keybd->key->xkbInfo->desc->max_key_code) ||
(stuff->key < keybd->key->xkbInfo->desc->min_key_code)) (stuff->key < keybd->key->xkbInfo->desc->min_key_code))
&& (stuff->key != AnyKey)) && (stuff->key != AnyKey))
@ -5048,21 +5044,15 @@ ProcGrabKey(ClientPtr client)
client->errorValue = stuff->key; client->errorValue = stuff->key;
return BadValue; return BadValue;
} }
if ((stuff->modifiers != AnyModifier) &&
(stuff->modifiers & ~AllModifiersMask))
{
client->errorValue = stuff->modifiers;
return BadValue;
}
rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixSetAttrAccess); rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixSetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
grab = CreateGrab(client->index, keybd, pWin,
(Mask)(KeyPressMask | KeyReleaseMask), (Bool)stuff->ownerEvents, mask.core = (KeyPressMask | KeyReleaseMask);
(Bool)stuff->keyboardMode, (Bool)stuff->pointerMode,
keybd, stuff->modifiers, KeyPress, GRABTYPE_CORE, stuff->key, grab = CreateGrab(client->index, keybd, keybd, pWin, GRABTYPE_CORE, &mask,
NullWindow, NullCursor); &param, KeyPress, stuff->key, NullWindow, NullCursor);
if (!grab) if (!grab)
return BadAlloc; return BadAlloc;
return AddPassiveGrabToList(client, grab); return AddPassiveGrabToList(client, grab);
@ -5084,6 +5074,8 @@ ProcGrabButton(ClientPtr client)
GrabPtr grab; GrabPtr grab;
DeviceIntPtr ptr, modifierDevice; DeviceIntPtr ptr, modifierDevice;
Mask access_mode = DixGrabAccess; Mask access_mode = DixGrabAccess;
GrabMask mask;
GrabParameters param;
int rc; int rc;
REQUEST_SIZE_MATCH(xGrabButtonReq); REQUEST_SIZE_MATCH(xGrabButtonReq);
@ -5150,11 +5142,17 @@ ProcGrabButton(ClientPtr client)
if (rc != Success) if (rc != Success)
return rc; return rc;
grab = CreateGrab(client->index, ptr, pWin, memset(&param, 0, sizeof(param));
(Mask)stuff->eventMask, (Bool)stuff->ownerEvents, param.ownerEvents = stuff->ownerEvents;
(Bool) stuff->keyboardMode, (Bool)stuff->pointerMode, param.this_device_mode = stuff->keyboardMode;
modifierDevice, stuff->modifiers, ButtonPress, GRABTYPE_CORE, param.other_devices_mode = stuff->pointerMode;
stuff->button, confineTo, cursor); param.modifiers = stuff->modifiers;
mask.core = stuff->eventMask;
grab = CreateGrab(client->index, ptr, modifierDevice, pWin,
GRABTYPE_CORE, &mask, &param, ButtonPress,
stuff->button, confineTo, cursor);
if (!grab) if (!grab)
return BadAlloc; return BadAlloc;
return AddPassiveGrabToList(client, grab); return AddPassiveGrabToList(client, grab);

36
dix/grabs.c
View File

@ -58,6 +58,7 @@ SOFTWARE.
#include "cursorstr.h" #include "cursorstr.h"
#include "dixgrabs.h" #include "dixgrabs.h"
#include "xace.h" #include "xace.h"
#include "exevents.h"
#define BITMASK(i) (((Mask)1) << ((i) & 31)) #define BITMASK(i) (((Mask)1) << ((i) & 31))
#define MASKIDX(i) ((i) >> 5) #define MASKIDX(i) ((i) >> 5)
@ -70,13 +71,12 @@ GrabPtr
CreateGrab( CreateGrab(
int client, int client,
DeviceIntPtr device, DeviceIntPtr device,
WindowPtr window,
Mask eventMask,
Bool ownerEvents, Bool keyboardMode, Bool pointerMode,
DeviceIntPtr modDevice, DeviceIntPtr modDevice,
unsigned short modifiers, WindowPtr window,
GrabType grabtype,
GrabMask *mask,
GrabParameters *param,
int type, int type,
int grabtype,
KeyCode keybut, /* key or button */ KeyCode keybut, /* key or button */
WindowPtr confineTo, WindowPtr confineTo,
CursorPtr cursor) CursorPtr cursor)
@ -89,12 +89,12 @@ CreateGrab(
grab->resource = FakeClientID(client); grab->resource = FakeClientID(client);
grab->device = device; grab->device = device;
grab->window = window; grab->window = window;
grab->eventMask = eventMask; grab->eventMask = mask->core; /* same for XI */
grab->deviceMask = 0; grab->deviceMask = 0;
grab->ownerEvents = ownerEvents; grab->ownerEvents = param->ownerEvents;
grab->keyboardMode = keyboardMode; grab->keyboardMode = param->this_device_mode;
grab->pointerMode = pointerMode; grab->pointerMode = param->other_devices_mode;
grab->modifiersDetail.exact = modifiers; grab->modifiersDetail.exact = param->modifiers;
grab->modifiersDetail.pMask = NULL; grab->modifiersDetail.pMask = NULL;
grab->modifierDevice = modDevice; grab->modifierDevice = modDevice;
grab->type = type; grab->type = type;
@ -434,17 +434,21 @@ DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
&& (pMinuendGrab->modifiersDetail.exact != AnyModifier)) && (pMinuendGrab->modifiersDetail.exact != AnyModifier))
{ {
GrabPtr pNewGrab; GrabPtr pNewGrab;
GrabParameters param;
UPDATE(grab->detail.pMask, pMinuendGrab->detail.exact); UPDATE(grab->detail.pMask, pMinuendGrab->detail.exact);
memset(&param, 0, sizeof(param));
param.ownerEvents = grab->ownerEvents;
param.this_device_mode = grab->keyboardMode;
param.other_devices_mode = grab->pointerMode;
param.modifiers = AnyModifier;
pNewGrab = CreateGrab(CLIENT_ID(grab->resource), grab->device, pNewGrab = CreateGrab(CLIENT_ID(grab->resource), grab->device,
grab->window, (Mask)grab->eventMask, grab->modifierDevice, grab->window,
(Bool)grab->ownerEvents,
(Bool)grab->keyboardMode,
(Bool)grab->pointerMode,
grab->modifierDevice,
AnyModifier, (int)grab->type,
grab->grabtype, grab->grabtype,
(GrabMask*)grab->eventMask,
&param, (int)grab->type,
pMinuendGrab->detail.exact, pMinuendGrab->detail.exact,
grab->confineTo, grab->cursor); grab->confineTo, grab->cursor);
if (!pNewGrab) if (!pNewGrab)

19
include/dixgrabs.h
View File

@ -26,21 +26,20 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef DIXGRABS_H #ifndef DIXGRABS_H
#define DIXGRABS_H 1 #define DIXGRABS_H 1
extern _X_EXPORT GrabPtr CreateGrab( struct _GrabParameters;
extern GrabPtr CreateGrab(
int /* client */, int /* client */,
DeviceIntPtr /* device */, DeviceIntPtr /* device */,
WindowPtr /* window */,
Mask /* eventMask */,
Bool /* ownerEvents */,
Bool /* keyboardMode */,
Bool /* pointerMode */,
DeviceIntPtr /* modDevice */, DeviceIntPtr /* modDevice */,
unsigned short /* modifiers */, WindowPtr /* window */,
GrabType /* grabtype */,
GrabMask * /* mask */,
struct _GrabParameters * /* param */,
int /* type */, int /* type */,
int /* grabtype */,
KeyCode /* keybut */, KeyCode /* keybut */,
WindowPtr /* confineTo */, WindowPtr /* confineTo */,
CursorPtr /* cursor */); CursorPtr /* cursor */);
extern _X_EXPORT int DeletePassiveGrab( extern _X_EXPORT int DeletePassiveGrab(
pointer /* value */, pointer /* value */,

50
include/exevents.h
View File

@ -42,6 +42,18 @@ typedef struct _XIClientRec {
int minor_version; int minor_version;
} XIClientRec, *XIClientPtr; } XIClientRec, *XIClientPtr;
typedef struct _GrabParameters {
unsigned int ownerEvents;
unsigned int this_device_mode;
unsigned int other_devices_mode;
Window grabWindow;
Window confineTo;
Cursor cursor;
unsigned int modifiers;
} GrabParameters;
extern _X_EXPORT void RegisterOtherDevice ( extern _X_EXPORT void RegisterOtherDevice (
DeviceIntPtr /* device */); DeviceIntPtr /* device */);
@ -73,31 +85,27 @@ extern _X_EXPORT void DeviceFocusEvent(
int /* detail */, int /* detail */,
WindowPtr /* pWin */); WindowPtr /* pWin */);
extern _X_EXPORT int GrabButton( extern int CheckGrabValues(
ClientPtr /* client */, ClientPtr /* client */,
DeviceIntPtr /* dev */, GrabParameters* /* param */);
BYTE /* this_device_mode */,
BYTE /* other_devices_mode */,
CARD16 /* modifiers */,
DeviceIntPtr /* modifier_device */,
CARD8 /* button */,
Window /* grabWindow */,
BOOL /* ownerEvents */,
Cursor /* rcursor */,
Window /* rconfineTo */,
Mask /* eventMask */);
extern _X_EXPORT int GrabKey( extern int GrabButton(
ClientPtr /* client */, ClientPtr /* client */,
DeviceIntPtr /* dev */, DeviceIntPtr /* dev */,
BYTE /* this_device_mode */,
BYTE /* other_devices_mode */,
CARD16 /* modifiers */,
DeviceIntPtr /* modifier_device */, DeviceIntPtr /* modifier_device */,
CARD8 /* key */, int /* button */,
Window /* grabWindow */, GrabParameters* /* param */,
BOOL /* ownerEvents */, GrabType /* grabtype */,
Mask /* mask */); GrabMask* /* eventMask */);
extern int GrabKey(
ClientPtr /* client */,
DeviceIntPtr /* dev */,
DeviceIntPtr /* modifier_device */,
int /* key */,
GrabParameters* /* param */,
GrabType /* grabtype */,
GrabMask* /* eventMask */);
extern int SelectForWindow( extern int SelectForWindow(
DeviceIntPtr /* dev */, DeviceIntPtr /* dev */,

62
test/input.c
View File

@ -33,6 +33,7 @@
#include "windowstr.h" #include "windowstr.h"
#include "inputstr.h" #include "inputstr.h"
#include "eventconvert.h" #include "eventconvert.h"
#include "exevents.h"
#include <glib.h> #include <glib.h>
@ -73,6 +74,66 @@ static void dix_init_valuators(void)
g_assert(dev.last.numValuators == num_axes); g_assert(dev.last.numValuators == num_axes);
} }
/* just check the known success cases, and that error cases set the client's
* error value correctly. */
static void dix_check_grab_values(void)
{
ClientRec client;
GrabParameters param;
int rc;
memset(&client, 0, sizeof(client));
param.this_device_mode = GrabModeSync;
param.other_devices_mode = GrabModeSync;
param.modifiers = AnyModifier;
param.ownerEvents = FALSE;
rc = CheckGrabValues(&client, &param);
g_assert(rc == Success);
param.this_device_mode = GrabModeAsync;
rc = CheckGrabValues(&client, &param);
g_assert(rc == Success);
param.this_device_mode = GrabModeAsync + 1;
rc = CheckGrabValues(&client, &param);
g_assert(rc == BadValue);
g_assert(client.errorValue == param.this_device_mode);
g_assert(client.errorValue == GrabModeAsync + 1);
param.this_device_mode = GrabModeSync;
param.other_devices_mode = GrabModeAsync;
rc = CheckGrabValues(&client, &param);
g_assert(rc == Success);
param.other_devices_mode = GrabModeAsync + 1;
rc = CheckGrabValues(&client, &param);
g_assert(rc == BadValue);
g_assert(client.errorValue == param.other_devices_mode);
g_assert(client.errorValue == GrabModeAsync + 1);
param.other_devices_mode = GrabModeSync;
param.modifiers = 1 << 13;
rc = CheckGrabValues(&client, &param);
g_assert(rc == BadValue);
g_assert(client.errorValue == param.modifiers);
g_assert(client.errorValue == (1 << 13));
param.modifiers = AnyModifier;
param.ownerEvents = TRUE;
rc = CheckGrabValues(&client, &param);
g_assert(rc == Success);
param.ownerEvents = 3;
rc = CheckGrabValues(&client, &param);
g_assert(rc == BadValue);
g_assert(client.errorValue == param.ownerEvents);
g_assert(client.errorValue == 3);
}
/** /**
* Convert various internal events to the matching core event and verify the * Convert various internal events to the matching core event and verify the
@ -222,6 +283,7 @@ int main(int argc, char** argv)
g_test_add_func("/dix/input/init-valuators", dix_init_valuators); g_test_add_func("/dix/input/init-valuators", dix_init_valuators);
g_test_add_func("/dix/input/event-core-conversion", dix_event_to_core_conversion); g_test_add_func("/dix/input/event-core-conversion", dix_event_to_core_conversion);
g_test_add_func("/dix/input/check-grab-values", dix_check_grab_values);
return g_test_run(); return g_test_run();
} }