touchui: support XInput2 MT

views/touchui/touch_factory.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/touchui/touch_factory.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdkx.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
@@ skipping 11 matching lines @@
 // The X cursor is hidden if it is idle for kCursorIdleSeconds seconds.
 int kCursorIdleSeconds = 5;
 
 // Given the TouchParam, return the correspoding XIValuatorClassInfo using
 // the X device information through Atom name matching.
 XIValuatorClassInfo* FindTPValuator(Display* display,
                                     XIDeviceInfo* info,
                                     views::TouchFactory::TouchParam tp) {
   // Lookup table for mapping TouchParam to Atom string used in X.
   // A full set of Atom strings can be found at xserver-properties.h.
-  // For Slot ID, See this chromeos revision: http://git.chromium.org/gitweb/?
-  //        p=chromiumos/overlays/chromiumos-overlay.git;
-  //        a=commit;h=9164d0a75e48c4867e4ef4ab51f743ae231c059a
   static struct {
     views::TouchFactory::TouchParam tp;
     const char* atom;
   } kTouchParamAtom[] = {
     { views::TouchFactory::TP_TOUCH_MAJOR, "Abs MT Touch Major" },
     { views::TouchFactory::TP_TOUCH_MINOR, "Abs MT Touch Minor" },
     { views::TouchFactory::TP_ORIENTATION, "Abs MT Orientation" },
     { views::TouchFactory::TP_PRESSURE,    "Abs MT Pressure" },
+#if !defined(USE_XI2_1)
+    // For Slot ID, See this chromeos revision: http://git.chromium.org/gitweb/?
+    //        p=chromiumos/overlays/chromiumos-overlay.git;
+    //        a=commit;h=9164d0a75e48c4867e4ef4ab51f743ae231c059a
     { views::TouchFactory::TP_SLOT_ID,     "Abs MT Slot ID" },
+#endif
     { views::TouchFactory::TP_TRACKING_ID, "Abs MT Tracking ID" },
     { views::TouchFactory::TP_LAST_ENTRY, NULL },
   };
 
   const char* atom_tp = NULL;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTouchParamAtom); i++) {
     if (tp == kTouchParamAtom[i].tp) {
       atom_tp = kTouchParamAtom[i].atom;
       break;
@@ skipping 65 matching lines @@
 
 // static
 TouchFactory* TouchFactory::GetInstance() {
   return Singleton<TouchFactory>::get();
 }
 
 TouchFactory::TouchFactory()
     : is_cursor_visible_(true),
       keep_mouse_cursor_(false),
       cursor_timer_(),
+#if !defined(USE_XI2_1)
+      slots_used_(),
+#endif
       pointer_device_lookup_(),
-      touch_device_list_(),
-      slots_used_() {
+      touch_device_list_() {
 #if defined(TOUCH_UI)
   if (!base::MessagePumpForUI::HasXInput2())
     return;
 #endif
 
   char nodata[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   XColor black;
   black.red = black.green = black.blue = 0;
   Display* display = ui::GetXDisplay();
   Pixmap blank = XCreateBitmapFromData(display, ui::GetX11RootWindow(),
@@ skipping 41 matching lines @@
 void TouchFactory::UpdateDeviceList(Display* display) {
   // Detect touch devices.
   // NOTE: The new API for retrieving the list of devices (XIQueryDevice) does
   // not provide enough information to detect a touch device. As a result, the
   // old version of query function (XListInputDevices) is used instead.
   // If XInput2 is not supported, this will return null (with count of -1) so
   // we assume there cannot be any touch devices.
   int count = 0;
   touch_device_lookup_.reset();
   touch_device_list_.clear();
+#if !defined(USE_XI2_1)
   XDeviceInfo* devlist = XListInputDevices(display, &count);
   for (int i = 0; i < count; i++) {
     if (devlist[i].type) {
       const char* devtype = XGetAtomName(display, devlist[i].type);
       if (devtype && !strcmp(devtype, XI_TOUCHSCREEN)) {
         touch_device_lookup_[devlist[i].id] = true;
         touch_device_list_.push_back(devlist[i].id);
       }
     }
   }
   if (devlist)
     XFreeDeviceList(devlist);
+#endif
 
   // Instead of asking X for the list of devices all the time, let's maintain a
   // list of pointer devices we care about.
   // It should not be necessary to select for slave devices. XInput2 provides
   // enough information to the event callback to decide which slave device
   // triggered the event, thus decide whether the 'pointer event' is a
   // 'mouse event' or a 'touch event'.
   // However, on some desktops, some events from a master pointer are
   // not delivered to the client. So we select for slave devices instead.
   // If the touch device has 'GrabDevice' set and 'SendCoreEvents' unset (which
   // is possible), then the device is detected as a floating device, and a
   // floating device is not connected to a master device. So it is necessary to
   // also select on the floating devices.
   pointer_device_lookup_.reset();
   XIDeviceInfo* devices = XIQueryDevice(display, XIAllDevices, &count);
-  for (int i = 0; i < count; i++) {
-    XIDeviceInfo* devinfo = devices + i;
-    if (devinfo->use == XIFloatingSlave || devinfo->use == XISlavePointer) {
-      pointer_device_lookup_[devinfo->deviceid] = true;
+  if (devices) {
+    for (int i = 0; i < count; i++) {
+      if (!devices[i].enabled)
+        continue;
+      XIDeviceInfo* devinfo = devices + i;
+#if defined(USE_XI2_1)
+      for (int k = 0; k < devinfo->num_classes; ++k) {
+        XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
+        if (xiclassinfo->type == XITouchClass) {
+          XITouchClassInfo* tci = (XITouchClassInfo *)xiclassinfo;
+          // Only care direct touch device (such as touch screen) right now
+          if (tci->mode == XIDirectTouch) {
+            touch_device_lookup_[devinfo->deviceid] = true;
+            touch_device_list_.push_back(devinfo->deviceid);
+          }
+        }
+      }
+#endif
+      if (devinfo->use == XIFloatingSlave || devinfo->use == XISlavePointer)
+        pointer_device_lookup_[devinfo->deviceid] = true;
     }
   }
   if (devices)
     XIFreeDeviceInfo(devices);
 
   SetupValuator();
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
   DCHECK_EQ(GenericEvent, xev->type);
+#if defined(USE_XI2_1)
+  XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data);
+  if (event->evtype != XI_TouchBegin &&
+      event->evtype != XI_TouchUpdate &&
+      event->evtype != XI_TouchEnd)
+    return true;
 
+  XIDeviceEvent* xiev = reinterpret_cast<XIDeviceEvent*>(event);
+  return touch_device_lookup_[xiev->sourceid];
+#else
   XGenericEventCookie* cookie = &xev->xcookie;
   if (cookie->evtype != XI_ButtonPress &&
       cookie->evtype != XI_ButtonRelease &&
       cookie->evtype != XI_Motion)
     return true;
 
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(cookie->data);
   return pointer_device_lookup_[xiev->deviceid];
+#endif
 }
 
 void TouchFactory::SetupXI2ForXWindow(Window window) {
   // Setup mask for mouse events. It is possible that a device is loaded/plugged
   // in after we have setup XInput2 on a window. In such cases, we need to
   // either resetup XInput2 for the window, so that we get events from the new
   // device, or we need to listen to events from all devices, and then filter
   // the events from uninteresting devices. We do the latter because that's
   // simpler.
 
   Display* display = ui::GetXDisplay();
 
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   memset(mask, 0, sizeof(mask));
 
+#if defined(USE_XI2_1)
+  XISetMask(mask, XI_TouchBegin);
+  XISetMask(mask, XI_TouchUpdate);
+  XISetMask(mask, XI_TouchEnd);
+#else

[sadrul, 2011/09/07 14:56:37]

I think it'd be a good idea to select for XI_Button/Motion events here even when
XInput2.1 is available. (the event dipatching code may need to be updated
accordingly)

[ningxin.hu, 2011/09/08 08:24:50]

Yes. It is really a good idea. I am working on this.

   XISetMask(mask, XI_ButtonPress);
   XISetMask(mask, XI_ButtonRelease);
   XISetMask(mask, XI_Motion);
+#endif
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(display, window, &evmask, 1);
   XFlush(display);
 }
 
 void TouchFactory::SetTouchDeviceList(
     const std::vector<unsigned int>& devices) {
   touch_device_lookup_.reset();
   touch_device_list_.clear();
   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
     DCHECK(*iter < touch_device_lookup_.size());
     touch_device_lookup_[*iter] = true;
     touch_device_list_.push_back(*iter);
   }
 
   SetupValuator();
 }
 
 bool TouchFactory::IsTouchDevice(unsigned deviceid) const {
   return deviceid < touch_device_lookup_.size() ?
       touch_device_lookup_[deviceid] : false;
 }
 
+#if !defined(USE_XI2_1)
 bool TouchFactory::IsSlotUsed(int slot) const {
   CHECK_LT(slot, kMaxTouchPoints);
   return slots_used_[slot];
 }
 
 void TouchFactory::SetSlotUsed(int slot, bool used) {
   CHECK_LT(slot, kMaxTouchPoints);
   slots_used_[slot] = used;
 }
+#endif
 
 bool TouchFactory::GrabTouchDevices(Display* display, ::Window window) {
 #if defined(TOUCH_UI)
   if (!base::MessagePumpForUI::HasXInput2() ||
       touch_device_list_.empty())
     return true;
 #endif
 
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   bool success = true;
 
   memset(mask, 0, sizeof(mask));
+#if defined(USE_XI2_1)
+  XISetMask(mask, XI_TouchBegin);
+  XISetMask(mask, XI_TouchUpdate);
+  XISetMask(mask, XI_TouchEnd);
+#else

[sadrul, 2011/09/07 14:56:37]

ditto

[ningxin.hu, 2011/09/08 08:24:50]

Will select touch and mouse events for XI2.1

   XISetMask(mask, XI_ButtonPress);
   XISetMask(mask, XI_ButtonRelease);
   XISetMask(mask, XI_Motion);
+#endif
 
   XIEventMask evmask;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   for (std::vector<int>::const_iterator iter =
        touch_device_list_.begin();
        iter != touch_device_list_.end(); ++iter) {
     evmask.deviceid = *iter;
     Status status = XIGrabDevice(display, *iter, window, CurrentTime, None,
                                  GrabModeAsync, GrabModeAsync, False, &evmask);
@@ skipping 85 matching lines @@
                                      float* value) {
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
   if (xiev->sourceid >= kMaxDeviceNum)
     return false;
   int v = valuator_lookup_[xiev->sourceid][tp];
   if (v >= 0 && XIMaskIsSet(xiev->valuators.mask, v)) {
     *value = xiev->valuators.values[v];
     return true;
   }
 
+  // With XInput 2.1, Tracking ID could be provided in the detail field
+  if (tp == TP_TRACKING_ID) {
+    *value = xiev->detail;
+    return true;
+  }
+
   return false;
 }
 
 bool TouchFactory::NormalizeTouchParam(unsigned int deviceid,
                                        TouchParam tp,
                                        float* value) {
   float max_value;
   float min_value;
   if (GetTouchParamRange(deviceid, tp, &min_value, &max_value)) {
     *value = (*value - min_value) / (max_value - min_value);
     DCHECK(*value >= 0.0 && *value <= 1.0);
     return true;
   }
   return false;
 }
 
 bool TouchFactory::GetTouchParamRange(unsigned int deviceid,
                                       TouchParam tp,
                                       float* min,
                                       float* max) {
   if (valuator_lookup_[deviceid][tp] >= 0) {
     *min = touch_param_min_[deviceid][tp];
     *max = touch_param_max_[deviceid][tp];
     return true;
   }
   return false;
 }
 
 }  // namespace views