This patch implements Chromium's Aura gesture recognizer in terms of utouch-grail and utouch-frame …

ui/base/touch/touch_factory.cc

 // Copyright (c) 2012 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 "ui/base/touch/touch_factory.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/XIproto.h>
 
+#include <string>
+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "ui/base/touch/multi_touch_device.h"
+#include "ui/base/touch/multi_touch_device_x11.h"
 #include "ui/base/x/x11_util.h"
 
 namespace {
 
 // The X cursor is hidden if it is idle for kCursorIdleSeconds seconds.
 int kCursorIdleSeconds = 5;
 
+ui::Axis::Type TouchParamToAxisType(ui::TouchFactory::TouchParam tp) {

[sadrul, 2012/04/03 19:52:01]

We have way too many types as it is. Either get rid of TouchFactory::TouchParam,
or don't add ui::Axis::Type

+  ui::Axis::Type type = ui::Axis::AXIS_TYPE_UNKNOWN;
+  switch (tp) {
+    case ui::TouchFactory::TP_TOUCH_MAJOR:
+      // Length of the touch area.
+      type = ui::Axis::AXIS_TYPE_TOUCH_MAJOR;
+      break;
+    case ui::TouchFactory::TP_TOUCH_MINOR:
+      // Width of the touch area.
+      type = ui::Axis::AXIS_TYPE_TOUCH_MINOR;
+      break;
+    case ui::TouchFactory::TP_ORIENTATION:
+      // Angle between the X-axis and the major axis of the
+      // touch area.
+      type = ui::Axis::AXIS_TYPE_ORIENTATION;
+      break;
+    case ui::TouchFactory::TP_PRESSURE:
+      // Pressure of the touch contact.
+      type = ui::Axis::AXIS_TYPE_PRESSURE;
+    case ui::TouchFactory::TP_TRACKING_ID:
+      // ID of the touch point.
+      type = ui::Axis::AXIS_TYPE_TRACKING_ID;
+    default:
+      break;
+  }
+
+  return type;
+}
+
 // Given the TouchParam, return the correspoding XIValuatorClassInfo using
 // the X device information through Atom name matching.
 XIValuatorClassInfo* FindTPValuator(Display* display,
                                     XIDeviceInfo* info,
                                     ui::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.
   static struct {
     ui::TouchFactory::TouchParam tp;
     const char* atom;
@@ skipping 32 matching lines @@
 
     if (v->label) {
       ui::XScopedString atom(XGetAtomName(display, v->label));
       if (atom.string() && strcmp(atom.string(), atom_tp) == 0)
         return v;
     }
   }
 
   return NULL;
 }
-
 }  // namespace
 
 namespace ui {
 
 // static
 TouchFactory* TouchFactory::GetInstance() {
   return Singleton<TouchFactory>::get();
 }
 
 TouchFactory::TouchFactory()
-    : is_cursor_visible_(true),
+    : device_observer_list_(
+        new ObserverListThreadSafe<TouchFactory::DeviceObserver>()),
+      is_cursor_visible_(true),
       cursor_timer_(),
       pointer_device_lookup_(),
       touch_device_available_(false),
       touch_device_list_(),
 #if defined(USE_XI2_MT)
+#if defined(USE_AURA)
+      native_root_window_aura_(ui::GetX11RootWindow()),
+#if defined(USE_UTOUCH)
+      utouch_frame_handle_(NULL),
+#endif  // USE_UTOUCH
+#endif  // USE_AURA
       min_available_slot_(0),
 #endif
       slots_used_() {
 #if defined(USE_AURA)
   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();
+
+#if defined(USE_AURA) && defined(USE_UTOUCH)
+  if (UFStatusSuccess != frame_x11_new(display, &utouch_frame_handle_)) {
+    LOG(ERROR) << "Failed to create utouch frame instance";
+  } else {
+      fd_set set;
+      FD_ZERO(&set);
+      FD_SET(frame_get_fd(utouch_frame_handle_), &set);
+  }
+#endif  // USE_AURA && USE_UTOUCH
+
   Pixmap blank = XCreateBitmapFromData(display, ui::GetX11RootWindow(),
                                        nodata, 8, 8);
   invisible_cursor_ = XCreatePixmapCursor(display, blank, blank,
                                           &black, &black, 0, 0);
   arrow_cursor_ = XCreateFontCursor(display, XC_arrow);
 
-  SetCursorVisible(false, false);
+  // TODO(tvoss): Selectively enable visibility for indirect touch devs.
+  // SetCursorVisible(false, false);
   UpdateDeviceList(display);
 
   // Make sure the list of devices is kept up-to-date by listening for
   // XI_HierarchyChanged event on the root window.
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   memset(mask, 0, sizeof(mask));
 
   XISetMask(mask, XI_HierarchyChanged);
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(display, ui::GetX11RootWindow(), &evmask, 1);
 }
 
 TouchFactory::~TouchFactory() {
+  device_observer_list_->Release();
+  ObserverListThreadSafeTraits<DeviceObserver>::Destruct(
+      device_observer_list_);
+
 #if defined(USE_AURA)
   if (!base::MessagePumpForUI::HasXInput2())
     return;
-#endif
+
+#if defined(USE_UTOUCH)
+  frame_x11_delete(utouch_frame_handle_);
+#endif  // USE_UTOUCH
+#endif  // USE_AURA
 
   // The XDisplay may be lost by the time we get destroyed.
   if (ui::XDisplayExists()) {
     SetCursorVisible(true, false);
     Display* display = ui::GetXDisplay();
     XFreeCursor(display, invisible_cursor_);
     XFreeCursor(display, arrow_cursor_);
   }
 }
 
+void TouchFactory::AddDeviceObserver(TouchFactory::DeviceObserver * observer) {
+  device_observer_list_->AddObserver(observer);
+
+  base::AutoLock al(touch_device_list_lock_);
+  // Make sure that every new observer is provided with an
+  // initial list of devices.
+  device_observer_list_->Notify(
+      &DeviceObserver::OnDevicesUpdated,
+      touch_device_list_);
+}
+
+void TouchFactory::RemoveDeviceObserver(
+    TouchFactory::DeviceObserver * observer) {
+  device_observer_list_->RemoveObserver(observer);
+}
+
 void TouchFactory::UpdateDeviceList(Display* display) {
+  base::AutoLock al(touch_device_list_lock_);

[sadrul, 2012/04/03 19:52:01]

Why?

+
   // 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_available_ = false;
   touch_device_lookup_.reset();
   touch_device_list_.clear();
@@ skipping 23 matching lines @@
   // 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 defined(USE_XI2_MT)
+    MultiTouchDevice mtDevice;
+    if (ui::xi_device_info_to_mt_device(devinfo, mtDevice))
+      touch_device_list_[devinfo->deviceid] = mtDevice;
+
     for (int k = 0; k < devinfo->num_classes; ++k) {
       XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
       if (xiclassinfo->type == XITouchClass) {
         XITouchClassInfo* tci =
             reinterpret_cast<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_[devinfo->deviceid] = true;
-          touch_device_available_ = true;
+        switch (tci->mode) {
+          case XIDirectTouch:
+            touch_device_lookup_[devinfo->deviceid] = true;
+            touch_device_available_ = true;
+            break;
+          case XIDependentTouch:
+            touch_device_lookup_[devinfo->deviceid] = true;
+            touch_device_available_ = true;
+            break;
         }
       }
     }
 #endif
     if (devinfo->use == XIFloatingSlave || devinfo->use == XISlavePointer)
       pointer_device_lookup_[devinfo->deviceid] = true;
   }
   if (devices)
     XIFreeDeviceInfo(devices);
 
   SetupValuator();
+
+  device_observer_list_->Notify(
+      &DeviceObserver::OnDevicesUpdated, touch_device_list_);
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
   DCHECK_EQ(GenericEvent, xev->type);
   XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data);
   XIDeviceEvent* xiev = reinterpret_cast<XIDeviceEvent*>(event);
 
 #if defined(USE_XI2_MT)
