Add support for new scroll valuators coming from CMT

ui/base/x/events_x.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 "ui/base/events.h"
 
 #include <X11/Xlib.h>
+#include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <string.h>
 
 #include "base/logging.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/point.h"
 
 #if !defined(TOOLKIT_USES_GTK)
 #include "base/message_pump_x.h"
 #endif
 
+// Copied from xserver-properties.h
+#define AXIS_LABEL_PROP_REL_HWHEEL "Rel Horiz Wheel"
+#define AXIS_LABEL_PROP_REL_WHEEL "Rel Vert Wheel"
+
 namespace {
 
 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
 static const int kWheelScrollAmount = 53;
 
 static const int kMinWheelButton = 4;
 #if defined(OS_CHROMEOS)
 // TODO(davemoore) For now use the button to decide how much to scroll by.
 // When we go to XI2 scroll events this won't be necessary. If this doesn't
 // happen for some reason we can better detect which devices are touchpads.
 static const int kTouchpadScrollAmount = 3;
 // Chrome OS also uses buttons 8 and 9 for scrolling.
 static const int kMaxWheelButton = 9;
 #else
 static const int kMaxWheelButton = 7;
 #endif
 
+// A class to support the detection of scroll events, using X11 valuators.
+class UI_EXPORT ScrollEventData {
+ public:
+  // Returns the ScrollEventData singleton.
+  static ScrollEventData* GetInstance() {
+    return Singleton<ScrollEventData>::get();
+  }
+
+  // Updates the list of devices.
+  void UpdateDeviceList(Display* display) {
+    scroll_devices_.reset();
+    device_to_valuators_.clear();
+
+    int count = 0;
+    XDeviceInfo* dev_list = XListInputDevices(display, &count);
+    Atom xi_touchpad = XInternAtom(display, XI_TOUCHPAD, false);
+    for (int i = 0; i < count; ++i) {
+      XDeviceInfo* dev = dev_list + i;
+      if (dev->type == xi_touchpad)
+        scroll_devices_[dev_list[i].id] = true;
+    }
+    if (dev_list)
+      XFreeDeviceList(dev_list);
+
+    XIDeviceInfo* info_list = XIQueryDevice(display, XIAllDevices, &count);
+    Atom x_axis = XInternAtom(display, AXIS_LABEL_PROP_REL_HWHEEL, false);
+    Atom y_axis = XInternAtom(display, AXIS_LABEL_PROP_REL_WHEEL, false);
+    for (int i = 0; i < count; ++i) {
+      XIDeviceInfo* info = info_list + i;
+
+      if (!scroll_devices_[info->deviceid])
+        continue;
+
+      if (info->use != XISlavePointer && info->use != XIFloatingSlave) {
+        scroll_devices_[info->deviceid] = false;
+        continue;
+      }
+
+      Valuators valuators = {-1, -1};
+      for (int j = 0; j < info->num_classes; ++j) {
+        if (info->classes[j]->type != XIValuatorClass)
+          continue;
+
+        XIValuatorClassInfo* v =
+            reinterpret_cast<XIValuatorClassInfo*>(info->classes[j]);
+        if (v->label == x_axis)
+          valuators.x_scroll = v->number;
+        else if (v->label == y_axis)
+          valuators.y_scroll = v->number;
+      }
+      if (valuators.x_scroll >= 0 && valuators.y_scroll >= 0)
+        device_to_valuators_[info->deviceid] = valuators;
+      else
+        scroll_devices_[info->deviceid] = false;
+    }
+  }
+
+  // Returns true if this is a scroll event (a motion event with the necessary
+  // valuators. Also returns the offsets. |x_offset| and |y_offset| can be
+  // NULL.
+  bool GetScrollOffsets(const XEvent& xev, float* x_offset, float* y_offset) {
+    XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
+
+    if (x_offset)
+      *x_offset = 0;
+    if (y_offset)
+      *y_offset = 0;
+
+    if (!scroll_devices_[xiev->deviceid])
+      return false;
+
+    int x_scroll = device_to_valuators_[xiev->deviceid].x_scroll;
+    int y_scroll = device_to_valuators_[xiev->deviceid].y_scroll;
+
+    bool has_x_offset = XIMaskIsSet(xiev->valuators.mask, x_scroll);
+    bool has_y_offset = XIMaskIsSet(xiev->valuators.mask, y_scroll);
+    bool is_scroll = has_x_offset || has_y_offset;
+
+    if (!x_offset && !y_offset)
+      return is_scroll;
+
+    double* valuators = xiev->valuators.values;
+    for (int i = 0; i < xiev->valuators.mask_len * 8; ++i) {
+      if (XIMaskIsSet(xiev->valuators.mask, i)) {
+        if (x_offset && x_scroll == i)
+          *x_offset = -(*valuators);
+        else if (y_offset && y_scroll == i)
+          *y_offset = -(*valuators);
+        valuators++;
+      }
+    }
+
+    return is_scroll;
+  }
+
+ private:
+  // Requirement for Singleton
+  friend struct DefaultSingletonTraits<ScrollEventData>;
+
+  struct Valuators {
+    int x_scroll;
+    int y_scroll;
+  };
+
+  ScrollEventData() {
+    UpdateDeviceList(ui::GetXDisplay());
+  }
+
+  ~ScrollEventData() {}
+
+  // A quick lookup table for determining if events from the pointer device
+  // should be processed.
+  static const int kMaxDeviceNum = 128;
+  std::bitset<kMaxDeviceNum> scroll_devices_;
+  std::map<int, Valuators> device_to_valuators_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScrollEventData);
+};
+
 int GetEventFlagsFromXState(unsigned int state) {
   int flags = 0;
   if (state & ControlMask)
     flags |= ui::EF_CONTROL_DOWN;
   if (state & ShiftMask)
     flags |= ui::EF_SHIFT_DOWN;
   if (state & Mod1Mask)
     flags |= ui::EF_ALT_DOWN;
   if (state & LockMask)
     flags |= ui::EF_CAPS_LOCK_DOWN;
@@ skipping 137 matching lines @@
       return ET_MOUSE_MOVED;
     case EnterNotify:
       return ET_MOUSE_ENTERED;
     case LeaveNotify:
       return ET_MOUSE_EXITED;
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       if (TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid))
         return GetTouchEventType(native_event);
