]> diplodocus.org Git - xorg-xinput/blobdiff - src/test_xi2.c
projects / xorg-xinput / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xinput 1.5.2
[xorg-xinput] / src / test_xi2.c
diff --git a/src/test_xi2.c b/src/test_xi2.c
index 713bc1a0f3ba0f9f59b243dfd5e155e149d1ed6d..9ddb2912340a95def1aa73888ce0d2b185df7817 100644 (file)
--- 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);
 
 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,
 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));
 
     Window subwindow = XCreateSimpleWindow(dpy, win, 50, 50, 50, 50, 0, 0,
             BlackPixel(dpy, 0));
 
-    XSelectInput(dpy, win, ExposureMask);
     XMapWindow(dpy, subwindow);
     XMapWindow(dpy, subwindow);
-    XMapWindow(dpy, win);
-    XFlush(dpy);
+    XSelectInput(dpy, win, ExposureMask);
     return win;
 }
 
     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("    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("    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:");
 
     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(" %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:");
 
     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");
 
             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);
 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);
 }
 
                                 "DeviceChanged");
     print_classes_xi2(dpy, event->classes, event->num_classes);
 }
 
-static void print_hierarchychangedevent(XIDeviceHierarchyEvent *event)
+static void print_hierarchychangedevent(XIHierarchyEvent *event)
 {
     int i;
 {
     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)
         {
     {
         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;
         }
 
                 break;
         }
 
@@ -119,10 +116,22 @@ static void print_hierarchychangedevent(XIDeviceHierarchyEvent *event)
                 use,
                 event->info[i].attachment,
                 (event->info[i].enabled) ? "enabled" : "disabled");
                 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;
 {
     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");
 
     printf("    detail: %d\n", event->detail);
     printf("    valuators:\n");
 
-    val = event->valuators->values;
+    val = event->valuators.values;
     raw_val = event->raw_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");
 }
             printf("         %2d: %.2f (%.2f)\n", i, *val++, *raw_val++);
     printf("\n");
 }
@@ -144,59 +153,79 @@ static void print_enterleave(XILeaveEvent* event)
     char *mode, *detail;
     int i;
 
     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)
     {
     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)
     {
     }
     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:");
     }
     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(" %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);
 
 }
 
 
     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;
 void
 test_sync_grab(Display *display, Window win)
 {
     int loop = 3;
     int rc;
-    XIDeviceEventMask mask;
+    XIEventMask mask;
 
     /* Select for motion events */
 
     /* Select for motion events */
-    mask.deviceid = AllDevices;
+    mask.deviceid = XIAllDevices;
     mask.mask_len = 2;
     mask.mask = calloc(2, sizeof(char));
     mask.mask_len = 2;
     mask.mask = calloc(2, sizeof(char));
-    SetBit(mask.mask, XI_ButtonPress);
+    XISetMask(mask.mask, XI_ButtonPress);
 
     if ((rc = XIGrabDevice(display, 2,  win, CurrentTime, None, GrabModeSync,
                            GrabModeAsync, False, &mask)) != GrabSuccess)
 
     if ((rc = XIGrabDevice(display, 2,  win, CurrentTime, None, GrabModeSync,
                            GrabModeAsync, False, &mask)) != GrabSuccess)
@@ -217,12 +246,11 @@ test_sync_grab(Display *display, Window win)
         XIEvent ev;
 
         XNextEvent(display, (XEvent*)&ev);
         XIEvent ev;
 
         XNextEvent(display, (XEvent*)&ev);
-        if (ev.type == GenericEvent)
+        if (ev.type == GenericEvent && ev.extension == xi_opcode )
         {
             XIDeviceEvent *event = (XIDeviceEvent*)&ev;
             print_deviceevent(event);
             XIAllowEvents(display, 2, SyncPointer, CurrentTime);
         {
             XIDeviceEvent *event = (XIDeviceEvent*)&ev;
             print_deviceevent(event);
             XIAllowEvents(display, 2, SyncPointer, CurrentTime);
-            XIFreeEventData(&ev);
         }
     }
 
         }
     }
 
@@ -230,6 +258,35 @@ test_sync_grab(Display *display, Window win)
     printf("Done\n");
 }
 
     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;
+        default:
+                                  name = "unknown event type"; break;
+    }
+    return name;
+}
+
+
 int
 test_xi2(Display       *display,
          int   argc,
 int
 test_xi2(Display       *display,
          int   argc,
@@ -237,35 +294,59 @@ test_xi2(Display  *display,
          char  *name,
          char  *desc)
 {
          char  *name,
          char  *desc)
 {
-    XIDeviceEventMask mask;
+    XIEventMask mask;
     Window win;
 
     list(display, argc, argv, name, desc);
     win = create_win(display);
 
     Window win;
 
     list(display, argc, argv, name, desc);
     win = create_win(display);
 
+    /* Select for motion events */
+    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);
 
     XSync(display, False);
 
-    /* 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;
+    {
+        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);
     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);
 
 
     free(mask.mask);
 
@@ -275,42 +356,52 @@ test_xi2(Display  *display,
         XSelectInput(display, win, 0);
     }
 
         XSelectInput(display, win, 0);
     }
 
+    /*
     test_sync_grab(display, win);
     test_sync_grab(display, win);
+    */
 
     while(1)
     {
 
     while(1)
     {
-        XIEvent ev;
+        XEvent ev;
+        XGenericEventCookie *cookie = (XGenericEventCookie*)&ev.xcookie;
         XNextEvent(display, (XEvent*)&ev);
         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 (%s)\n", cookie->evtype, type_to_name(cookie->evtype));
+            switch (cookie->evtype)
             {
                 case XI_DeviceChanged:
             {
                 case XI_DeviceChanged:
-                    print_devicechangedevent(display,
-                                             (XIDeviceChangedEvent*)event);
+                    print_devicechangedevent(display, cookie->data);
                     break;
                 case XI_HierarchyChanged:
                     break;
                 case XI_HierarchyChanged:
-                    print_hierarchychangedevent((XIDeviceHierarchyEvent*)event);
+                    print_hierarchychangedevent(cookie->data);
                     break;
                     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:
                     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:
                     break;
                 default:
-                    print_deviceevent(event);
+                    print_deviceevent(cookie->data);
                     break;
             }
         }
 
                     break;
             }
         }
 
-        XIFreeEventData(&ev);
+        XFreeEventData(display, cookie);
     }
 
     XDestroyWindow(display, win);
     }
 
     XDestroyWindow(display, win);
Fork of https://gitlab.freedesktop.org/xorg/app/xinput