+  if (event->evtype == XI_HierarchyChanged)
+      return true;
   if (event->evtype == XI_TouchBegin ||
       event->evtype == XI_TouchUpdate ||
       event->evtype == XI_TouchEnd) {
     return touch_device_lookup_[xiev->sourceid];
   }
 #endif
   if (event->evtype != XI_ButtonPress &&
       event->evtype != XI_ButtonRelease &&
       event->evtype != XI_Motion)
     return true;
 
   return pointer_device_lookup_[xiev->deviceid];
 }
 
+#if defined(USE_UTOUCH)
+void TouchFactory::ProcessXI2Event(XEvent* event) {
+  // Commented out under the assumption that the window host
+  // already loaded all event data.
+  /* XGenericEventCookie *xcookie = &event->xcookie;
+  if(!XGetEventData(ui::GetXDisplay(), xcookie)) {
+    LOG(ERROR) << "Failed to get X generic event data";
+    return;
+  }else
+    printf( "Successfully retrieved X generic event data\n" );
+  */
+  if (UFStatusSuccess !=
+     frame_x11_process_event(utouch_frame_handle_, &event->xcookie)) {
+    LOG(ERROR) << "Failed to inject X event";
+  }
+}
+#endif  // USE_UTOUCH
+
 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_MT)
   XISetMask(mask, XI_TouchBegin);
   XISetMask(mask, XI_TouchUpdate);
   XISetMask(mask, XI_TouchEnd);
-#endif
+  XISetMask(mask, XI_TouchOwnership);
+  XISetMask(mask, XI_HierarchyChanged);
+#else
   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);
