Support longpress drag selection

ui/touch_selection/touch_selection_controller.h

 // 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.
 
 #ifndef UI_TOUCH_SELECTION_TOUCH_SELECTION_CONTROLLER_H_
 #define UI_TOUCH_SELECTION_TOUCH_SELECTION_CONTROLLER_H_
 
 #include "ui/base/touch/selection_bound.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/vector2d_f.h"
 #include "ui/touch_selection/selection_event_type.h"
 #include "ui/touch_selection/touch_handle.h"
 #include "ui/touch_selection/touch_handle_orientation.h"
 #include "ui/touch_selection/ui_touch_selection_export.h"
 
 namespace ui {
 class MotionEvent;
 
 // Interface through which |TouchSelectionController| issues selection-related
 // commands, notifications and requests.
@@ skipping 31 matching lines @@
   // Returns true iff the event was consumed, in which case the caller should
   // cease further handling of the event.
   bool WillHandleTouchEvent(const MotionEvent& event);
 
   // To be called before forwarding a tap event. This allows automatically
   // showing the insertion handle from subsequent bounds changes.
   void OnTapEvent();
 
   // To be called before forwarding a longpress event. This allows automatically
   // showing the selection or insertion handles from subsequent bounds changes.
-  void OnLongPressEvent();
+  void OnLongPressEvent(const gfx::PointF& location);
 
   // Allow showing the selection handles from the most recent selection bounds
   // update (if valid), or a future valid bounds update.
   void AllowShowingFromCurrentSelection();
 
   // Hide the handles and suppress bounds updates until the next explicit
   // showing allowance.
   void HideAndDisallowShowingAutomatically();
 
   // Override the handle visibility according to |hidden|.
@@ skipping 43 matching lines @@
 
   void OnInsertionChanged();
   void OnSelectionChanged();
 
   void ActivateInsertion();
   void DeactivateInsertion();
   void ActivateSelection();
   void DeactivateSelection();
   void ResetCachedValuesIfInactive();
 
+  bool WillHandleTouchEventForLongPressDrag(const MotionEvent& event);
+  void SetTemporarilyHiddenForLongPressDrag(bool hidden);
+  void OnHandleVisibilityOverrideChanged();
+
   gfx::Vector2dF GetStartLineOffset() const;
   gfx::Vector2dF GetEndLineOffset() const;
   bool GetStartVisible() const;
   bool GetEndVisible() const;
   TouchHandle::AnimationStyle GetAnimationStyle(bool was_active) const;
 
   void LogSelectionEnd();
 
   TouchSelectionControllerClient* const client_;
   const base::TimeDelta tap_timeout_;
@@ skipping 17 matching lines @@
   scoped_ptr<TouchHandle> start_selection_handle_;
   scoped_ptr<TouchHandle> end_selection_handle_;
   bool is_selection_active_;
   bool activate_selection_automatically_;
 
   bool selection_empty_;
   bool selection_editable_;
 
   bool temporarily_hidden_;
 
+  // Longpress drag allows direct manipulation of longpress-initiated selection.
+  // TODO(jdduke): Factor out longpress drag-specific logic into a more isolated

[mfomitchev, 2015/04/18 16:09:08]

I wonder if we can reuse some of the TouchHandle code for this. The 'long press
logic unit' seems somewhat similar to the TouchHandle in the way it interacts
with TSC. Perhaps we can factor out the common functionality in a superclass
(TouchSelectionEventProcessor)? 
- The long press logic unit would either extend this superclass or use it
directly. 
- TouchHandle would extend it. 
- TSC would interact with the handles and the long press logic unit through this
superclass's interfact (i.e. the instance of start_selection_handle_ would be
TouchSelectionEventProcessor). 
- TouchHandleClient would become TouchSelectionEventProcessorClient

Then instead of calling WillHandleTouchEventForLongPressDrag(event), we'd just
call longpress_drag_processor_->WillHandleTouchEvent(event), same way we do for
handles. Instead of storing temporarily_hidden_for_longpress_drag_, we'd just
check longpress_drag_processor_->is_dragging(), etc. Do you think something like
this would work? 

[jdduke (slow), 2015/04/21 19:25:57]

I think this is very reasonable. I'd been planning to also pull the
|StylusSelectionController| into this class and have it serve a similar function
(i.e., delegate to it touch events, have it manipulate the selection as a
side-effect). I'll see if I can tease out a simple/common interface, not sure if
we need to force both the handles/drag processing through identical interface,
but I think sharing logic would be beneficial.

[mfomitchev, 2015/04/21 21:08:57]

Do you mean StylusTextSelector?

+  // logic unit.
+  bool temporarily_hidden_for_longpress_drag_;

[mfomitchev, 2015/04/18 16:09:08]

handles_hidden_for_longpress_drag_? Otherwise it's not clear what's hidden.Same
with the setter.

[jdduke (slow), 2015/04/21 19:25:57]

Hmm, well this is a parallel of the existing |temporarily_hidden_| flag, which I
guess is also somewhat ambiguous. I'll update.

+  bool consume_remaining_motion_for_longpress_drag_;
+  bool has_begun_longpress_drag_;
+  gfx::PointF longpress_drag_initial_position_;
+  gfx::Vector2dF longpress_drag_selection_offset_;
+
+  bool has_active_touch_sequence_;
+  gfx::PointF touch_sequence_start_position_;
+
   base::TimeTicks selection_start_time_;
   // Whether a selection handle was dragged during the current 'selection
   // session' - i.e. since the current selection has been activated.
   bool selection_handle_dragged_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchSelectionController);
 };
 
 }  // namespace ui
 
 #endif  // UI_TOUCH_SELECTION_TOUCH_SELECTION_CONTROLLER_H_