Add support for ordinal scroll amounts

ui/base/x/events_x.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/events/event_constants.h"
 
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
@@ skipping 18 matching lines @@
 #include "ui/gfx/screen.h"
 
 // Copied from xserver-properties.h
 #define AXIS_LABEL_PROP_REL_HWHEEL "Rel Horiz Wheel"
 #define AXIS_LABEL_PROP_REL_WHEEL "Rel Vert Wheel"
 
 // CMT specific timings
 #define AXIS_LABEL_PROP_ABS_START_TIME "Abs Start Timestamp"
 #define AXIS_LABEL_PROP_ABS_END_TIME "Abs End Timestamp"
 
+// Ordinal values
+#define AXIS_LABEL_PROP_ABS_DBL_ORDINAL_X   "Abs Dbl Ordinal X"
+#define AXIS_LABEL_PROP_ABS_DBL_ORDINAL_Y   "Abs Dbl Ordinal Y"
+
 // Fling properties
 #define AXIS_LABEL_PROP_ABS_FLING_X       "Abs Fling X Velocity"
 #define AXIS_LABEL_PROP_ABS_FLING_Y       "Abs Fling Y Velocity"
 #define AXIS_LABEL_PROP_ABS_FLING_STATE   "Abs Fling State"
 
 #define AXIS_LABEL_PROP_ABS_FINGER_COUNT   "Abs Finger Count"
 
 // New versions of the valuators, with double values instead of fixed point.
 #define AXIS_LABEL_PROP_ABS_DBL_START_TIME "Abs Dbl Start Timestamp"
 #define AXIS_LABEL_PROP_ABS_DBL_END_TIME   "Abs Dbl End Timestamp"
 #define AXIS_LABEL_PROP_ABS_DBL_FLING_VX   "Abs Dbl Fling X Velocity"
 #define AXIS_LABEL_PROP_ABS_DBL_FLING_VY   "Abs Dbl Fling Y Velocity"
 
 namespace {
 
 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
 const int kWheelScrollAmount = 53;
 
 const int kMinWheelButton = 4;
 const int kMaxWheelButton = 7;
 
 const char* kCMTCachedAtoms[] = {
+  AXIS_LABEL_PROP_ABS_DBL_ORDINAL_X,
+  AXIS_LABEL_PROP_ABS_DBL_ORDINAL_Y,
   AXIS_LABEL_PROP_REL_HWHEEL,
   AXIS_LABEL_PROP_REL_WHEEL,
   AXIS_LABEL_PROP_ABS_START_TIME,
   AXIS_LABEL_PROP_ABS_DBL_START_TIME,
   AXIS_LABEL_PROP_ABS_END_TIME,
   AXIS_LABEL_PROP_ABS_DBL_END_TIME,
   AXIS_LABEL_PROP_ABS_FLING_X,
   AXIS_LABEL_PROP_ABS_FLING_Y,
   AXIS_LABEL_PROP_ABS_DBL_FLING_VX,
   AXIS_LABEL_PROP_ABS_DBL_FLING_VY,
@@ skipping 33 matching lines @@
         ui::DeviceListCacheX::GetInstance()->GetXDeviceList(display);
     Atom xi_touchpad = XInternAtom(display, XI_TOUCHPAD, false);
     for (int i = 0; i < dev_list.count; ++i)
       if (dev_list[i].type == xi_touchpad)
         touchpads_[dev_list[i].id] = true;
 
     XIDeviceList info_list =
         ui::DeviceListCacheX::GetInstance()->GetXI2DeviceList(display);
     Atom x_axis = atom_cache_.GetAtom(AXIS_LABEL_PROP_REL_HWHEEL);
     Atom y_axis = atom_cache_.GetAtom(AXIS_LABEL_PROP_REL_WHEEL);
+    Atom x_ordinal = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_ORDINAL_X);
+    Atom y_ordinal = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_ORDINAL_Y);
     Atom start_time = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_START_TIME);
     Atom start_time_dbl =
         atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_START_TIME);
     Atom end_time = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_END_TIME);
     Atom end_time_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_END_TIME);
     Atom fling_vx = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_X);
     Atom fling_vx_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_FLING_VX);
     Atom fling_vy = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_Y);
     Atom fling_vy_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_FLING_VY);
     Atom fling_state = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_STATE);