+
+#if defined(USE_XI2_MT)
+#if defined(USE_AURA)
+  native_root_window_aura_ = window;
+#endif
+#endif
 }
 
 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_[*iter] = false;
   }
 
   SetupValuator();
 }
 
 bool TouchFactory::IsTouchDevice(unsigned deviceid) const {
   return deviceid < touch_device_lookup_.size() ?
       touch_device_lookup_[deviceid] : false;
 }
 
 bool TouchFactory::IsMultiTouchDevice(unsigned int deviceid) const {
   return (deviceid < touch_device_lookup_.size() &&
           touch_device_lookup_[deviceid]) ?
-          touch_device_list_.find(deviceid)->second :
-          false;
+      touch_device_list_.find(deviceid) != touch_device_list_.end() :
+      false;
 }
 
 #if defined(USE_XI2_MT)
 int TouchFactory::GetSlotForTrackingID(uint32 tracking_id) {
   TrackingIdMap::iterator itr = tracking_id_map_.find(tracking_id);
   if (itr != tracking_id_map_.end())
     return itr->second;
 
   int slot = min_available_slot_;
   if (slot == kMaxTouchPoints) {
@@ skipping 43 matching lines @@
 #endif
 
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   bool success = true;
 
   memset(mask, 0, sizeof(mask));
 #if defined(USE_XI2_MT)
   XISetMask(mask, XI_TouchBegin);
   XISetMask(mask, XI_TouchUpdate);
   XISetMask(mask, XI_TouchEnd);
-#endif
+  XISetMask(mask, XI_TouchOwnership);
+  XISetMask(mask, XI_HierarchyChanged);
+#else
   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::map<int, bool>::const_iterator iter =
+  for (TouchDeviceList::const_iterator iter =
        touch_device_list_.begin();
        iter != touch_device_list_.end(); ++iter) {
     evmask.deviceid = iter->first;
     Status status = XIGrabDevice(display, iter->first, window, CurrentTime,
         None, GrabModeAsync, GrabModeAsync, False, &evmask);
     success = success && status == GrabSuccess;
   }
 
   return success;
 }
 
 bool TouchFactory::UngrabTouchDevices(Display* display) {
 #if defined(USE_AURA)
   if (!base::MessagePumpForUI::HasXInput2())
     return true;
 #endif
 
   bool success = true;
-  for (std::map<int, bool>::const_iterator iter =
+  for (TouchDeviceList::const_iterator iter =
        touch_device_list_.begin();
        iter != touch_device_list_.end(); ++iter) {
     Status status = XIUngrabDevice(display, iter->first, CurrentTime);
     success = success && status == GrabSuccess;
   }
   return success;
 }
 
 void TouchFactory::SetCursorVisible(bool show, bool start_timer) {
   // This function may get called after the display is terminated.
@@ skipping 54 matching lines @@
         touch_param_min_[info->deviceid][j] = valuator->min;
         touch_param_max_[info->deviceid][j] = valuator->max;
       }
     }
 
 #if !defined(USE_XI2_MT)
     // In order to support multi-touch with XI2.0, we need both a slot_id and
     // tracking_id valuator.  Without these we'll treat the device as a
     // single-touch device (like a mouse).
     // TODO(rbyers): Multi-touch is disabled: http://crbug.com/112329
-    //if (valuator_lookup_[info->deviceid][TP_SLOT_ID] == -1 ||
+    // if (valuator_lookup_[info->deviceid][TP_SLOT_ID] == -1 ||
     //    valuator_lookup_[info->deviceid][TP_TRACKING_ID] == -1) {
       DVLOG(1) << "Touch device " << info->deviceid <<
         " does not provide enough information for multi-touch, treating as "
         "a single-touch device.";
       touch_device_list_[info->deviceid] = false;
-    //}
+    // }
 #endif
   }
 
   if (info_list)
     XIFreeDeviceInfo(info_list);
 }
 
 bool TouchFactory::ExtractTouchParam(const XEvent& xev,
                                      TouchParam tp,
                                      float* value) {
@@ skipping 27 matching lines @@
     DCHECK(*value >= 0.0 && *value <= 1.0);
     return true;
   }
   return false;
 }
 
 bool TouchFactory::GetTouchParamRange(unsigned int deviceid,
                                       TouchParam tp,
                                       float* min,
                                       float* max) {
+#if defined(USE_XI2_MT)
+  TouchDeviceList::const_iterator it = touch_device_list_.find(deviceid);
+  if (it == touch_device_list_.end())
+    return false;
+
+  MultiTouchDevice::Axes::const_iterator ita =
+      it->second.axes().find(TouchParamToAxisType(tp));
+
+  if (ita == it->second.axes().end())
+    return false;
+
+  *min = ita->second.min();
+  *max = ita->second.max();
+
+  return true;
+#else
   if (valuator_lookup_[deviceid][tp] >= 0) {
     *min = touch_param_min_[deviceid][tp];
     *max = touch_param_max_[deviceid][tp];
     return true;
   }
   return false;
+#endif
 }
 
 }  // namespace ui