Support longpress drag selection

ui/touch_selection/touch_selection_controller.cc

 // Copyright 2014 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/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     base::TimeDelta tap_timeout,
     float tap_slop,
     bool show_on_tap_for_empty_editable)
     : client_(client),
       tap_timeout_(tap_timeout),
-      tap_slop_(tap_slop),
+      tap_slop_squared_(static_cast<double>(tap_slop) * tap_slop),
       show_on_tap_for_empty_editable_(show_on_tap_for_empty_editable),
       response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
       start_orientation_(TouchHandleOrientation::UNDEFINED),
       end_orientation_(TouchHandleOrientation::UNDEFINED),
       is_insertion_active_(false),
       activate_insertion_automatically_(false),
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false),
+      longpress_drag_selector_(this),
       selection_handle_dragged_(false) {
   DCHECK(client_);
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const SelectionBound& start,
     const SelectionBound& end) {
@@ skipping 13 matching lines @@
 
   // Ensure that |response_pending_input_event_| is cleared after the method
   // completes, while also making its current value available for the duration
   // of the call.
   InputEventType causal_input_event = response_pending_input_event_;
   response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
   base::AutoReset<InputEventType> auto_reset_response_pending_input_event(
       &response_pending_input_event_, causal_input_event);
 
   const bool is_selection_dragging =
-      is_selection_active_ && (start_selection_handle_->is_dragging() ||
-                               end_selection_handle_->is_dragging());
+      is_selection_active_ && (start_selection_handle_->IsActive() ||
+                               end_selection_handle_->IsActive());
 
   // It's possible that the bounds temporarily overlap while a selection handle
   // is being dragged, incorrectly reporting a CENTER orientation.
   // TODO(jdduke): This safeguard is racy, as it's possible the delayed response
   // from handle positioning occurs *after* the handle dragging has ceased.
   // Instead, prevent selection -> insertion transitions without an intervening
   // action or selection clearing of some sort, crbug.com/392696.
   if (is_selection_dragging) {
     if (start_orientation_ == TouchHandleOrientation::CENTER)
       start_orientation_ = start_selection_handle_->orientation();
@@ skipping 12 matching lines @@
   if (start_orientation_ == TouchHandleOrientation::CENTER &&
       selection_editable_) {
     OnInsertionChanged();
     return;
   }
 
   HideAndDisallowShowingAutomatically();
 }
 
 bool TouchSelectionController::WillHandleTouchEvent(const MotionEvent& event) {
+  if (longpress_drag_selector_.WillHandleTouchEvent(event))
+    return true;
+
   if (is_insertion_active_) {
     DCHECK(insertion_handle_);
     return insertion_handle_->WillHandleTouchEvent(event);
   }
 
   if (is_selection_active_) {
     DCHECK(start_selection_handle_);
     DCHECK(end_selection_handle_);
-    if (start_selection_handle_->is_dragging())
+    if (start_selection_handle_->IsActive())
       return start_selection_handle_->WillHandleTouchEvent(event);
 
-    if (end_selection_handle_->is_dragging())
+    if (end_selection_handle_->IsActive())
       return end_selection_handle_->WillHandleTouchEvent(event);
 
     const gfx::PointF event_pos(event.GetX(), event.GetY());
     if ((event_pos - GetStartPosition()).LengthSquared() <=
         (event_pos - GetEndPosition()).LengthSquared())
       return start_selection_handle_->WillHandleTouchEvent(event);
     else
       return end_selection_handle_->WillHandleTouchEvent(event);
   }
 
   return false;
 }
 
-void TouchSelectionController::OnLongPressEvent() {
+void TouchSelectionController::OnLongPressEvent(base::TimeTicks event_time,
+                                                const gfx::PointF& position) {
+  longpress_drag_selector_.OnLongPressEvent(event_time, position);
   response_pending_input_event_ = LONG_PRESS;
   ShowSelectionHandlesAutomatically();
   ShowInsertionHandleAutomatically();
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::AllowShowingFromCurrentSelection() {
   if (is_selection_active_ || is_insertion_active_)
     return;
 
@@ skipping 19 matching lines @@
   DeactivateInsertion();
   DeactivateSelection();
   activate_insertion_automatically_ = false;
   activate_selection_automatically_ = false;
 }
 
 void TouchSelectionController::SetTemporarilyHidden(bool hidden) {
   if (temporarily_hidden_ == hidden)
     return;
   temporarily_hidden_ = hidden;
-
-  TouchHandle::AnimationStyle animation_style = GetAnimationStyle(true);
-  if (is_selection_active_) {
-    start_selection_handle_->SetVisible(GetStartVisible(), animation_style);
-    end_selection_handle_->SetVisible(GetEndVisible(), animation_style);
-  }
-  if (is_insertion_active_)
-    insertion_handle_->SetVisible(GetStartVisible(), animation_style);
+  RefreshHandleVisibility();
 }
 
 void TouchSelectionController::OnSelectionEditable(bool editable) {
   if (selection_editable_ == editable)
     return;
   selection_editable_ = editable;
   ResetCachedValuesIfInactive();
   if (!selection_editable_)
     DeactivateInsertion();
 }
@@ skipping 50 matching lines @@
 }
 
 const gfx::PointF& TouchSelectionController::GetStartPosition() const {
   return start_.edge_bottom();
 }
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
   return end_.edge_bottom();
 }
 
-void TouchSelectionController::OnHandleDragBegin(const TouchHandle& handle) {
-  if (&handle == insertion_handle_.get()) {
+void TouchSelectionController::OnDragBegin(
+    const TouchSelectionDraggable& draggable,
+    const gfx::PointF& drag_position) {
+  if (&draggable == insertion_handle_.get()) {
     client_->OnSelectionEvent(INSERTION_DRAG_STARTED);
+    drag_line_offset_ = GetStartLineOffset();
     return;
   }
 
-  gfx::PointF base, extent;
-  if (&handle == start_selection_handle_.get()) {
-    base = end_selection_handle_->position() + GetEndLineOffset();
-    extent = start_selection_handle_->position() + GetStartLineOffset();
+  DCHECK(is_selection_active_);
+
+  bool extend_selection_start = false;
+  if (&draggable == start_selection_handle_.get()) {
+    extend_selection_start = true;
+  } else if (&draggable == end_selection_handle_.get()) {
+    extend_selection_start = false;
   } else {
-    base = start_selection_handle_->position() + GetStartLineOffset();
-    extent = end_selection_handle_->position() + GetEndLineOffset();
+    DCHECK_EQ(&draggable, &longpress_drag_selector_);
+    extend_selection_start =
+      (drag_position - GetStartPosition()).LengthSquared() <
+      (drag_position - GetEndPosition()).LengthSquared();
   }
+
+  gfx::PointF base = GetStartPosition() + GetStartLineOffset();
+  gfx::PointF extent = GetEndPosition() + GetEndLineOffset();
+  if (extend_selection_start) {
+    std::swap(base, extent);
+    drag_line_offset_ = GetStartLineOffset();
+  } else {
+    drag_line_offset_ = GetEndLineOffset();
+  }
+
   selection_handle_dragged_ = true;
 
   // When moving the handle we want to move only the extent point. Before doing
   // so we must make sure that the base point is set correctly.
   client_->SelectBetweenCoordinates(base, extent);
   client_->OnSelectionEvent(SELECTION_DRAG_STARTED);
 }
 
-void TouchSelectionController::OnHandleDragUpdate(const TouchHandle& handle,
-                                                  const gfx::PointF& position) {
+void TouchSelectionController::OnDragUpdate(
+    const TouchSelectionDraggable& draggable,
+    const gfx::PointF& drag_position) {
   // As the position corresponds to the bottom left point of the selection
   // bound, offset it by half the corresponding line height.
-  gfx::Vector2dF line_offset = &handle == start_selection_handle_.get()
-                                   ? GetStartLineOffset()
-                                   : GetEndLineOffset();
-  gfx::PointF line_position = position + line_offset;
-  if (&handle == insertion_handle_.get()) {
+  gfx::PointF line_position = drag_position + drag_line_offset_;
+  if (&draggable == insertion_handle_.get()) {
     client_->MoveCaret(line_position);
   } else {
     client_->MoveRangeSelectionExtent(line_position);
   }
 }
 
-void TouchSelectionController::OnHandleDragEnd(const TouchHandle& handle) {
-  if (&handle == insertion_handle_.get())
+void TouchSelectionController::OnDragEnd(
+    const TouchSelectionDraggable& draggable) {
+  if (&draggable == insertion_handle_.get())
     client_->OnSelectionEvent(INSERTION_DRAG_STOPPED);
   else
     client_->OnSelectionEvent(SELECTION_DRAG_STOPPED);
 }
 
+bool TouchSelectionController::IsWithinTapSlop(
+    const gfx::Vector2dF& delta) const {
+  return delta.LengthSquared() < tap_slop_squared_;
+}
+
 void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) {
   if (insertion_handle_ && &handle == insertion_handle_.get())
     client_->OnSelectionEvent(INSERTION_TAPPED);
 }
 
 void TouchSelectionController::SetNeedsAnimate() {
   client_->SetNeedsAnimate();
 }
 
 scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() {
   return client_->CreateDrawable();
 }
 
 base::TimeDelta TouchSelectionController::GetTapTimeout() const {
   return tap_timeout_;
 }
 
-float TouchSelectionController::GetTapSlop() const {
-  return tap_slop_;
+void TouchSelectionController::OnLongPressDragActiveStateChanged() {
+  // The handles should remain hidden for the duration of a longpress drag,
+  // including the time between a longpress and the start of drag motion.
+  RefreshHandleVisibility();
+}
+
+gfx::PointF TouchSelectionController::GetSelectionStart() const {
+  return GetStartPosition();
+}
+
+gfx::PointF TouchSelectionController::GetSelectionEnd() const {
+  return GetEndPosition();
 }
 
 void TouchSelectionController::ShowInsertionHandleAutomatically() {
   if (activate_insertion_automatically_)
     return;
   activate_insertion_automatically_ = true;
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::ShowSelectionHandlesAutomatically() {
@@ skipping 92 matching lines @@
   // intervening SELECTION_CLEARED update to avoid unnecessary state changes.
   if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
     if (is_selection_active_) {
       // The active selection session finishes with the start of the new one.
       LogSelectionEnd();
     }
     is_selection_active_ = true;
     selection_handle_dragged_ = false;
     selection_start_time_ = base::TimeTicks::Now();
     response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
+    longpress_drag_selector_.OnSelectionActivated();
     client_->OnSelectionEvent(SELECTION_SHOWN);
   }
 }
 
 void TouchSelectionController::DeactivateSelection() {
   if (!is_selection_active_)
     return;
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
   LogSelectionEnd();
+  longpress_drag_selector_.OnSelectionDeactivated();
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   is_selection_active_ = false;
   client_->OnSelectionEvent(SELECTION_CLEARED);
 }
 
 void TouchSelectionController::ResetCachedValuesIfInactive() {
   if (is_selection_active_ || is_insertion_active_)
     return;
   start_ = SelectionBound();
   end_ = SelectionBound();
   start_orientation_ = TouchHandleOrientation::UNDEFINED;
   end_orientation_ = TouchHandleOrientation::UNDEFINED;
 }
 
+void TouchSelectionController::RefreshHandleVisibility() {
+  TouchHandle::AnimationStyle animation_style = GetAnimationStyle(true);
+  if (is_selection_active_) {
+    start_selection_handle_->SetVisible(GetStartVisible(), animation_style);
+    end_selection_handle_->SetVisible(GetEndVisible(), animation_style);
+  }
+  if (is_insertion_active_)
+    insertion_handle_->SetVisible(GetStartVisible(), animation_style);
+}
+
 gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const {
   return ComputeLineOffsetFromBottom(start_);
 }
 
 gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
   return ComputeLineOffsetFromBottom(end_);
 }
 
 bool TouchSelectionController::GetStartVisible() const {
-  return start_.visible() && !temporarily_hidden_;
+  if (!start_.visible())
+    return false;
+
+  return !temporarily_hidden_ && !longpress_drag_selector_.IsActive();
 }
 
 bool TouchSelectionController::GetEndVisible() const {
-  return end_.visible() && !temporarily_hidden_;
+  if (!end_.visible())
+    return false;
+
+  return !temporarily_hidden_ && !longpress_drag_selector_.IsActive();
 }
 
 TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
     bool was_active) const {
   return was_active && client_->SupportsAnimation()
              ? TouchHandle::ANIMATION_SMOOTH
              : TouchHandle::ANIMATION_NONE;
 }
 
 void TouchSelectionController::LogSelectionEnd() {
   // TODO(mfomitchev): Once we are able to tell the difference between
   // 'successful' and 'unsuccessful' selections - log
   // Event.TouchSelection.Duration instead and get rid of
   // Event.TouchSelectionD.WasDraggeduration.
   if (selection_handle_dragged_) {
     base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchSelection.WasDraggedDuration",
                                duration,
                                base::TimeDelta::FromMilliseconds(500),
                                base::TimeDelta::FromSeconds(60),
                                60);
   }
 }
 
 }  // namespace ui