@@ skipping 19 matching lines @@
             reinterpret_cast<XIValuatorClassInfo*>(info->classes[j]);
         int number = v->number;
         if (number > valuators.max)
           valuators.max = number;
         if (v->label == x_axis) {
           valuators.scroll_x = number;
           is_cmt = true;
         } else if (v->label == y_axis) {
           valuators.scroll_y = number;
           is_cmt = true;
+        } else if (v->label == x_ordinal) {
+          valuators.ordinal_x = number;
+          is_cmt = true;
+        } else if (v->label == y_ordinal) {
+          valuators.ordinal_y = number;
+          is_cmt = true;
         } else if (v->label == finger_count) {
           valuators.finger_count = number;
           is_cmt = true;
         } else if (v->label == start_time) {
           valuators.start_time = number;
           is_cmt = true;
         } else if (v->label == start_time_dbl) {
           valuators.start_time_dbl = number;
           is_cmt = true;
         } else if (v->label == end_time) {
@@ skipping 57 matching lines @@
 
     return natural_scroll_enabled_ ? 1.0f : -1.0f;
   }
 
   // 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,
+                        float* x_offset_ordinal,
+                        float* y_offset_ordinal,
                         int* finger_count) {
     XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
 
     if (x_offset)
       *x_offset = 0;
     if (y_offset)
       *y_offset = 0;
-    if (finger_count)
+    if (x_offset_ordinal)
+      *x_offset_ordinal = 0;
+    if (y_offset_ordinal)
+      *y_offset_ordinal = 0;
+   if (finger_count)
       *finger_count = 2;
 
     const int sourceid = xiev->sourceid;
     if (!cmt_devices_[sourceid])
       return false;
 
     const float natural_scroll_factor = GetNaturalScrollFactor(sourceid);
     const Valuators v = device_to_valuators_[sourceid];
     const bool has_x_offset = XIMaskIsSet(xiev->valuators.mask, v.scroll_x);
     const bool has_y_offset = XIMaskIsSet(xiev->valuators.mask, v.scroll_y);
     const bool is_scroll = has_x_offset || has_y_offset;
 
     if (!is_scroll || (!x_offset && !y_offset))
       return is_scroll;
 
     double* valuators = xiev->valuators.values;
     for (int i = 0; i <= v.max; ++i) {
       if (XIMaskIsSet(xiev->valuators.mask, i)) {
         if (x_offset && v.scroll_x == i)
           *x_offset = *valuators * natural_scroll_factor;
         else if (y_offset && v.scroll_y == i)
           *y_offset = *valuators * natural_scroll_factor;
+        else if (x_offset_ordinal && v.ordinal_x == i)
+          *x_offset_ordinal = *valuators * natural_scroll_factor;
+        else if (y_offset_ordinal && v.ordinal_y == i)
+          *y_offset_ordinal = *valuators * natural_scroll_factor;
         else if (finger_count && v.finger_count == i)
           *finger_count = static_cast<int>(*valuators);
         valuators++;
       }
     }
 
     return true;
   }
 
   bool GetFlingData(const XEvent& xev,
                     float* vx, float* vy,
+                    float* vx_ordinal, float* vy_ordinal,
                     bool* is_cancel) {
     XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
 
-    *vx = 0;
-    *vy = 0;
-    *is_cancel = false;
+    if (vx)
+      *vx = 0;
+    if (vy)
+      *vy = 0;
+    if (vx_ordinal)
+      *vx_ordinal = 0;
+    if (vy_ordinal)
+      *vy_ordinal = 0;
+    if (is_cancel)
+      *is_cancel = false;
 
     const int sourceid = xiev->sourceid;
     if (!cmt_devices_[sourceid])
       return false;
 
     const float natural_scroll_factor = GetNaturalScrollFactor(sourceid);
     const Valuators v = device_to_valuators_[sourceid];
     if ((!XIMaskIsSet(xiev->valuators.mask, v.fling_vx) &&
             !XIMaskIsSet(xiev->valuators.mask, v.fling_vx_dbl)) ||
         (!XIMaskIsSet(xiev->valuators.mask, v.fling_vy) &&
             !XIMaskIsSet(xiev->valuators.mask, v.fling_vy_dbl)) ||
         !XIMaskIsSet(xiev->valuators.mask, v.fling_state))
       return false;
 
     double* valuators = xiev->valuators.values;
     for (int i = 0; i <= v.max; ++i) {
       if (XIMaskIsSet(xiev->valuators.mask, i)) {
         // Convert values to unsigned ints representing ms before storing them,
         // as that is how they were encoded before conversion to doubles.
-        if (v.fling_vx_dbl == i) {
+        if (vx && v.fling_vx_dbl == i) {
           *vx = natural_scroll_factor * *valuators;
-        } else if (v.fling_vx == i) {
+        } else if (vx && v.fling_vx == i) {
           *vx = natural_scroll_factor *
               static_cast<double>(static_cast<int>(*valuators)) / 1000.0f;
-        } else if (v.fling_vy_dbl == i) {
+        } else if (vy && v.fling_vy_dbl == i) {
           *vy = natural_scroll_factor * *valuators;
-        } else if (v.fling_vy == i) {
+        } else if (vy && v.fling_vy == i) {
           *vy = natural_scroll_factor *
               static_cast<double>(static_cast<int>(*valuators)) / 1000.0f;
-        } else if (v.fling_state == i) {
+        } else if (is_cancel && v.fling_state == i) {
           *is_cancel = !!static_cast<unsigned int>(*valuators);
+        } else if (vx_ordinal && v.ordinal_x == i) {
+          *vx_ordinal = *valuators * natural_scroll_factor;
+        } else if (vy_ordinal && v.ordinal_y == i) {
+          *vy_ordinal = *valuators * natural_scroll_factor;
         }
         valuators++;
       }
     }
 
     return true;
   }
 
   bool GetGestureTimes(const XEvent& xev,
                        double* start_time,
@@ skipping 42 matching lines @@
   }
 
  private:
   // Requirement for Singleton
   friend struct DefaultSingletonTraits<CMTEventData>;
 
   struct Valuators {
     int max;
     int scroll_x;
     int scroll_y;
+    int ordinal_x;
+    int ordinal_y;
     int finger_count;
     int start_time;
     int end_time;
     int fling_vx;
     int fling_vy;
     int fling_state;
     // *_dbl valuators take precedence over the fixed precision versions.
     int start_time_dbl;
     int end_time_dbl;
     int fling_vx_dbl;
     int fling_vy_dbl;
 
     Valuators()
         : max(-1),
           scroll_x(-1),
           scroll_y(-1),
+          ordinal_x(-1),
+          ordinal_y(-1),
           finger_count(-1),
           start_time(-1),
           end_time(-1),
           fling_vx(-1),
           fling_vy(-1),
           fling_state(-1),
           start_time_dbl(-1),
           end_time_dbl(-1),
           fling_vx_dbl(-1),
           fling_vy_dbl(-1) {
@@ skipping 387 matching lines @@
           return ET_MOUSE_PRESSED;
         }
         case XI_ButtonRelease: {
           int button = EventButtonFromNative(native_event);
           // Drop wheel events; we should've already scrolled on the press.
           if (button >= kMinWheelButton && button <= kMaxWheelButton)
             return ET_UNKNOWN;
           return ET_MOUSE_RELEASED;
         }
         case XI_Motion: {
-          float vx, vy;
           bool is_cancel;
-          if (GetFlingData(native_event, &vx, &vy, &is_cancel)) {
+          if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel)) {
             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
-          } else if (GetScrollOffsets(native_event, NULL, NULL, NULL)) {
+          } else if (GetScrollOffsets(
+              native_event, NULL, NULL, NULL, NULL, NULL)) {
             return ET_SCROLL;
           } else if (GetButtonMaskForX2Event(xievent)) {
             return ET_MOUSE_DRAGGED;
           } else {
             return ET_MOUSE_MOVED;
           }
         }
       }
     }
     default:
