X-Git-Url: https://diplodocus.org/git/xorg-xinput/blobdiff_plain/dd27752cbff03ea79ac76801d3748edc348570dc..09b075863708e43b9c1202dd052f36d5f865f571:/src/test_xi2.c diff --git a/src/test_xi2.c b/src/test_xi2.c index 9f56c2a..53d984f 100644 --- a/src/test_xi2.c +++ b/src/test_xi2.c @@ -29,9 +29,6 @@ extern void print_classes_xi2(Display*, XIAnyClassInfo **classes, int num_classes); -#define BitIsOn(ptr, bit) (((unsigned char *) (ptr))[(bit)>>3] & (1 << ((bit) & 7))) -#define SetBit(ptr, bit) (((unsigned char *) (ptr))[(bit)>>3] |= (1 << ((bit) & 7))) - static Window create_win(Display *dpy) { Window win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 200, @@ -39,10 +36,8 @@ static Window create_win(Display *dpy) Window subwindow = XCreateSimpleWindow(dpy, win, 50, 50, 50, 50, 0, 0, BlackPixel(dpy, 0)); - XSelectInput(dpy, win, ExposureMask); XMapWindow(dpy, subwindow); - XMapWindow(dpy, win); - XFlush(dpy); + XSelectInput(dpy, win, ExposureMask); return win; } @@ -53,27 +48,28 @@ static void print_deviceevent(XIDeviceEvent* event) printf(" device: %d (%d)\n", event->deviceid, event->sourceid); printf(" detail: %d\n", event->detail); + printf(" flags: %s\n", (event->flags & XIKeyRepeat) ? "repeat" : ""); printf(" root: %.2f/%.2f\n", event->root_x, event->root_y); - printf(" event: %.2f/%.2f\n", event->event_x, event->event_x); + printf(" event: %.2f/%.2f\n", event->event_x, event->event_y); printf(" buttons:"); - for (i = 0; i < event->buttons->mask_len * 8; i++) - if (BitIsOn(event->buttons->mask, i)) + for (i = 0; i < event->buttons.mask_len * 8; i++) + if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); - printf(" modifiers: locked 0x%x latched 0x%x base 0x%x\n", - event->mods->locked, event->mods->latched, - event->mods->base); - printf(" group: locked 0x%x latched 0x%x base 0x%x\n", - event->group->locked, event->group->latched, - event->group->base); + 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:"); - val = event->valuators->values; - for (i = 0; i < event->valuators->mask_len * 8; i++) - if (BitIsOn(event->valuators->mask, i)) + val = event->valuators.values; + for (i = 0; i < event->valuators.mask_len * 8; i++) + if (XIMaskIsSet(event->valuators.mask, i)) printf(" %.2f", *val++); printf("\n"); @@ -84,33 +80,34 @@ static void print_deviceevent(XIDeviceEvent* event) static void print_devicechangedevent(Display *dpy, XIDeviceChangedEvent *event) { printf(" device: %d (%d)\n", event->deviceid, event->sourceid); - printf(" reason: %s\n", (event->reason == SlaveSwitch) ? "SlaveSwitch" : + printf(" reason: %s\n", (event->reason == XISlaveSwitch) ? "SlaveSwitch" : "DeviceChanged"); print_classes_xi2(dpy, event->classes, event->num_classes); } -static void print_hierarchychangedevent(XIDeviceHierarchyEvent *event) +static void print_hierarchychangedevent(XIHierarchyEvent *event) { int i; - printf(" Changes happened: %s %s %s %s %s %s %s\n", - (event->flags & HF_MasterAdded) ? "[new master]" : "", - (event->flags & HF_MasterRemoved) ? "[master removed]" : "", - (event->flags & HF_SlaveAdded) ? "[new slave]" : "", - (event->flags & HF_SlaveRemoved) ? "[slave removed]" : "", - (event->flags & HF_SlaveAttached) ? "[slave attached]" : "", - (event->flags & HF_DeviceEnabled) ? "[device enabled]" : "", - (event->flags & HF_DeviceDisabled) ? "[device disabled]" : ""); - - for (i = 0; i < event->num_devices; 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 MasterPointer: use = "master pointer"; - case MasterKeyboard: use = "master keyboard"; break; - case SlavePointer: use = "slave pointer"; - case SlaveKeyboard: use = "slave keyboard"; break; - case FloatingSlave: use = "floating slave"; break; + 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; } @@ -119,10 +116,22 @@ static void print_hierarchychangedevent(XIDeviceHierarchyEvent *event) 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(XIRawDeviceEvent *event) +static void print_rawevent(XIRawEvent *event) { int i; double *val, *raw_val; @@ -131,10 +140,10 @@ static void print_rawevent(XIRawDeviceEvent *event) printf(" detail: %d\n", event->detail); printf(" valuators:\n"); - val = event->valuators->values; + val = event->valuators.values; raw_val = event->raw_values; - for (i = 0; i < event->valuators->mask_len * 8; i++) - if (BitIsOn(event->valuators->mask, i)) + 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"); } @@ -144,47 +153,111 @@ static void print_enterleave(XILeaveEvent* event) char *mode, *detail; int i; + printf(" device: %d\n", event->deviceid); printf(" windows: root 0x%lx event 0x%lx child 0x%ld\n", event->root, event->event, event->child); switch(event->mode) { - case NotifyNormal: mode = "NotifyNormal"; break; - case NotifyGrab: mode = "NotifyGrab"; break; - case NotifyUngrab: mode = "NotifyUngrab"; break; - case NotifyWhileGrabbed: mode = "NotifyWhileGrabbed"; break; + 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 NotifyAncestor: detail = "NotifyAncestor"; break; - case NotifyVirtual: detail = "NotifyVirtual"; break; - case NotifyInferior: detail = "NotifyInferior"; break; - case NotifyNonlinear: detail = "NotifyNonlinear"; break; - case NotifyNonlinearVirtual: detail = "NotifyNonlinearVirtual"; break; - case NotifyPointer: detail = "NotifyPointer"; break; - case NotifyPointerRoot: detail = "NotifyPointerRoot"; break; - case NotifyDetailNone: detail = "NotifyDetailNone"; break; + 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 (BitIsOn(event->buttons->mask, i)) + for (i = 0; i < event->buttons.mask_len * 8; i++) + if (XIMaskIsSet(event->buttons.mask, i)) printf(" %d", i); printf("\n"); - printf(" modifiers: locked 0x%x latched 0x%x base 0x%x\n", - event->mods->locked, event->mods->latched, - event->mods->base); - printf(" group: locked 0x%x latched 0x%x base 0x%x\n", - event->group->locked, event->group->latched, - event->group->base); + 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"); +} + int test_xi2(Display *display, int argc, @@ -192,33 +265,59 @@ test_xi2(Display *display, char *name, char *desc) { - XIDeviceEventMask mask; + XIEventMask mask; Window win; list(display, argc, argv, name, desc); win = create_win(display); /* Select for motion events */ - mask.deviceid = AllDevices; - mask.mask_len = 2; - mask.mask = calloc(2, sizeof(char)); - SetBit(mask.mask, XI_ButtonPress); - SetBit(mask.mask, XI_ButtonRelease); - SetBit(mask.mask, XI_Motion); - SetBit(mask.mask, XI_KeyPress); - SetBit(mask.mask, XI_KeyPress); - SetBit(mask.mask, XI_DeviceChanged); - SetBit(mask.mask, XI_Enter); - SetBit(mask.mask, XI_Leave); - SetBit(mask.mask, XI_FocusIn); - SetBit(mask.mask, XI_FocusOut); - SetBit(mask.mask, XI_HierarchyChanged); - XISelectEvent(display, win, &mask, 1); - - mask.deviceid = AllMasterDevices; + mask.deviceid = XIAllDevices; + mask.mask_len = XIMaskLen(XI_RawMotion); + mask.mask = calloc(mask.mask_len, sizeof(char)); + XISetMask(mask.mask, XI_ButtonPress); + XISetMask(mask.mask, XI_ButtonRelease); + XISetMask(mask.mask, XI_KeyPress); + XISetMask(mask.mask, XI_KeyRelease); + XISetMask(mask.mask, XI_Motion); + XISetMask(mask.mask, XI_DeviceChanged); + XISetMask(mask.mask, XI_Enter); + XISetMask(mask.mask, XI_Leave); + XISetMask(mask.mask, XI_FocusIn); + XISetMask(mask.mask, XI_FocusOut); + XISetMask(mask.mask, XI_HierarchyChanged); + XISetMask(mask.mask, XI_PropertyEvent); + XISelectEvents(display, win, &mask, 1); + XMapWindow(display, win); + XSync(display, False); + + { + XIGrabModifiers modifiers[] = {{0, 0}, {0, 0x10}, {0, 0x1}, {0, 0x11}}; + int nmods = sizeof(modifiers)/sizeof(modifiers[0]); + + mask.deviceid = 2; + memset(mask.mask, 0, 2); + XISetMask(mask.mask, XI_KeyPress); + XISetMask(mask.mask, XI_KeyRelease); + XISetMask(mask.mask, XI_ButtonPress); + XISetMask(mask.mask, XI_ButtonRelease); + XISetMask(mask.mask, XI_Motion); + XIGrabButton(display, 2, 1, win, None, GrabModeAsync, GrabModeAsync, + False, &mask, nmods, modifiers); + XIGrabKeycode(display, 3, 24 /* q */, win, GrabModeAsync, GrabModeAsync, + False, &mask, nmods, modifiers); + XIUngrabButton(display, 3, 1, win, nmods - 2, &modifiers[2]); + XIUngrabKeycode(display, 3, 24 /* q */, win, nmods - 2, &modifiers[2]); + } + + mask.deviceid = XIAllMasterDevices; memset(mask.mask, 0, 2); - SetBit(mask.mask, XI_RawEvent); - XISelectEvent(display, DefaultRootWindow(display), &mask, 1); + XISetMask(mask.mask, XI_RawKeyPress); + XISetMask(mask.mask, XI_RawKeyRelease); + XISetMask(mask.mask, XI_RawButtonPress); + XISetMask(mask.mask, XI_RawButtonRelease); + XISetMask(mask.mask, XI_RawMotion); + XISelectEvents(display, DefaultRootWindow(display), &mask, 1); free(mask.mask); @@ -228,41 +327,52 @@ test_xi2(Display *display, XSelectInput(display, win, 0); } + /* + test_sync_grab(display, win); + */ while(1) { - XIEvent ev; + XEvent ev; + XGenericEventCookie *cookie = (XGenericEventCookie*)&ev.xcookie; XNextEvent(display, (XEvent*)&ev); - if (ev.type == GenericEvent) - { - XIDeviceEvent *event = (XIDeviceEvent*)&ev; - printf("EVENT type %d\n", event->evtype); - switch (event->evtype) + if (XGetEventData(display, cookie) && + cookie->type == GenericEvent && + cookie->extension == xi_opcode) + { + printf("EVENT type %d\n", cookie->evtype); + switch (cookie->evtype) { case XI_DeviceChanged: - print_devicechangedevent(display, - (XIDeviceChangedEvent*)event); + print_devicechangedevent(display, cookie->data); break; case XI_HierarchyChanged: - print_hierarchychangedevent((XIDeviceHierarchyEvent*)event); + print_hierarchychangedevent(cookie->data); break; - case XI_RawEvent: - print_rawevent((XIRawDeviceEvent*)event); + case XI_RawKeyPress: + case XI_RawKeyRelease: + case XI_RawButtonPress: + case XI_RawButtonRelease: + case XI_RawMotion: + print_rawevent(cookie->data); break; case XI_Enter: case XI_Leave: case XI_FocusIn: case XI_FocusOut: - print_enterleave((XILeaveEvent*)event); + print_enterleave(cookie->data); + break; + case XI_PropertyEvent: + print_propertyevent(display, cookie->data); break; default: - print_deviceevent(event); + print_deviceevent(cookie->data); break; } } - XIFreeEventData(&ev); + XFreeEventData(display, cookie); } XDestroyWindow(display, win);