src/ui/events/gestures/gesture_point.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/events/gestures/gesture_point.h"
   6
   7 #include <cmath>
   8
   9 #include "base/basictypes.h"
  10 #include "ui/events/event.h"
  11 #include "ui/events/event_constants.h"
  12 #include "ui/events/gestures/gesture_configuration.h"
  13 #include "ui/events/gestures/gesture_types.h"
  14
  15 namespace ui {
  16
  17 GesturePoint::GesturePoint()
  18     : first_touch_time_(0.0),
  19       second_last_touch_time_(0.0),
  20       last_touch_time_(0.0),
  21       second_last_tap_time_(0.0),
  22       last_tap_time_(0.0),
  23       velocity_calculator_(
  24           GestureConfiguration::points_buffered_for_velocity()),
  25       point_id_(-1),
  26       touch_id_(-1),
  27       source_device_id_(-1) {
  28   max_touch_move_in_pixels_for_click_squared_ =
  29       GestureConfiguration::max_touch_move_in_pixels_for_click() *
  30       GestureConfiguration::max_touch_move_in_pixels_for_click();
  31   max_distance_between_taps_for_double_tap_squared_ =
  32       GestureConfiguration::max_distance_between_taps_for_double_tap() *
  33       GestureConfiguration::max_distance_between_taps_for_double_tap();
  34 }
  35
  36 GesturePoint::~GesturePoint() {}
  37
  38 void GesturePoint::Reset() {
  39   first_touch_time_ = second_last_touch_time_ = last_touch_time_ = 0.0;
  40   ResetVelocity();
  41   point_id_ = -1;
  42   clear_enclosing_rectangle();
  43   source_device_id_ = -1;
  44 }
  45
  46 void GesturePoint::ResetVelocity() {
  47   velocity_calculator_.ClearHistory();
  48 }
  49
  50 gfx::Vector2dF GesturePoint::ScrollDelta() const {
  51   return last_touch_position_ - second_last_touch_position_;
  52 }
  53
  54 void GesturePoint::UpdateValues(const TouchEvent& event) {
  55   const int64 event_timestamp_microseconds =
  56       event.time_stamp().InMicroseconds();
  57   if (event.type() == ui::ET_TOUCH_MOVED) {
  58     velocity_calculator_.PointSeen(event.location().x(),
  59                                    event.location().y(),
  60                                    event_timestamp_microseconds);
  61     gfx::Vector2d sd(ScrollVelocityDirection(velocity_calculator_.XVelocity()),
  62                      ScrollVelocityDirection(velocity_calculator_.YVelocity()));
  63   }
  64
  65   last_touch_time_ = event.time_stamp().InSecondsF();
  66   last_touch_position_ = event.location_f();
  67
  68   if (event.type() == ui::ET_TOUCH_PRESSED) {
  69     ResetVelocity();
  70     clear_enclosing_rectangle();
  71     first_touch_time_ = last_touch_time_;
  72     first_touch_position_ = event.location();
  73     second_last_touch_position_ = last_touch_position_;
  74     second_last_touch_time_ = last_touch_time_;
  75     velocity_calculator_.PointSeen(event.location().x(),
  76                                    event.location().y(),
  77                                    event_timestamp_microseconds);
  78   }
  79
  80   UpdateEnclosingRectangle(event);
  81 }
  82
  83 void GesturePoint::UpdateForTap() {
  84   // Update the tap-position and time, and reset every other state.
  85   second_last_tap_position_ = last_tap_position_;
  86   second_last_tap_time_ = last_tap_time_;
  87   last_tap_time_ = last_touch_time_;
  88   last_tap_position_ = last_touch_position_;
  89 }
  90
  91 void GesturePoint::UpdateForScroll() {
  92   second_last_touch_position_ = last_touch_position_;
  93   second_last_touch_time_ = last_touch_time_;
  94 }
  95
  96 bool GesturePoint::IsInClickWindow(const TouchEvent& event) const {
  97   return IsInClickTimeWindow() && IsInsideTouchSlopRegion(event);
  98 }
  99
 100 bool GesturePoint::IsInDoubleClickWindow(const TouchEvent& event) const {
 101   return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
 102          IsPointInsideDoubleTapTouchSlopRegion(
 103              event.location(), last_tap_position_);
 104 }
 105
 106 bool GesturePoint::IsInTripleClickWindow(const TouchEvent& event) const {
 107   return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
 108          IsInClickAggregateTimeWindow(second_last_tap_time_, last_tap_time_) &&
 109          IsPointInsideDoubleTapTouchSlopRegion(
 110              event.location(), last_tap_position_) &&
 111          IsPointInsideDoubleTapTouchSlopRegion(last_tap_position_,
 112                                       second_last_tap_position_);
 113 }
 114
 115 bool GesturePoint::IsInScrollWindow(const TouchEvent& event) const {
 116   return event.type() == ui::ET_TOUCH_MOVED &&
 117          !IsInsideTouchSlopRegion(event);
 118 }
 119
 120 bool GesturePoint::IsInFlickWindow(const TouchEvent& event) {
 121   return IsOverMinFlickSpeed() &&
 122          event.type() != ui::ET_TOUCH_CANCELLED;
 123 }
 124
 125 int GesturePoint::ScrollVelocityDirection(float v) {
 126   if (v < -GestureConfiguration::min_scroll_velocity())
 127     return -1;
 128   else if (v > GestureConfiguration::min_scroll_velocity())
 129     return 1;
 130   else
 131     return 0;
 132 }
 133
 134 bool GesturePoint::DidScroll(const TouchEvent& event, int dist) const {
 135   gfx::Vector2dF d = last_touch_position_ - second_last_touch_position_;
 136   return fabs(d.x()) > dist || fabs(d.y()) > dist;
 137 }
 138
 139 bool GesturePoint::IsInHorizontalRailWindow() const {
 140   gfx::Vector2dF d = last_touch_position_ - second_last_touch_position_;
 141   return std::abs(d.x()) >
 142       GestureConfiguration::rail_start_proportion() * std::abs(d.y());
 143 }
 144
 145 bool GesturePoint::IsInVerticalRailWindow() const {
 146   gfx::Vector2dF d = last_touch_position_ - second_last_touch_position_;
 147   return std::abs(d.y()) >
 148       GestureConfiguration::rail_start_proportion() * std::abs(d.x());
 149 }
 150
 151 bool GesturePoint::BreaksHorizontalRail() {
 152   float vx = XVelocity();
 153   float vy = YVelocity();
 154   return fabs(vy) > GestureConfiguration::rail_break_proportion() * fabs(vx) +
 155       GestureConfiguration::min_rail_break_velocity();
 156 }
 157
 158 bool GesturePoint::BreaksVerticalRail() {
 159   float vx = XVelocity();
 160   float vy = YVelocity();
 161   return fabs(vx) > GestureConfiguration::rail_break_proportion() * fabs(vy) +
 162       GestureConfiguration::min_rail_break_velocity();
 163 }
 164
 165 bool GesturePoint::IsInClickTimeWindow() const {
 166   double duration = last_touch_time_ - first_touch_time_;
 167   return duration >=
 168       GestureConfiguration::min_touch_down_duration_in_seconds_for_click() &&
 169       duration <
 170       GestureConfiguration::max_touch_down_duration_in_seconds_for_click();
 171 }
 172
 173 bool GesturePoint::IsInClickAggregateTimeWindow(double before,
 174                                                 double after) const {
 175   double duration =  after - before;
 176   return duration < GestureConfiguration::max_seconds_between_double_click();
 177 }
 178
 179 bool GesturePoint::IsInsideTouchSlopRegion(const TouchEvent& event) const {
 180   const gfx::PointF& p1 = event.location();
 181   const gfx::PointF& p2 = first_touch_position_;
 182   float dx = p1.x() - p2.x();
 183   float dy = p1.y() - p2.y();
 184   float distance = dx * dx + dy * dy;
 185   return distance < max_touch_move_in_pixels_for_click_squared_;
 186 }
 187
 188 bool GesturePoint::IsPointInsideDoubleTapTouchSlopRegion(gfx::PointF p1,
 189                                                          gfx::PointF p2) const {
 190   float dx = p1.x() - p2.x();
 191   float dy = p1.y() - p2.y();
 192   float distance = dx * dx + dy * dy;
 193   return distance < max_distance_between_taps_for_double_tap_squared_;
 194 }
 195
 196 bool GesturePoint::IsOverMinFlickSpeed() {
 197   return velocity_calculator_.VelocitySquared() >
 198       GestureConfiguration::min_flick_speed_squared();
 199 }
 200
 201 void GesturePoint::UpdateEnclosingRectangle(const TouchEvent& event) {
 202   int radius;
 203
 204   // Ignore this TouchEvent if it has a radius larger than the maximum
 205   // allowed radius size.
 206   if (event.radius_x() > GestureConfiguration::max_radius() ||
 207       event.radius_y() > GestureConfiguration::max_radius())
 208     return;
 209
 210   // If the device provides at least one of the radius values, take the larger
 211   // of the two and use this as both the x radius and the y radius of the
 212   // touch region. Otherwise use the default radius value.
 213   // TODO(tdanderson): Implement a more specific check for the exact
 214   // information provided by the device (0-2 radii values, force, angle) and
 215   // use this to compute a more representative rectangular touch region.
 216   if (event.radius_x() || event.radius_y())
 217     radius = std::max(event.radius_x(), event.radius_y());
 218   else
 219     radius = GestureConfiguration::default_radius();
 220
 221   gfx::RectF rect(event.location_f().x() - radius,
 222                   event.location_f().y() - radius,
 223                   radius * 2,
 224                   radius * 2);
 225   if (IsInClickWindow(event))
 226     enclosing_rect_.Union(rect);
 227   else
 228     enclosing_rect_ = rect;
 229 }
 230
 231 }  // namespace ui