@@ skipping 297 matching lines @@
   // Force is normalized to fall into [0, 1]
   if (!ui::ValuatorTracker::GetInstance()->NormalizeValuator(
       deviceid, ui::ValuatorTracker::VAL_PRESSURE, &force))
     force = 0.0;
   return force;
 }
 
 bool GetScrollOffsets(const base::NativeEvent& native_event,
                       float* x_offset,
                       float* y_offset,
+                      float* x_offset_ordinal,
+                      float* y_offset_ordinal,
                       int* finger_count) {
   return CMTEventData::GetInstance()->GetScrollOffsets(
-      *native_event, x_offset, y_offset, finger_count);
+      *native_event,
+      x_offset, y_offset,
+      x_offset_ordinal, y_offset_ordinal,
+      finger_count);
 }
 
 bool GetFlingData(const base::NativeEvent& native_event,
                   float* vx,
                   float* vy,
+                  float* vx_ordinal,
+                  float* vy_ordinal,
                   bool* is_cancel) {
   return CMTEventData::GetInstance()->GetFlingData(
-      *native_event, vx, vy, is_cancel);
+      *native_event, vx, vy, vx_ordinal, vy_ordinal, is_cancel);
 }
 
 bool GetGestureTimes(const base::NativeEvent& native_event,
                      double* start_time,
                      double* end_time) {
   return CMTEventData::GetInstance()->GetGestureTimes(
       *native_event, start_time, end_time);
 }
 
 void SetNaturalScroll(bool enabled) {
@@ skipping 23 matching lines @@
     noop->xclient.format = 8;
     DCHECK(!noop->xclient.display);
   }
   // Make sure we use atom from current xdisplay, which may
   // change during the test.
   noop->xclient.message_type = GetNoopEventAtom();
   return noop;
 }
 
 }  // namespace ui