From 2c44f1d365803c89b3c61ff040a4280bc9c94150 Mon Sep 17 00:00:00 2001 From: Frediano Ziglio Date: Mon, 3 Aug 2015 10:05:05 +0100 Subject: Import code for XInput --- test_xi2.c | 464 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 464 insertions(+) create mode 100644 test_xi2.c diff --git a/test_xi2.c b/test_xi2.c new file mode 100644 index 0000000..c8dbf34 --- /dev/null +++ b/test_xi2.c @@ -0,0 +1,464 @@ +/* + * Copyright © 2009 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. + * + */ + + +#include "xinput.h" +#include + +extern void print_classes_xi2(Display*, XIAnyClassInfo **classes, + int num_classes); + +static Window create_win(Display *dpy) +{ + Window win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 200, + 200, 0, 0, WhitePixel(dpy, 0)); + Window subwindow = XCreateSimpleWindow(dpy, win, 50, 50, 50, 50, 0, 0, + BlackPixel(dpy, 0)); + + XMapWindow(dpy, subwindow); + XSelectInput(dpy, win, ExposureMask); + return win; +} + +static void print_deviceevent(XIDeviceEvent* event) +{ + double *val; + int i; + + printf(" device: %d (%d)\n", event->deviceid, event->sourceid); + printf(" detail: %d\n", event->detail); + switch(event->evtype) { + case XI_KeyPress: + case XI_KeyRelease: + printf(" flags: %s\n", (event->flags & XIKeyRepeat) ? "repeat" : ""); + break; +#if HAVE_XI21 + case XI_ButtonPress: + case XI_ButtonRelease: + case XI_Motion: + printf(" flags: %s\n", (event->flags & XIPointerEmulated) ? "emulated" : ""); + break; +#endif + } + + printf(" root: %.2f/%.2f\n", event->root_x, event->root_y); + printf(" event: %.2f/%.2f\n", event->event_x, event->event_y); + + printf(" buttons:"); + for (i = 0; i < event->buttons.mask_len * 8; i++) + if (XIMaskIsSet(event->buttons.mask, i)) + printf(" %d", i); + printf("\n"); + + printf(" modifiers: locked %#x latched %#x base %#x effective: %#x\n", + event->mods.locked, event->mods.latched, + event->mods.base, event->mods.effective); + printf(" group: locked %#x latched %#x base %#x effective: %#x\n", + event->group.locked, event->group.latched, + event->group.base, event->group.effective); + printf(" valuators:\n"); + + val = event->valuators.values; + for (i = 0; i < event->valuators.mask_len * 8; i++) + if (XIMaskIsSet(event->valuators.mask, i)) + printf(" %i: %.2f\n", i, *val++); + + printf(" windows: root 0x%lx event 0x%lx child 0x%lx\n", + event->root, event->event, event->child); +} + +static void print_devicechangedevent(Display *dpy, XIDeviceChangedEvent *event) +{ + printf(" device: %d (%d)\n", event->deviceid, event->sourceid); + printf(" reason: %s\n", (event->reason == XISlaveSwitch) ? "SlaveSwitch" : + "DeviceChanged"); + print_classes_xi2(dpy, event->classes, event->num_classes); +} + +static void print_hierarchychangedevent(XIHierarchyEvent *event) +{ + int i; + printf(" Changes happened: %s %s %s %s %s %s %s %s\n", + (event->flags & XIMasterAdded) ? "[new master]" : "", + (event->flags & XIMasterRemoved) ? "[master removed]" : "", + (event->flags & XISlaveAdded) ? "[new slave]" : "", + (event->flags & XISlaveRemoved) ? "[slave removed]" : "", + (event->flags & XISlaveAttached) ? "[slave attached]" : "", + (event->flags & XISlaveDetached) ? "[slave detached]" : "", + (event->flags & XIDeviceEnabled) ? "[device enabled]" : "", + (event->flags & XIDeviceDisabled) ? "[device disabled]" : ""); + + for (i = 0; i < event->num_info; i++) + { + char *use = ""; + switch(event->info[i].use) + { + case XIMasterPointer: use = "master pointer"; break; + case XIMasterKeyboard: use = "master keyboard"; break; + case XISlavePointer: use = "slave pointer"; break; + case XISlaveKeyboard: use = "slave keyboard"; break; + case XIFloatingSlave: use = "floating slave"; break; + break; + } + + printf(" device %d [%s (%d)] is %s\n", + event->info[i].deviceid, + use, + event->info[i].attachment, + (event->info[i].enabled) ? "enabled" : "disabled"); + if (event->info[i].flags) + { + printf(" changes: %s %s %s %s %s %s %s %s\n", + (event->info[i].flags & XIMasterAdded) ? "[new master]" : "", + (event->info[i].flags & XIMasterRemoved) ? "[master removed]" : "", + (event->info[i].flags & XISlaveAdded) ? "[new slave]" : "", + (event->info[i].flags & XISlaveRemoved) ? "[slave removed]" : "", + (event->info[i].flags & XISlaveAttached) ? "[slave attached]" : "", + (event->info[i].flags & XISlaveDetached) ? "[slave detached]" : "", + (event->info[i].flags & XIDeviceEnabled) ? "[device enabled]" : "", + (event->info[i].flags & XIDeviceDisabled) ? "[device disabled]" : ""); + } + } +} + +static void print_rawevent(XIRawEvent *event) +{ + int i; + double *val, *raw_val; + + printf(" device: %d (%d)\n", event->deviceid, event->sourceid); + printf(" detail: %d\n", event->detail); + printf(" valuators:\n"); +#if HAVE_XI21 + switch(event->evtype) { + case XI_RawButtonPress: + case XI_RawButtonRelease: + case XI_RawMotion: + printf(" flags: %s\n", (event->flags & XIPointerEmulated) ? "emulated" : ""); + break; + } +#endif + + val = event->valuators.values; + raw_val = event->raw_values; + for (i = 0; i < event->valuators.mask_len * 8; i++) + if (XIMaskIsSet(event->valuators.mask, i)) + printf(" %2d: %.2f (%.2f)\n", i, *val++, *raw_val++); + printf("\n"); +} + +static void print_enterleave(XILeaveEvent* event) +{ + char *mode = "", + *detail = ""; + int i; + + printf(" device: %d (%d)\n", event->deviceid, event->sourceid); + printf(" windows: root 0x%lx event 0x%lx child 0x%ld\n", + event->root, event->event, event->child); + switch(event->mode) + { + case XINotifyNormal: mode = "NotifyNormal"; break; + case XINotifyGrab: mode = "NotifyGrab"; break; + case XINotifyUngrab: mode = "NotifyUngrab"; break; + case XINotifyWhileGrabbed: mode = "NotifyWhileGrabbed"; break; + case XINotifyPassiveGrab: mode = "NotifyPassiveGrab"; break; + case XINotifyPassiveUngrab:mode = "NotifyPassiveUngrab"; break; + } + switch (event->detail) + { + case XINotifyAncestor: detail = "NotifyAncestor"; break; + case XINotifyVirtual: detail = "NotifyVirtual"; break; + case XINotifyInferior: detail = "NotifyInferior"; break; + case XINotifyNonlinear: detail = "NotifyNonlinear"; break; + case XINotifyNonlinearVirtual: detail = "NotifyNonlinearVirtual"; break; + case XINotifyPointer: detail = "NotifyPointer"; break; + case XINotifyPointerRoot: detail = "NotifyPointerRoot"; break; + case XINotifyDetailNone: detail = "NotifyDetailNone"; break; + } + printf(" mode: %s (detail %s)\n", mode, detail); + printf(" flags: %s %s\n", event->focus ? "[focus]" : "", + event->same_screen ? "[same screen]" : ""); + printf(" buttons:"); + for (i = 0; i < event->buttons.mask_len * 8; i++) + if (XIMaskIsSet(event->buttons.mask, i)) + printf(" %d", i); + printf("\n"); + + printf(" modifiers: locked %#x latched %#x base %#x effective: %#x\n", + event->mods.locked, event->mods.latched, + event->mods.base, event->mods.effective); + printf(" group: locked %#x latched %#x base %#x effective: %#x\n", + event->group.locked, event->group.latched, + event->group.base, event->group.effective); + + printf(" root x/y: %.2f / %.2f\n", event->root_x, event->root_y); + printf(" event x/y: %.2f / %.2f\n", event->event_x, event->event_y); + +} + +static void print_propertyevent(Display *display, XIPropertyEvent* event) +{ + char *changed; + char *name; + + if (event->what == XIPropertyDeleted) + changed = "deleted"; + else if (event->what == XIPropertyCreated) + changed = "created"; + else + changed = "modified"; + name = XGetAtomName(display, event->property); + printf(" property: %ld '%s'\n", event->property, name); + printf(" changed: %s\n", changed); + + XFree(name); +} +void +test_sync_grab(Display *display, Window win) +{ + int loop = 3; + int rc; + XIEventMask mask; + + /* Select for motion events */ + mask.deviceid = XIAllDevices; + mask.mask_len = 2; + mask.mask = calloc(2, sizeof(char)); + XISetMask(mask.mask, XI_ButtonPress); + + if ((rc = XIGrabDevice(display, 2, win, CurrentTime, None, GrabModeSync, + GrabModeAsync, False, &mask)) != GrabSuccess) + { + fprintf(stderr, "Grab failed with %d\n", rc); + return; + } + free(mask.mask); + + XSync(display, True); + XIAllowEvents(display, 2, SyncPointer, CurrentTime); + XFlush(display); + + printf("Holding sync grab for %d button presses.\n", loop); + + while(loop--) + { + XIEvent ev; + + XNextEvent(display, (XEvent*)&ev); + if (ev.type == GenericEvent && ev.extension == xi_opcode ) + { + XIDeviceEvent *event = (XIDeviceEvent*)&ev; + print_deviceevent(event); + XIAllowEvents(display, 2, SyncPointer, CurrentTime); + } + } + + XIUngrabDevice(display, 2, CurrentTime); + printf("Done\n"); +} + +static const char* type_to_name(int evtype) +{ + const char *name; + + switch(evtype) { + case XI_DeviceChanged: name = "DeviceChanged"; break; + case XI_KeyPress: name = "KeyPress"; break; + case XI_KeyRelease: name = "KeyRelease"; break; + case XI_ButtonPress: name = "ButtonPress"; break; + case XI_ButtonRelease: name = "ButtonRelease"; break; + case XI_Motion: name = "Motion"; break; + case XI_Enter: name = "Enter"; break; + case XI_Leave: name = "Leave"; break; + case XI_FocusIn: name = "FocusIn"; break; + case XI_FocusOut: name = "FocusOut"; break; + case XI_HierarchyChanged: name = "HierarchyChanged"; break; + case XI_PropertyEvent: name = "PropertyEvent"; break; + case XI_RawKeyPress: name = "RawKeyPress"; break; + case XI_RawKeyRelease: name = "RawKeyRelease"; break; + case XI_RawButtonPress: name = "RawButtonPress"; break; + case XI_RawButtonRelease: name = "RawButtonRelease"; break; + case XI_RawMotion: name = "RawMotion"; break; + case XI_TouchBegin: name = "TouchBegin"; break; + case XI_TouchUpdate: name = "TouchUpdate"; break; + case XI_TouchEnd: name = "TouchEnd"; break; + case XI_RawTouchBegin: name = "RawTouchBegin"; break; + case XI_RawTouchUpdate: name = "RawTouchUpdate"; break; + case XI_RawTouchEnd: name = "RawTouchEnd"; break; + default: + name = "unknown event type"; break; + } + return name; +} + + +int +test_xi2(Display *display, + int argc, + char *argv[], + char *name, + char *desc) +{ + XIEventMask mask[2]; + XIEventMask *m; + Window win; + int deviceid = -1; + int use_root = 0; + int rc; + + setvbuf(stdout, NULL, _IOLBF, 0); + + if (argc >= 1 && strcmp(argv[0], "--root") == 0) { + use_root = 1; + + argc--; + argv++; + } + + rc = list(display, argc, argv, name, desc); + if (rc != EXIT_SUCCESS) + return rc; + + if (use_root) + win = DefaultRootWindow(display); + else + win = create_win(display); + + if (argc >= 1) { + XIDeviceInfo *info; + info = xi2_find_device_info(display, argv[0]); + deviceid = info->deviceid; + } + + /* Select for motion events */ + m = &mask[0]; + m->deviceid = (deviceid == -1) ? XIAllDevices : deviceid; + m->mask_len = XIMaskLen(XI_LASTEVENT); + m->mask = calloc(m->mask_len, sizeof(char)); + XISetMask(m->mask, XI_ButtonPress); + XISetMask(m->mask, XI_ButtonRelease); + XISetMask(m->mask, XI_KeyPress); + XISetMask(m->mask, XI_KeyRelease); + XISetMask(m->mask, XI_Motion); + XISetMask(m->mask, XI_DeviceChanged); + XISetMask(m->mask, XI_Enter); + XISetMask(m->mask, XI_Leave); + XISetMask(m->mask, XI_FocusIn); + XISetMask(m->mask, XI_FocusOut); +#ifdef HAVE_XI22 + XISetMask(m->mask, XI_TouchBegin); + XISetMask(m->mask, XI_TouchUpdate); + XISetMask(m->mask, XI_TouchEnd); +#endif + if (m->deviceid == XIAllDevices) + XISetMask(m->mask, XI_HierarchyChanged); + XISetMask(m->mask, XI_PropertyEvent); + + m = &mask[1]; + m->deviceid = (deviceid == -1) ? XIAllMasterDevices : deviceid; + m->mask_len = XIMaskLen(XI_LASTEVENT); + m->mask = calloc(m->mask_len, sizeof(char)); + XISetMask(m->mask, XI_RawKeyPress); + XISetMask(m->mask, XI_RawKeyRelease); + XISetMask(m->mask, XI_RawButtonPress); + XISetMask(m->mask, XI_RawButtonRelease); + XISetMask(m->mask, XI_RawMotion); +#ifdef HAVE_XI22 + XISetMask(m->mask, XI_RawTouchBegin); + XISetMask(m->mask, XI_RawTouchUpdate); + XISetMask(m->mask, XI_RawTouchEnd); +#endif + + XISelectEvents(display, win, &mask[0], use_root ? 2 : 1); + if (!use_root) { + XISelectEvents(display, DefaultRootWindow(display), &mask[1], 1); + XMapWindow(display, win); + } + XSync(display, False); + + free(mask[0].mask); + free(mask[1].mask); + + if (!use_root) { + XEvent event; + XMaskEvent(display, ExposureMask, &event); + XSelectInput(display, win, 0); + } + + /* + test_sync_grab(display, win); + */ + + while(1) + { + XEvent ev; + XGenericEventCookie *cookie = (XGenericEventCookie*)&ev.xcookie; + XNextEvent(display, (XEvent*)&ev); + + if (XGetEventData(display, cookie) && + cookie->type == GenericEvent && + cookie->extension == xi_opcode) + { + printf("EVENT type %d (%s)\n", cookie->evtype, type_to_name(cookie->evtype)); + switch (cookie->evtype) + { + case XI_DeviceChanged: + print_devicechangedevent(display, cookie->data); + break; + case XI_HierarchyChanged: + print_hierarchychangedevent(cookie->data); + break; + case XI_RawKeyPress: + case XI_RawKeyRelease: + case XI_RawButtonPress: + case XI_RawButtonRelease: + case XI_RawMotion: + case XI_RawTouchBegin: + case XI_RawTouchUpdate: + case XI_RawTouchEnd: + print_rawevent(cookie->data); + break; + case XI_Enter: + case XI_Leave: + case XI_FocusIn: + case XI_FocusOut: + print_enterleave(cookie->data); + break; + case XI_PropertyEvent: + print_propertyevent(display, cookie->data); + break; + default: + print_deviceevent(cookie->data); + break; + } + } + + XFreeEventData(display, cookie); + } + + XDestroyWindow(display, win); + + return EXIT_SUCCESS; +} -- cgit v1.2.3