ui: events: Add a class to hold common touch and stylus properties

ui/events/event.h

 // 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.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 304 matching lines @@
                base::TimeDelta time_stamp,
                int flags);
 
   gfx::PointF location_;
 
   // |location_| multiplied by an optional transformation matrix for
   // rotations, animations and skews.
   gfx::PointF root_location_;
 };
 
+// Structure for handling common fields between touch and mouse to support
+// PointerEvents API.
+class EVENTS_EXPORT PointerDetails {
+ public:
+  PointerDetails() {}
+  explicit PointerDetails(EventPointerType pointer_type)
+      : pointer_type_(pointer_type) {}
+  PointerDetails(EventPointerType pointer_type,
+                 float radius_x,
+                 float radius_y,
+                 float force,
+                 float tilt_x,
+                 float tilt_y)
+      : pointer_type_(pointer_type),
+        radius_x_(radius_x),
+        radius_y_(radius_y),
+        force_(force),
+        tilt_x_(tilt_x),
+        tilt_y_(tilt_y) {}
+
+  EventPointerType pointer_type() const { return pointer_type_; };
+
+  // If we aren't provided with a radius on one axis, use the
+  // information from the other axis.
+  float radius_x() const { return radius_x_ > 0 ? radius_x_ : radius_y_; }
+  float radius_y() const { return radius_y_ > 0 ? radius_y_ : radius_x_; }
+  float force() const { return force_; }
+  float tilt_x() const { return tilt_x_; }
+  float tilt_y() const { return tilt_y_; }
+
+  void set_pointer_type(EventPointerType type) { pointer_type_ = type; }
+  void set_radius_x(float r) { radius_x_ = r; }
+  void set_radius_y(float r) { radius_y_ = r; }
+  void set_force(float f) { force_ = f; }
+  void set_tilt_x(float t) { tilt_x_ = t; }
+  void set_tilt_y(float t) { tilt_y_ = t; }
+
+ private:
+  // The type of pointer device.
+  EventPointerType pointer_type_ = EventPointerType::POINTER_TYPE_UNKNOWN;
+
+  // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
+  float radius_x_ = 0.0;
+
+  // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
+  float radius_y_ = 0.0;
+
+  // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
+  float force_ = 0.0;
+
+  // Angle of tilt of the X (major) axis. 0.0 if unknown.
+  float tilt_x_ = 0.0;
+
+  // Angle of tilt of the Y (minor) axis. 0.0 if unknown.
+  float tilt_y_ = 0.0;
+};
+
 class EVENTS_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
   // Create a new MouseEvent based on the provided model.
   // Uses the provided |type| and |flags| for the new event.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   MouseEvent(const MouseEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
-        changed_button_flags_(model.changed_button_flags_) {
-  }
+        changed_button_flags_(model.changed_button_flags_),
+        pointer_details_(model.pointer_details_) {}
 
   template <class T>
   MouseEvent(const MouseEvent& model,
              T* source,
              T* target,
              EventType type,
              int flags)
       : LocatedEvent(model, source, target),
