Support for Adaptive Handle Orientation

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),
+      viewport_size_changed_(false),
       selection_handle_dragged_(false) {
   DCHECK(client_);
 }
 
 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_) {
     DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
     return;
   }
 
   // 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.
@@ skipping 333 matching lines @@
 void TouchSelectionController::ResetCachedValuesIfInactive() {
   if (is_selection_active_ || is_insertion_active_)
     return;
   start_ = SelectionBound();
   end_ = SelectionBound();
   start_orientation_ = TouchHandleOrientation::UNDEFINED;
   end_orientation_ = TouchHandleOrientation::UNDEFINED;
 }
 
 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_);
 }
 
 gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
   return ComputeLineOffsetFromBottom(end_);
 }
 
 bool TouchSelectionController::GetStartVisible() const {
   return start_.visible() && !temporarily_hidden_;
@@ skipping 19 matching lines @@
     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