xscreensaver 6.00

1 files changed, 381 insertions, 0 deletions

diff --git a/driver/xinput.c b/driver/xinput.c
new file mode 100644
index 0000000..3b21db0
--- /dev/null
+++ b/driver/xinput.c
@@ -0,0 +1,381 @@
+/* xscreensaver, Copyright © 1991-2021 Jamie Zawinski <jwz@jwz.org>
+ *
+ * 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.  No representations are made about the suitability of this
+ * software for any purpose.  It is provided "as is" without express or 
+ * implied warranty.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XInput2.h>
+
+#include "blurb.h"
+#include "xinput.h"
+
+extern Bool debug_p;
+
+#undef countof
+#define countof(x) (sizeof((x))/sizeof((*x)))
+
+
+/* Initialize the XInput2 extension. Returns True on success.
+ */
+Bool
+init_xinput (Display *dpy, int *opcode_ret)
+{
+  int nscreens = ScreenCount (dpy);
+  XIEventMask evmasks[1];
+  unsigned char mask1[(XI_LASTEVENT + 7)/8];
+  int major, minor;
+  int xi_opcode, ev, err;
+  int i;
+  int ndevs = 0;
+  XIDeviceInfo *devs;
+
+  if (!XQueryExtension (dpy, "XInputExtension", &xi_opcode, &ev, &err))
+    {
+      fprintf (stderr, "%s: XInput extension missing\n", blurb());
+      return False;
+    }
+
+  major = 2;	/* Desired version */
+  minor = 2;
+  if (XIQueryVersion (dpy, &major, &minor) != Success)
+    {
+      fprintf (stderr, "%s: server only supports XInput %d.%d\n",
+               blurb(), major, minor);
+      return False;
+    }
+
+  if (verbose_p)
+    fprintf (stderr, "%s: XInput version %d.%d\n", blurb(), major, minor);
+
+  memset (mask1, 0, sizeof(mask1));
+
+  XISetMask (mask1, XI_RawMotion);
+  XISetMask (mask1, XI_RawKeyPress);
+  XISetMask (mask1, XI_RawKeyRelease);
+  XISetMask (mask1, XI_RawButtonPress);
+  XISetMask (mask1, XI_RawButtonRelease);
+  XISetMask (mask1, XI_RawTouchBegin);
+  XISetMask (mask1, XI_RawTouchUpdate);
+  XISetMask (mask1, XI_RawTouchEnd);
+
+  /* If we use XIAllDevices instead, we get double events. */
+  evmasks[0].deviceid = XIAllMasterDevices;
+  evmasks[0].mask_len = sizeof(mask1);
+  evmasks[0].mask = mask1;
+
+  for (i = 0; i < nscreens; i++)
+    {
+      Window root = RootWindow (dpy, i);
+      if (XISelectEvents (dpy, root, evmasks, countof(evmasks)) != Success)
+        {
+          fprintf (stderr, "%s: XISelectEvents failed\n", blurb());
+          return False;
+        }
+    }
+
+  XFlush (dpy);
+
+  devs = XIQueryDevice (dpy, XIAllDevices, &ndevs);
+  if (!ndevs)
+    {
+      fprintf (stderr, "%s: XInput: no devices\n", blurb());
+      return False;
+    }
+
+  if (verbose_p)
+    for (i = 0; i < ndevs; i++)
+      {
+        XIDeviceInfo *d = &devs[i];
+        fprintf (stderr, "%s:   device %2d/%d: %s: %s\n",
+                 blurb(), d->deviceid, d->attachment, 
+                 (d->use == XIMasterPointer  ? "MP" :
+                  d->use == XIMasterKeyboard ? "MK" :
+                  d->use == XISlavePointer   ? "SP" :
+                  d->use == XISlaveKeyboard  ? "SK" :
+                  d->use == XIFloatingSlave  ? "FS" : "??"),
+                 d->name);
+      }
+
+  XIFreeDeviceInfo (devs);
+  *opcode_ret = xi_opcode;
+  return True;
+}
+
+
+/* Convert an XInput2 event to corresponding old-school Xlib event.
+   Returns true on success.
+ */
+Bool
+xinput_event_to_xlib (int evtype, XIDeviceEvent *in, XEvent *out)
+{
+  Display *dpy = in->display;
+  Bool ok = False;
+
+  int root_x = 0, root_y = 0;
+  unsigned int mods = 0;
+
+  /* The closest thing to actual documentation on XInput2 seems to be a series
+     of blog posts by Peter Hutterer.  There's basically nothing about it on
+     www.x.org.  In http://who-t.blogspot.com/2009/07/xi2-recipes-part-4.html
+     he says: 
+
+       "XIDeviceEvent [...] contains the state of the modifier keys [...]
+       The base modifiers are the ones currently pressed, latched the ones
+       pressed until a key is pressed that's configured to unlatch it (e.g.
+       some shift-capslock interactions have this behaviour) and finally
+       locked modifiers are the ones permanently active until unlocked
+       (default capslock behaviour in the US layout). The effective modifiers
+       are a bitwise OR of the three above - which is essentially equivalent
+       to the modifiers state supplied in the core protocol events."
+
+     However, I'm seeing random noise in the various XIDeviceEvent.mods fields.
+     Nonsensical values like base = 0x6045FB3D.  So, let's poll the actual
+     modifiers from XQueryPointer.  This can race: maybe the modifier state
+     changed between when the server generated the keyboard event, and when
+     we receive it and poll.  However, if an actual human is typing and
+     releasing their modifier keys on such a tight timeframe... that's
+     probably already not going well.
+
+     I'm also seeing random noise in the event_xy and root_xy fields in
+     motion events.  So just always use XQueryPointer.
+   */
+  switch (evtype) {
+  case XI_RawKeyPress:
+  case XI_RawKeyRelease:
+  case XI_RawButtonPress:
+  case XI_RawButtonRelease:
+  case XI_RawMotion:
+    {
+      Window root_ret, child_ret;
+      int win_x, win_y;
+      int i;
+      for (i = 0; i < ScreenCount (dpy); i++)   /* query on correct screen */
+        if (XQueryPointer (dpy, RootWindow (dpy, i),
+                           &root_ret, &child_ret, &root_x, &root_y,
+                           &win_x, &win_y, &mods))
+          break;
+    }
+  default: break;
+  }
+
+  switch (evtype) {
+  case XI_RawKeyPress:
+  case XI_RawKeyRelease:
+    out->xkey.type      = (evtype == XI_RawKeyPress ? KeyPress : KeyRelease);
+    out->xkey.display   = in->display;
+    out->xkey.window    = in->event;
+    out->xkey.root      = in->root;
+    out->xkey.subwindow = in->child;
+    out->xkey.time      = in->time;
+    out->xkey.x         = root_x;
+    out->xkey.y         = root_y;
+    out->xkey.x_root    = root_x;
+    out->xkey.y_root    = root_y;
+    out->xkey.state     = mods;
+    out->xkey.keycode   = in->detail;
+    ok = True;
+    break;
+  case XI_RawButtonPress:
+  case XI_RawButtonRelease:
+    out->xbutton.type      = (evtype == XI_RawButtonPress 
+                              ? ButtonPress : ButtonRelease);
+    out->xbutton.display   = in->display;
+    out->xbutton.window    = in->event;
+    out->xbutton.root      = in->root;
+    out->xbutton.subwindow = in->child;
+    out->xbutton.time      = in->time;
+    out->xbutton.x         = root_x;
+    out->xbutton.y         = root_y;
+    out->xbutton.x_root    = root_x;
+    out->xbutton.y_root    = root_y;
+    out->xbutton.state     = mods;
+    out->xbutton.button    = in->detail;
+    ok = True;
+    break;
+  case XI_RawMotion:
+    out->xmotion.type      = MotionNotify;
+    out->xmotion.display   = in->display;
+    out->xmotion.window    = in->event;
+    out->xmotion.root      = in->root;
+    out->xmotion.subwindow = in->child;
+    out->xmotion.time      = in->time;
+    out->xmotion.x         = root_x;
+    out->xmotion.y         = root_y;
+    out->xmotion.x_root    = root_x;
+    out->xmotion.y_root    = root_y;
+    out->xmotion.state     = mods;
+    ok = True;
+    break;
+  default:
+    break;
+  }
+
+  return ok;
+}
+
+
+static void
+print_kbd_event (XEvent *xev, XComposeStatus *compose, Bool x11_p)
+{
+  if (debug_p)		/* Passwords show up in plaintext! */
+    {
+      KeySym keysym = 0;
+      char c[100];
+      char M[100], *mods = M;
+      int n = XLookupString (&xev->xkey, c, sizeof(c)-1, &keysym, compose);
+      const char *ks = keysym ? XKeysymToString (keysym) : "NULL";
+      c[n] = 0;
+      if      (*c == '\n') strcpy (c, "\\n");
+      else if (*c == '\r') strcpy (c, "\\r");
+      else if (*c == '\t') strcpy (c, "\\t");
+
+      *mods = 0;
+      if (xev->xkey.state & ShiftMask)   strcat (mods, "-Sh");
+      if (xev->xkey.state & LockMask)    strcat (mods, "-Lk");
+      if (xev->xkey.state & ControlMask) strcat (mods, "-C");
+      if (xev->xkey.state & Mod1Mask)    strcat (mods, "-M1");
+      if (xev->xkey.state & Mod2Mask)    strcat (mods, "-M2");
+      if (xev->xkey.state & Mod3Mask)    strcat (mods, "-M3");
+      if (xev->xkey.state & Mod4Mask)    strcat (mods, "-M4");
+      if (xev->xkey.state & Mod5Mask)    strcat (mods, "-M5");
+      if (*mods) mods++;
+      if (!*mods) strcat (mods, "0");
+
+      fprintf (stderr, "%s: %s    0x%02X %s %s \"%s\"\n", blurb(),
+               (x11_p
+                ? (xev->xkey.type == KeyPress
+                   ? "X11 KeyPress    "
+                   : "X11 KeyRelease  ")
+                : (xev->xkey.type == KeyPress
+                   ? "XI_RawKeyPress  "
+                   : "XI_RawKeyRelease")),
+               xev->xkey.keycode, mods, ks, c);
+    }
+  else			/* Log only that the KeyPress happened. */
+    {
+      fprintf (stderr, "%s: X11 Key%s\n", blurb(),
+               (xev->xkey.type == KeyPress ? "Press  " : "Release"));
+    }
+}
+
+
+void
+print_xinput_event (Display *dpy, XEvent *xev, const char *desc)
+{
+  XIRawEvent *re;
+
+  switch (xev->xany.type) {
+  case KeyPress:
+  case KeyRelease:
+    {
+      static XComposeStatus compose = { 0, };
+      print_kbd_event (xev, &compose, True);
+    }
+    break;
+
+  case ButtonPress:
+  case ButtonRelease:
+    fprintf (stderr, "%s: X11 Button%s   %d %d\n", blurb(),
+             (xev->xany.type == ButtonPress ? "Press  " : "Release"),
+             xev->xbutton.button, xev->xbutton.state);
+    break;
+
+  case MotionNotify:
+    fprintf (stderr, "%s: X11 MotionNotify   %4d, %-4d"
+             "                   %s\n",
+             blurb(), xev->xmotion.x_root, xev->xmotion.y_root,
+             (desc ? desc : ""));
+    break;
+  default:
+    break;
+  }
+
+  if (xev->xany.type != GenericEvent)
+    return;  /* not an XInput event */
+  
+  if (!xev->xcookie.data)
+    XGetEventData (dpy, &xev->xcookie);
+
+  re = xev->xcookie.data;
+  if (!re) return; /* Bogus XInput event */
+
+  switch (re->evtype) {
+  case XI_RawKeyPress:
+  case XI_RawKeyRelease:
+    if (debug_p)
+      {
+        /* Fake up an XKeyEvent in order to call XKeysymToString(). */
+        XEvent ev2;
+        Bool ok = xinput_event_to_xlib (xev->xcookie.evtype,
+                                        (XIDeviceEvent *) re,
+                                        &ev2);
+        if (!ok)
+          fprintf (stderr, "%s: unable to translate XInput2 event\n", blurb());
+        else
+          {
+            static XComposeStatus compose = { 0, };
+            print_kbd_event (&ev2, &compose, False);
+          }
+        break;
+      }
+    else
+      fprintf (stderr, "%s: XI RawKey%s\n", blurb(),
+               (re->evtype == XI_RawKeyPress ? "Press  " : "Release"));
+    break;
+
+  case XI_RawButtonPress:
+  case XI_RawButtonRelease:
+    fprintf (stderr, "%s: XI RawButton%s %d\n", blurb(),
+             (re->evtype == XI_RawButtonPress ? "Press  " : "Release"),
+             re->detail);
+    break;
+
+  case XI_RawMotion:
+    if (verbose_p > 1)
+      {
+        Window root_ret, child_ret;
+        int root_x, root_y;
+        int win_x, win_y;
+        unsigned int mask;
+        XQueryPointer (dpy, DefaultRootWindow (dpy),
+                       &root_ret, &child_ret, &root_x, &root_y,
+                       &win_x, &win_y, &mask);
+        fprintf (stderr,
+                 "%s: XI_RawMotion       %4d, %-4d  %7.02f, %-7.02f%s\n",
+                 blurb(), root_x, root_y, re->raw_values[0], re->raw_values[1],
+                 (desc ? desc : ""));
+      }
+    break;
+
+  /* Touch-screens, possibly trackpads or tablets. */
+  case XI_RawTouchBegin:
+    fprintf (stderr, "%s: XI RawTouchBegin\n", blurb());
+    break;
+  case XI_RawTouchEnd:
+    fprintf (stderr, "%s: XI RawTouchEnd\n", blurb());
+    break;
+  case XI_RawTouchUpdate:
+    if (verbose_p > 1)
+      fprintf (stderr, "%s: XI RawTouchUpdate\n", blurb());
+    break;
+
+  default:
+    fprintf (stderr, "%s: unknown XInput event %d\n", blurb(), re->type);
+    break;
+  }
+}