-      int button = EventButtonFromNative(native_event);
       switch (xievent->evtype) {
         case XI_ButtonPress:
-          if (button >= kMinWheelButton &&
-              button <= kMaxWheelButton)
+        case XI_ButtonRelease: {
+          int button = EventButtonFromNative(native_event);
+          if (button >= kMinWheelButton && button <= kMaxWheelButton)
             return ET_MOUSEWHEEL;
-          return ET_MOUSE_PRESSED;
-        case XI_ButtonRelease:
-          if (button >= kMinWheelButton &&
-              button <= kMaxWheelButton)
-            return ET_MOUSEWHEEL;
-          return ET_MOUSE_RELEASED;
+          return xievent->evtype == XI_ButtonPress ?
+              ET_MOUSE_PRESSED : ET_MOUSE_RELEASED;
+        }
         case XI_Motion:
-          return GetButtonMaskForX2Event(xievent) ?
-              ET_MOUSE_DRAGGED : ET_MOUSE_MOVED;
+          if (GetScrollOffsets(native_event, NULL, NULL))
+            return ET_SCROLL;
+          else if (GetButtonMaskForX2Event(xievent))
+            return ET_MOUSE_DRAGGED;
+          else
+            return ET_MOUSE_MOVED;
       }
     }
     default:
       break;
   }
   return ET_UNKNOWN;
 }
 
 int EventFlagsFromNative(const base::NativeEvent& native_event) {
   switch (native_event->type) {
@@ skipping 178 matching lines @@
                                   0.0);
   unsigned int deviceid =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
   // Force is normalized to fall into [0, 1]
   if (!ui::TouchFactory::GetInstance()->NormalizeTouchParam(
       deviceid, ui::TouchFactory::TP_PRESSURE, &force))
     force = 0.0;
   return force;
 }
 
+bool GetScrollOffsets(const base::NativeEvent& native_event,
+                      float* x_offset,
+                      float* y_offset) {
+  return ScrollEventData::GetInstance()->GetScrollOffsets(
+      *native_event, x_offset, y_offset);
+}
+
+void UpdateDeviceList() {
+  Display* display = GetXDisplay();
+  ScrollEventData::GetInstance()->UpdateDeviceList(display);
+  TouchFactory::GetInstance()->UpdateDeviceList(display);
+}
+
 base::NativeEvent CreateNoopEvent() {
   static XEvent* noop = NULL;
   if (!noop) {
     noop = new XEvent();
     memset(noop, 0, sizeof(XEvent));
     noop->xclient.type = ClientMessage;
     noop->xclient.window = None;
     noop->xclient.format = 8;
     DCHECK(!noop->xclient.display);
   }
   // TODO(oshima): Remove ifdef once gtk is removed from views.
 #if defined(TOOLKIT_USES_GTK)
   NOTREACHED();
 #else
   // Make sure we use atom from current xdisplay, which may
   // change during the test.
   noop->xclient.message_type = XInternAtom(
       base::MessagePumpX::GetDefaultXDisplay(),
       "noop", False);
 #endif
   return noop;
 }
 
 }  // namespace ui