gesture recognizer: Recognizer rotation gestures.

ui/base/gestures/gesture_sequence.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/gestures/gesture_sequence.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 246 matching lines @@
   return signature;
 }
 #undef G
 
 float BoundingBoxDiagonal(const gfx::Rect& rect) {
   float width = rect.width() * rect.width();
   float height = rect.height() * rect.height();
   return sqrt(width + height);
 }
 
+float BoundingBoxDiagonalAngle(const gfx::Rect& rect) {
+  float width = rect.width();
+  float height = rect.height();
+  return width == 0.f ? M_PI_2 : atan(height / width);
+}
+
 unsigned int ComputeTouchBitmask(const GesturePoint* points) {
   unsigned int touch_bitmask = 0;
   for (int i = 0; i < GestureSequence::kMaxGesturePoints; ++i) {
     if (points[i].in_use())
       touch_bitmask |= 1 << points[i].touch_id();
   }
   return touch_bitmask;
 }
 
 float CalibrateFlingVelocity(float velocity) {
   // TODO(sad|rjkroege): fling-curve is currently configured to work well with
   // touchpad scroll-events. This curve needs to be adjusted to work correctly
   // with both touchpad and touchscreen. Until then, scale quadratically.
   // http://crbug.com/120154
   const float velocity_scaling  =
       GestureConfiguration::touchscreen_fling_acceleration_adjustment();
   return velocity_scaling * velocity;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Public:
 
 GestureSequence::GestureSequence(GestureEventHelper* helper)
     : state_(GS_NO_GESTURE),
       flags_(0),
+      bounding_box_diagonal_angle_(0.f),
       pinch_distance_start_(0.f),
       pinch_distance_current_(0.f),
       scroll_type_(ST_FREE),
       long_press_timer_(CreateTimer()),
       point_count_(0),
       helper_(helper) {
 }
 
 GestureSequence::~GestureSequence() {
 }
@@ skipping 163 matching lines @@
         // pinch_distance_current_ and pinch_distance_start_ will be updated
         // when the bounding-box is updated.
       }
       ResetVelocities();
       break;
     case GST_PINCH_THIRD_PRESSED:
     case GST_PINCH_FOURTH_PRESSED:
     case GST_PINCH_FIFTH_PRESSED:
       pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
       pinch_distance_start_ = pinch_distance_current_;
+      bounding_box_diagonal_angle_ = BoundingBoxDiagonalAngle(bounding_box_);
       break;
   }
 
   if (event.type() == ui::ET_TOUCH_RELEASED ||
       event.type() == ui::ET_TOUCH_CANCELLED)
     AppendEndGestureEvent(point, gestures.get());
 
   if (state_ != last_state)
     DVLOG(4) << "Gesture Sequence"
              << " State: " << state_
@@ skipping 14 matching lines @@
         iter_point.set_point_id(iter_point.point_id() - 1);
     }
 
     point.Reset();
     --point_count_;
     CHECK_GE(point_count_, 0);
     RecreateBoundingBox();
     if (state_ == GS_PINCH) {
       pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
       pinch_distance_start_ = pinch_distance_current_;
+      bounding_box_diagonal_angle_ = BoundingBoxDiagonalAngle(bounding_box_);
     }
   }
   return gestures.release();
 }
 
 void GestureSequence::RecreateBoundingBox() {
   // TODO(sad): Recreating the bounding box at every touch-event is not very
   // efficient. This should be made better.
   int left = INT_MAX, top = INT_MAX, right = INT_MIN, bottom = INT_MIN;
   for (int i = 0; i < kMaxGesturePoints; ++i) {
@@ skipping 224 matching lines @@
   gestures->push_back(CreateGestureEvent(
       GestureEventDetails(ui::ET_GESTURE_PINCH_END, 0, 0),
       center,
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
       1 << p1.touch_id() | 1 << p2.touch_id()));
 }
 
 void GestureSequence::AppendPinchGestureUpdate(const GesturePoint& point,
                                                float scale,
+                                               float rotation,
                                                Gestures* gestures) {
   // TODO(sad): Compute rotation and include it in delta_y.
   // http://crbug.com/113145
   gestures->push_back(CreateGestureEvent(
-      GestureEventDetails(ui::ET_GESTURE_PINCH_UPDATE, scale, 0),
+      GestureEventDetails(ui::ET_GESTURE_PINCH_UPDATE, scale, rotation),
       bounding_box_.CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
       ComputeTouchBitmask(points_)));
 }
 
 void GestureSequence::AppendSwipeGesture(const GesturePoint& point,
                                          int swipe_x,
                                          int swipe_y,
                                          Gestures* gestures) {
@@ skipping 155 matching lines @@
          state_ == GS_PENDING_TWO_FINGER_TAP);
 
   // Once pinch starts, we immediately break rail scroll.
   scroll_type_ = ST_FREE;
 
   const GesturePoint* point1 = GetPointByPointId(0);
   const GesturePoint* point2 = GetPointByPointId(1);
 
   pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
   pinch_distance_start_ = pinch_distance_current_;
+  bounding_box_diagonal_angle_ = BoundingBoxDiagonalAngle(bounding_box_);
+
   AppendPinchGestureBegin(*point1, *point2, gestures);
 
   if (state_ == GS_PENDING_SYNTHETIC_CLICK ||
       state_ == GS_PENDING_TWO_FINGER_TAP) {
     gfx::Point center = bounding_box_.CenterPoint();
     AppendScrollGestureBegin(point, center, gestures);
   }
 
   return true;
 }
@@ skipping 16 matching lines @@
     break;
   }
 
   if (!did_scroll)
     return false;
 
   float distance = BoundingBoxDiagonal(bounding_box_);
 
   if (abs(distance - pinch_distance_current_) >=
       GestureConfiguration::min_pinch_update_distance_in_pixels()) {
-    AppendPinchGestureUpdate(point,
-        distance / pinch_distance_current_, gestures);
+    float scale = distance / pinch_distance_current_;
+    float angle = bounding_box_diagonal_angle_;
+    // Compute rotation only if the the bounding box remained of roughly the
+    // same size.
+    if (fabs(1.f - scale) < 0.15f)
+      angle = BoundingBoxDiagonalAngle(bounding_box_);
+    else
+      LOG(ERROR) << "Scale: " << scale;
+    AppendPinchGestureUpdate(point, scale, angle - bounding_box_diagonal_angle_,
+        gestures);
     pinch_distance_current_ = distance;
+    bounding_box_diagonal_angle_ = angle;
   } else {
     gfx::Point center = bounding_box_.CenterPoint();
     AppendScrollGestureUpdate(point, center, gestures);
   }
 
   return true;
 }
 
 bool GestureSequence::PinchEnd(const TouchEvent& event,
                                const GesturePoint& point,
@@ skipping 85 matching lines @@
     return;
 
   // Since long press timer has been started, there should be a non-NULL point.
   const GesturePoint* point = GetPointByPointId(0);
   if (!ui::gestures::IsInsideManhattanSquare(point->first_touch_position(),
       event.location()))
     long_press_timer_->Stop();
 }
 
 }  // namespace ui