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 41 matching lines @@
       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, tap_slop),
       selection_handle_dragged_(false) {
   DCHECK(client_);
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const SelectionBound& start,
     const SelectionBound& end) {
@@ skipping 47 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())
       return start_selection_handle_->WillHandleTouchEvent(event);
 
     if (end_selection_handle_->is_dragging())
       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);
+  OnHandleVisibilityOverrideMaybeChanged();
 }
 
 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) {
+  OnHandleVisibilityOverrideMaybeChanged();
+
+  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_);
+
+  gfx::PointF base = GetStartPosition() + GetStartLineOffset();
+  gfx::PointF extent = GetEndPosition() + GetEndLineOffset();
+  if (&draggable == start_selection_handle_.get()) {
+    std::swap(base, extent);
+    drag_line_offset_ = GetStartLineOffset();
+  } else if (&draggable == end_selection_handle_.get()) {
+    drag_line_offset_ = GetEndLineOffset();
   } else {
-    base = start_selection_handle_->position() + GetStartLineOffset();
-    extent = end_selection_handle_->position() + GetEndLineOffset();
+    DCHECK_EQ(&draggable, &longpress_drag_selector_);
+    if ((drag_position - GetStartPosition()).LengthSquared() <

[mfomitchev, 2015/04/23 21:05:53]

Can we just pass an enum in OnDragBegin indicating whether start, end, or insert
markers were dragged instead of passing draggable and position? Then we wouldn't
need extra code for longpress_drag_selector_.

[jdduke (slow), 2015/04/27 20:24:25]

The problem is that the TouchHandle has no awareness of the start/end of a
selection, neither does it know to which it corresponds.

At some point, it might make sense to shift *all* of the responsibility of
determining the handle orientation to the handle itself, i.e., we tell it
whether it's start/end/insertion/, the text orientation (LTR), and the viewport,
and let it decide the best visual representation/orientation. To this end, we
could plumb the RTL bits through instead of the left/right bits (in
RenderWidgetCompositor), propagate those, and it will fit in nicely with
crrev.com/481683003. However, I'd prefer that happen as a separate patch.

The other reason I hesitated adding such was b/c eventually StylusTextSelector
will live here and be a TouchSelectionDraggable, however, its semantics are
quite different in that it triggers a drag selection *before* any selection is
active. However, no need to optimize that case now, so that was only a minor
factor.

[mfomitchev, 2015/04/28 02:17:30]

Yeah, I was implying we'd pass the type to the TouchHandle on creation to
support this. What you say makes sense though.

+        (drag_position - GetEndPosition()).LengthSquared()) {
+      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) {
+  OnHandleVisibilityOverrideMaybeChanged();
+  if (&draggable == insertion_handle_.get())
     client_->OnSelectionEvent(INSERTION_DRAG_STOPPED);
   else
     client_->OnSelectionEvent(SELECTION_DRAG_STOPPED);
 }
 
 void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) {
   if (insertion_handle_ && &handle == insertion_handle_.get())
     client_->OnSelectionEvent(INSERTION_TAPPED);
 }
 
@@ skipping 116 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(GetStartPosition(),
+                                                  GetEndPosition());
     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::OnHandleVisibilityOverrideMaybeChanged() {

[mfomitchev, 2015/04/23 21:05:53]

Can we call this something like UpdateHandleVisibility or
RefreshHandleVisibility? The current name is pretty heavy, and unless I am
missing something, it doesn't seem like it conveys much additional info..

[jdduke (slow), 2015/04/27 20:24:25]

Done.

+  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