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

ui/base/touch/touch_factory.h

 // 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.
 
 #ifndef UI_BASE_TOUCH_TOUCH_FACTORY_H_
 #define UI_BASE_TOUCH_TOUCH_FACTORY_H_
 #pragma once
 
 #include <bitset>
 #include <map>
 #include <vector>
 
+#include "base/hash_tables.h"
 #include "base/memory/singleton.h"
-#include "base/hash_tables.h"
+#include "base/observer_list_threadsafe.h"
+#include "base/synchronization/lock.h"
 #include "base/timer.h"
+#if defined(USE_XI2_MT)
+#if defined(USE_UTOUCH)
+#include "third_party/utouch-frame/include/utouch/frame.h"
+#include "third_party/utouch-frame/include/utouch/frame_x11.h"
+#endif  // USE_UTOUCH
+#include "ui/base/touch/multi_touch_device.h"
+#endif  // USE_XI2_MT
 #include "ui/base/ui_export.h"
 
 typedef unsigned long Cursor;
 typedef unsigned long Window;
 typedef struct _XDisplay Display;
 typedef union _XEvent XEvent;
 
 namespace ui {
 
 // Functions related to determining touch devices.
 class UI_EXPORT TouchFactory {
  public:
+#if !defined(USE_XI2_MT)
+  typedef std::map<int, bool> TouchDeviceList;
+#else
+  typedef std::map<int, MultiTouchDevice> TouchDeviceList;
+#endif
+
+  // Allow components interested in multi-touch hierarch events
+  // to be notified if a device has been added or removed.
+  struct DeviceObserver {
+    virtual ~DeviceObserver() {}
+
+    // Called when the list of known devices changes.
+    virtual void OnDevicesUpdated(TouchDeviceList deviceList) = 0;
+  };
+
   // Define the touch params following the Multi-touch Protocol.
   enum TouchParam {
     TP_TOUCH_MAJOR = 0,   // Length of the touch area.
     TP_TOUCH_MINOR,       // Width of the touch area.
     TP_ORIENTATION,       // Angle between the X-axis and the major axis of the
                           // touch area.
     TP_PRESSURE,          // Pressure of the touch contact.
 
     // NOTE: A touch event can have multiple touch points. So when we receive a
     // touch event, we need to determine which point triggered the event.
@@ skipping 16 matching lines @@
     // is increased for each new touch. It will wrap back to 0 when reaching
     // the numerical limit.
     TP_TRACKING_ID,       // ID of the touch point.
 
     TP_LAST_ENTRY
   };
 
   // Returns the TouchFactory singleton.
   static TouchFactory* GetInstance();
 
+  // Add a new observer.
+  // Can be called from any thread.
+  // Must not be called from within a notification callback.
+  void AddDeviceObserver(DeviceObserver * observer);
+
+  // Remove an existing observer.
+  // Can be called from any thread.
+  // Must not be called from within a notification callback.
+  void RemoveDeviceObserver(DeviceObserver * observer);
+
   // Updates the list of devices.
   void UpdateDeviceList(Display* display);
 
   // Checks whether an XI2 event should be processed or not (i.e. if the event
   // originated from a device we are interested in).
   bool ShouldProcessXI2Event(XEvent* xevent);
 
+#if defined(USE_UTOUCH)
+  // Preprocesses an XI2 event and feeds it to utouch frame.
+  void ProcessXI2Event(XEvent* event);
+#endif  // USE_UTOUCH
+
   // Setup an X Window for XInput2 events.
   void SetupXI2ForXWindow(::Window xid);
 
   // Keeps a list of touch devices so that it is possible to determine if a
   // pointer event is a touch-event or a mouse-event. The list is reset each
   // time this is called.
   void SetTouchDeviceList(const std::vector<unsigned int>& devices);
 
   // Is the device a touch-device?
   bool IsTouchDevice(unsigned int deviceid) const;
 
   // Is the device a real multi-touch-device? (see doc. for |touch_device_list_|
   // below for more explanation.)
   bool IsMultiTouchDevice(unsigned int deviceid) const;
 
 #if defined(USE_XI2_MT)
   // Tries to find an existing slot ID mapping to tracking ID. If there
   // isn't one already, allocates a new slot ID and sets up the mapping.
   int GetSlotForTrackingID(uint32 tracking_id);
 
   // Releases the slot ID mapping to tracking ID.
   void ReleaseSlotForTrackingID(uint32 tracking_id);
-#endif
+
+#if defined(USE_UTOUCH)
+  // Provides raw access to the utouch-frame instance.
+  // TODO(tvoss): Come up with a more secure and clean
+  // pattern to provide access to the frame instance.
+  UFHandle handle() const {
+    return utouch_frame_handle_;
+  }
+#endif  // USE_UTOUCH
+#endif  // USE_XI2_MT
 
   // Is the slot ID currently used?
   bool IsSlotUsed(int slot) const;
 
   // Marks a slot as being used/unused.
   void SetSlotUsed(int slot, bool used);
 
   // Grabs the touch devices for the specified window on the specified display.
   // Returns if grab was successful for all touch devices.
   bool GrabTouchDevices(Display* display, ::Window window);
@@ skipping 39 matching lines @@
     SetCursorVisible(false, false);
   }
 
   // Setup the internal bookkeeping of the touch params valuator information for
   // touch devices
   void SetupValuator();
 
   // Requirement for Signleton
   friend struct DefaultSingletonTraits<TouchFactory>;
 
+  // Observer management
+  ObserverListThreadSafe<DeviceObserver>* device_observer_list_;
+
   // The default cursor is hidden after startup, and when the mouse pointer is
   // idle for a while. Once there is some event from a mouse device, the cursor
   // is immediately displayed.
   bool is_cursor_visible_;
 
   // The cursor is hidden if it is idle for a certain amount time. This timer
   // is used to keep track of the idleness.
   base::OneShotTimer<TouchFactory> cursor_timer_;
 
   // The default cursor.
@@ skipping 18 matching lines @@
   // A quick lookup table for determining if a device is a touch device.
   std::bitset<kMaxDeviceNum> touch_device_lookup_;
 
   // Indicates whether a touch device is currently available or not.
   bool touch_device_available_;
 
   // The list of touch devices. For testing/debugging purposes, a single-pointer
   // device (mouse or touch screen without sufficient X/driver support for MT)
   // can sometimes be treated as a touch device. The key in the map represents
   // the device id, and the value represents if the device is multi-touch
-  // capable.
-  std::map<int, bool> touch_device_list_;
+  // capable. If USE_XI2_MT is defined, the list contains not only boolean
+  // values indicating multi-touch capabilites of the respective device but an
+  // instance of class ui::MultiTouchDevice.
+  TouchDeviceList touch_device_list_;
 
   // Index table to find the valuator for the TouchParam on the specific device
   // by valuator_lookup_[device_id][touch_params]. Use 2-D array to get fast
   // index at the expense of space. If the kMaxDeviceNum grows larger that the
   // space waste becomes a concern, the 2D lookup table can be replaced by a
   // hash map.
   signed char valuator_lookup_[kMaxDeviceNum][TP_LAST_ENTRY];
 
   // Index table to find the min & max value of the TouchParam on a specific
   // device.
   int touch_param_min_[kMaxDeviceNum][TP_LAST_ENTRY];
   int touch_param_max_[kMaxDeviceNum][TP_LAST_ENTRY];
 
   // Maximum simultaneous touch points.
   static const int kMaxTouchPoints = 32;
 
 #if defined(USE_XI2_MT)
+#if defined(USE_UTOUCH)
+  UFHandle utouch_frame_handle_;
+#endif  // USE_UTOUCH
+
   // Stores the minimum available slot ID which helps get slot ID from
   // tracking ID. When it equals to kMaxTouchPoints, there is no available
   // slot.
   int min_available_slot_;
 
   // A hash table to map tracking ID to slot.
   typedef base::hash_map<uint32, int> TrackingIdMap;
   TrackingIdMap tracking_id_map_;
-#endif
+#endif  // USE_XI2_MT
 
   // A lookup table for slots in use for a touch event.
   std::bitset<kMaxTouchPoints> slots_used_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchFactory);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_TOUCH_TOUCH_FACTORY_H_