-        changed_button_flags_(model.changed_button_flags_) {
+        changed_button_flags_(model.changed_button_flags_),
+        pointer_details_(model.pointer_details_) {
     SetType(type);
     set_flags(flags);
   }
 
   // Used for synthetic events in testing, gesture recognizer and Ozone
   MouseEvent(EventType type,
              const gfx::PointF& location,
              const gfx::PointF& root_location,
              base::TimeDelta time_stamp,
              int flags,
@@ skipping 43 matching lines @@
   // Identifies the button that changed. During a press this corresponds to the
   // button that was pressed and during a release this corresponds to the button
   // that was released.
   // NOTE: during a press and release flags() contains the complete set of
   // flags. Use this to determine the button that was pressed or released.
   int changed_button_flags() const { return changed_button_flags_; }
 
   // Updates the button that changed.
   void set_changed_button_flags(int flags) { changed_button_flags_ = flags; }
 
+  // Event details common to MouseEvent and TouchEvent.
+  PointerDetails* pointer_details() { return &pointer_details_; }
+
  private:
   FRIEND_TEST_ALL_PREFIXES(EventTest, DoubleClickRequiresRelease);
   FRIEND_TEST_ALL_PREFIXES(EventTest, SingleClickRightLeft);
 
   // Returns the flags for the mouse buttons.
   int button_flags() const {
     return flags() & (EF_LEFT_MOUSE_BUTTON | EF_MIDDLE_MOUSE_BUTTON |
                       EF_RIGHT_MOUSE_BUTTON | EF_BACK_MOUSE_BUTTON |
                       EF_FORWARD_MOUSE_BUTTON);
   }
 
   // Returns the repeat count based on the previous mouse click, if it is
   // recent enough and within a small enough distance.
   static int GetRepeatCount(const MouseEvent& click_event);
 
   // Resets the last_click_event_ for unit tests.
   static void ResetLastClickForTest();
 
   // See description above getter for details.
   int changed_button_flags_;
 
   static MouseEvent* last_click_event_;
 
   // We can create a MouseEvent for a native event more than once. We set this
   // to true when the next event either has a different timestamp or we see a
   // release signalling that the press (click) event was completed.
   static bool last_click_complete_;
+
+  // Structure for holding pointer details for implementing PointerEvents API.
+  PointerDetails pointer_details_;
 };
 
 class ScrollEvent;
 
 class EVENTS_EXPORT MouseWheelEvent : public MouseEvent {
  public:
   // See |offset| for details.
   static const int kWheelDelta;
 
   explicit MouseWheelEvent(const base::NativeEvent& native_event);
@@ skipping 32 matching lines @@
   explicit TouchEvent(const base::NativeEvent& native_event);
 
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
         touch_id_(model.touch_id_),
         unique_event_id_(model.unique_event_id_),
-        radius_x_(model.radius_x_),
-        radius_y_(model.radius_y_),
         rotation_angle_(model.rotation_angle_),
-        force_(model.force_),
         may_cause_scrolling_(model.may_cause_scrolling_),
-        should_remove_native_touch_id_mapping_(false) {}
+        should_remove_native_touch_id_mapping_(false),
+        pointer_details_(model.pointer_details_) {}
 
   TouchEvent(EventType type,
              const gfx::PointF& location,
              int touch_id,
              base::TimeDelta time_stamp);
 
   TouchEvent(EventType type,
              const gfx::PointF& location,
              int flags,
              int touch_id,
              base::TimeDelta timestamp,
              float radius_x,
              float radius_y,
              float angle,
              float force);
 
   TouchEvent(const TouchEvent& copy);
 
   ~TouchEvent() override;
 
   // The id of the pointer this event modifies.
   int touch_id() const { return touch_id_; }
   // A unique identifier for this event.
   uint32 unique_event_id() const { return unique_event_id_; }
-  // If we aren't provided with a radius on one axis, use the
-  // information from the other axis.
-  float radius_x() const { return radius_x_ > 0 ? radius_x_ : radius_y_; }
-  float radius_y() const { return radius_y_ > 0 ? radius_y_ : radius_x_; }
+
+  // TODO(robert.bradford): Drop these shims.
+  float radius_x() const { return pointer_details_.radius_x(); }
+  float radius_y() const { return pointer_details_.radius_y(); }
+  float force() const { return pointer_details_.force(); }
+
   float rotation_angle() const { return rotation_angle_; }
-  float force() const { return force_; }
 
   void set_may_cause_scrolling(bool causes) { may_cause_scrolling_ = causes; }
   bool may_cause_scrolling() const { return may_cause_scrolling_; }
 
-  // Used for unit tests.
-  void set_radius_x(const float r) { radius_x_ = r; }
-  void set_radius_y(const float r) { radius_y_ = r; }
+  // TODO(robert.bradford): ozone_platform_egltest.cc could use
+  // UpdateForRootTransform() instead: crbug.com/519337
+  void set_radius_x(const float r) { pointer_details()->set_radius_x(r); }
+  void set_radius_y(const float r) { pointer_details()->set_radius_y(r); }
 
   void set_should_remove_native_touch_id_mapping(
       bool should_remove_native_touch_id_mapping) {
     should_remove_native_touch_id_mapping_ =
         should_remove_native_touch_id_mapping;
   }
 
   // Overridden from LocatedEvent.
   void UpdateForRootTransform(
       const gfx::Transform& inverted_root_transform) override;
 
   // Marks the event as not participating in synchronous gesture recognition.
   void DisableSynchronousHandling();
   bool synchronous_handling_disabled() const {
     return !!(result() & ER_DISABLE_SYNC_HANDLING);
   }
 
+  // Event details common to MouseEvent and TouchEvent.
+  PointerDetails* pointer_details() { return &pointer_details_; }

[sadrul, 2015/08/17 14:44:43]

Can this return a const& instead?

The callers should go through the MouseEvent/TouchEvent to mutate it (e.g.
MouseEvent::set_pointer_type(...) and so on)

+
  private:
   // Adjusts rotation_angle_ to within the acceptable range.
   void FixRotationAngle();
 
   // The identity (typically finger) of the touch starting at 0 and incrementing
   // for each separable additional touch that the hardware can detect.
   const int touch_id_;
 
   // A unique identifier for the touch event.
   const uint32 unique_event_id_;
 
-  // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
-  float radius_x_;
-
-  // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
-  float radius_y_;
-
   // Clockwise angle (in degrees) of the major axis from the X axis. Must be
   // less than 180 and non-negative.
   float rotation_angle_;
 
-  // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
-  float force_;
-
   // Whether the (unhandled) touch event will produce a scroll event (e.g., a
   // touchmove that exceeds the platform slop region, or a touchend that
   // causes a fling). Defaults to false.
   bool may_cause_scrolling_;
 
   // True if this event should remove the mapping between the native
   // event id and the touch_id_. This should only be the case for
   // release and cancel events where the associated touch press event
   // created a mapping between the native id and the touch_id_.
   bool should_remove_native_touch_id_mapping_;
+
+  // Structure for holding pointer details for implementing PointerEvents API.
+  PointerDetails pointer_details_;
 };
 
 // An interface that individual platforms can use to store additional data on
 // KeyEvent.
 //
 // Currently only used in mojo.
 class EVENTS_EXPORT ExtendedKeyEventData {
  public:
   virtual ~ExtendedKeyEventData() {}
 
@@ skipping 278 matching lines @@
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_