Support for Adaptive Handle Orientation

ui/touch_selection/touch_selection_controller.cc

Index: ui/touch_selection/touch_selection_controller.cc
diff --git a/ui/touch_selection/touch_selection_controller.cc b/ui/touch_selection/touch_selection_controller.cc
index 2e18037c658c9b0f7fc02d66e5a8471e8589d0a2..b1f1f47f313b384e3a71e895d8114718a90e0e67 100644
--- a/ui/touch_selection/touch_selection_controller.cc
+++ b/ui/touch_selection/touch_selection_controller.cc
@@ -59,6 +59,7 @@ TouchSelectionController::TouchSelectionController(
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false),
+      viewport_size_changed_(false),
       selection_handle_dragged_(false) {
   DCHECK(client_);
 }
@@ -66,16 +67,26 @@ TouchSelectionController::TouchSelectionController(
 TouchSelectionController::~TouchSelectionController() {
 }
 
+void TouchSelectionController::OnViewportChanged(
+    const gfx::RectF viewport_rect) {
+  if (viewport_rect_ == viewport_rect)
+    return;
+  viewport_size_changed_ = true;
+  viewport_rect_ = viewport_rect;
+}
+
 void TouchSelectionController::OnSelectionBoundsChanged(
     const SelectionBound& start,
     const SelectionBound& end) {
-  if (start == start_ && end_ == end)
+  if (start == start_ && end_ == end && !viewport_size_changed_)
     return;
 
   start_ = start;
   end_ = end;
   start_orientation_ = ToTouchHandleOrientation(start_.type());
   end_orientation_ = ToTouchHandleOrientation(end_.type());
+  SetInvertedOrientation();
+  viewport_size_changed_ = false;
 
   if (!activate_selection_automatically_ &&
       !activate_insertion_automatically_) {
@@ -429,13 +440,70 @@ void TouchSelectionController::ResetCachedValuesIfInactive() {
 }
 
 const gfx::PointF& TouchSelectionController::GetStartPosition() const {
+  bool top_handle =
+      start_orientation_ == TouchHandleOrientation::LEFT_INVERTED ||

[jdduke (slow), 2015/03/19 18:56:39]

Why does the position change depending on the orientation? The position should
be the "focus" of the selection handle, which should be invariant with respect
to orientation, even if we're inverted, right?

[jdduke (slow), 2015/03/23 21:05:31]

Nevermind, it sounds like if we mirror the handle about the x-axis (flip it
vertically), we'll want to position it at the top of the text.

[AviD, 2015/03/26 14:53:11]

Right, it is to position the handles above the text in case of inverted/x-axis
mirrored condition.

+      start_orientation_ == TouchHandleOrientation::LEFT_FLIPPED_INVERTED;
+  if (top_handle)
+    return start_.edge_top();
   return start_.edge_bottom();
 }
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
+  bool top_handle =
+      end_orientation_ == TouchHandleOrientation::RIGHT_INVERTED ||
+      end_orientation_ == TouchHandleOrientation::RIGHT_FLIPPED_INVERTED;
+  if (top_handle)
+    return end_.edge_top();
   return end_.edge_bottom();
 }
 
+void TouchSelectionController::SetInvertedOrientation() {
+  if (!start_selection_handle_ || !end_selection_handle_)
+    return;
+
+  TouchHandleOrientation old_start_orientation = start_orientation_;
+  TouchHandleOrientation old_end_orientation = end_orientation_;
+
+  gfx::RectF start_size = start_selection_handle_->GetHandleBounds();
+  gfx::RectF end_size = end_selection_handle_->GetHandleBounds();
+
+  int start_handle_state = 0;
+  int end_handle_state = 0;
+
+  if (start_.edge_bottom().y() + start_size.height() >
+      viewport_rect_.height()) {
+    start_orientation_ = TouchHandleOrientation::LEFT_INVERTED;
+    start_handle_state++;
+  }
+
+  if (end_.edge_bottom().y() + end_size.height() > viewport_rect_.height()) {
+    end_orientation_ = TouchHandleOrientation::RIGHT_INVERTED;
+    end_handle_state++;
+  }
+
+  if (start_.edge_top().x() - end_size.width() < viewport_rect_.x()) {
+    start_orientation_ = TouchHandleOrientation::LEFT_FLIPPED;
+    start_handle_state++;
+  }
+
+  if (end_.edge_top().x() + start_size.width() > viewport_rect_.width()) {
+    end_orientation_ = TouchHandleOrientation::RIGHT_FLIPPED;
+    end_handle_state++;
+  }
+
+  if (start_handle_state == 2) {

[jdduke (slow), 2015/03/19 18:56:39]

Flipped vs inverted is confusing.

What if, instead, we had a mirror_x + mirror_y argument. We can pass that to the
drawable along with the orientation, which should be all we need to position the
handle (given an anchor position), right? Then we don't need all these enum
combinations.

[jdduke (slow), 2015/03/23 21:05:31]

I wonder if it's worth having the TouchHandle be responsible for mirroring
itself? 

[AviD, 2015/03/26 14:53:10]

I will try this approach with the next patch.

+    start_orientation_ = TouchHandleOrientation::LEFT_FLIPPED_INVERTED;
+  } else if (start_handle_state == 0) {
+    start_orientation_ = old_start_orientation;
+  }
+
+  if (end_handle_state == 2) {
+    end_orientation_ = TouchHandleOrientation::RIGHT_FLIPPED_INVERTED;
+  } else if (end_handle_state == 0) {
+    end_orientation_ = old_end_orientation;
+  }
+}
+
 gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const {
   return ComputeLineOffsetFromBottom(start_);
 }