Support for Adaptive Handle Orientation

ui/touch_selection/touch_handle.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_handle.h"
 
 #include <cmath>
 
 namespace ui {
 
@@ skipping 45 matching lines @@
       return os << "CENTER";
     case TouchHandleOrientation::UNDEFINED:
       return os << "UNDEFINED";
     default:
       return os << "INVALID: " << static_cast<int>(orientation);
   }
 }
 
 // Responsible for rendering a selection or insertion handle for text editing.
 TouchHandle::TouchHandle(TouchHandleClient* client,
-                         TouchHandleOrientation orientation)
+                         TouchHandleOrientation orientation,
+                         const gfx::RectF viewport_rect)
     : drawable_(client->CreateDrawable()),
       client_(client),
+      viewport_rect_(viewport_rect),
       orientation_(orientation),
       deferred_orientation_(TouchHandleOrientation::UNDEFINED),
       alpha_(0.f),
       animate_deferred_fade_(false),
       enabled_(true),
       is_visible_(false),
       is_dragging_(false),
-      is_drag_within_tap_region_(false) {
+      is_drag_within_tap_region_(false),
+      mirror_vertical_(false),
+      mirror_horizontal_(false) {
   DCHECK_NE(orientation, TouchHandleOrientation::UNDEFINED);
   drawable_->SetEnabled(enabled_);
-  drawable_->SetOrientation(orientation_);
+  drawable_->SetLayout(focus_bottom_, orientation_, false, false, false);
   drawable_->SetAlpha(alpha_);
-  drawable_->SetFocus(position_);
 }
 
 TouchHandle::~TouchHandle() {
 }
 
 void TouchHandle::SetEnabled(bool enabled) {
   if (enabled_ == enabled)
     return;
   if (!enabled) {
     EndDrag();
     EndFade();
   }
   enabled_ = enabled;
   drawable_->SetEnabled(enabled);
 }
 
 void TouchHandle::SetVisible(bool visible, AnimationStyle animation_style) {
   DCHECK(enabled_);
   if (is_visible_ == visible)
     return;
 
   is_visible_ = visible;
 
   // Handle repositioning may have been deferred while previously invisible.
-  if (visible)
-    drawable_->SetFocus(position_);
+  UpdateLayout();
 
   bool animate = animation_style != ANIMATION_NONE;
   if (is_dragging_) {
     animate_deferred_fade_ = animate;
     return;
   }
 
   if (animate)
     BeginFade();
   else
     EndFade();
 }
 
-void TouchHandle::SetPosition(const gfx::PointF& position) {
-  DCHECK(enabled_);
-  if (position_ == position)
+void TouchHandle::SetFocus(const gfx::PointF& top, const gfx::PointF& bottom) {
+  if (focus_top_ == top && focus_bottom_ == bottom)
     return;
-  position_ = position;
-  // Suppress repositioning a handle while invisible or fading out to prevent it
-  // from "ghosting" outside the visible bounds. The position will be pushed to
-  // the drawable when the handle regains visibility (see |SetVisible()|).
-  if (is_visible_)
-    drawable_->SetFocus(position_);
+
+  focus_top_ = top;
+  focus_bottom_ = bottom;
+  UpdateLayout();
+}
+
+void TouchHandle::SetViewportRect(const gfx::RectF viewport_rect) {
+  if ((viewport_rect_ == viewport_rect))
+    return;
+
+  viewport_rect_ = viewport_rect;
+  UpdateLayout();
 }
 
 void TouchHandle::SetOrientation(TouchHandleOrientation orientation) {
   DCHECK(enabled_);
   DCHECK_NE(orientation, TouchHandleOrientation::UNDEFINED);
   if (is_dragging_) {
     deferred_orientation_ = orientation;
     return;
   }
   DCHECK_EQ(deferred_orientation_, TouchHandleOrientation::UNDEFINED);
   if (orientation_ == orientation)
     return;
 
   orientation_ = orientation;
-  drawable_->SetOrientation(orientation);
+  UpdateLayout();
 }
 
 bool TouchHandle::WillHandleTouchEvent(const MotionEvent& event) {
   if (!enabled_)
     return false;
 
   if (!is_dragging_ && event.GetAction() != MotionEvent::ACTION_DOWN)
     return false;
 
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN: {
       if (!is_visible_)
         return false;
       const gfx::PointF touch_point(event.GetX(), event.GetY());
       const float touch_radius = std::max(
           kMinTouchMajorForHitTesting,
           std::min(kMaxTouchMajorForHitTesting, event.GetTouchMajor())) * 0.5f;
       if (!RectIntersectsCircle(drawable_->GetVisibleBounds(),
                                 touch_point,
                                 touch_radius)) {
         EndDrag();
         return false;
       }
       touch_down_position_ = touch_point;
-      touch_to_focus_offset_ = position_ - touch_down_position_;
+      touch_to_focus_offset_ = focus_bottom_ - touch_down_position_;
       touch_down_time_ = event.GetEventTime();
       BeginDrag();
     } break;
 
     case MotionEvent::ACTION_MOVE: {
       gfx::PointF touch_move_position(event.GetX(), event.GetY());
       if (is_drag_within_tap_region_) {
         const float tap_slop = client_->GetTapSlop();
         is_drag_within_tap_region_ =
             (touch_move_position - touch_down_position_).LengthSquared() <
@@ skipping 27 matching lines @@
 }
 
 bool TouchHandle::Animate(base::TimeTicks frame_time) {
   if (fade_end_time_ == base::TimeTicks())
     return false;
 
   DCHECK(enabled_);
 
   float time_u =
       1.f - (fade_end_time_ - frame_time).InMillisecondsF() / kFadeDurationMs;
-  float position_u =
-      (position_ - fade_start_position_).LengthSquared() / kFadeDistanceSquared;
+  float position_u = (focus_bottom_ - fade_start_position_).LengthSquared() /
+                     kFadeDistanceSquared;
   float u = std::max(time_u, position_u);
   SetAlpha(is_visible_ ? u : 1.f - u);
 
   if (u >= 1.f) {
     EndFade();
     return false;
   }
 
   return true;
 }
 
 gfx::RectF TouchHandle::GetVisibleBounds() const {
   if (!is_visible_ || !enabled_)
     return gfx::RectF();
 
   return drawable_->GetVisibleBounds();
 }
 
+void TouchHandle::UpdateLayout() {
+  // Suppress repositioning a handle while invisible or fading out to prevent it
+  // from "ghosting" outside the visible bounds. The position will be pushed to
+  // the drawable when the handle regains visibility (see |SetVisible()|).
+  if (!is_visible_)
+    return;
+
+  // Update mirror values only when dragging has stopped to prevent unwanted
+  // inversion while dragging of handles
+  bool mirror_changed = false;
+
+  if (!is_dragging_) {
+    gfx::RectF handle_bounds = drawable_->GetVisibleBounds();
+    bool mirror_horizontal = false;
+    bool mirror_vertical = false;
+
+    if (focus_bottom_.y() + handle_bounds.height() + viewport_rect_.y() >
+        viewport_rect_.bottom()) {

[jdduke (slow), 2015/06/03 18:59:00]

There's one scenario I wonder if we should handle differently. For WebView, the
size of the viewport may be quite small, the size of the actual line of text. In
that case, we would always invert the handles, but I wonder if we should avoid
that? So we might change the logic to something like:

float bottom_y_unmirrored = focus_bottom_.y() + handle_bounds.height() +
viewport_rect_.y();
float top_y_mirrored = focus_top_.y() - handle_bounds.height() +
viewport_rect_.y();
if (bottom_y_mirrored > viewport_rect_.bottom() && top_y_mirrored >
viewport_rect_.top()) {
  mirror_vertical = true;
}
  mirror_vertical = true;
}

[AviD, 2015/06/08 08:51:37]

Done.

+      mirror_vertical = true;
+    }
+
+    if (orientation_ == TouchHandleOrientation::LEFT &&
+        focus_bottom_.x() - (handle_bounds.width() * 0.75f) <
+            viewport_rect_.x()) {
+      mirror_horizontal = true;
+    } else if (orientation_ == TouchHandleOrientation::RIGHT &&
+               focus_bottom_.x() + (handle_bounds.width() * 0.75f) >
+                   viewport_rect_.right()) {
+      mirror_horizontal = true;
+    }
+
+    mirror_changed = mirror_horizontal != mirror_horizontal_ ||
+                     mirror_vertical != mirror_vertical_;
+    mirror_horizontal_ = mirror_horizontal;
+    mirror_vertical_ = mirror_vertical;
+  }
+
+  gfx::PointF position = mirror_vertical_ ? focus_top_ : focus_bottom_;
+
+  drawable_->SetLayout(position, orientation_, mirror_vertical_,
+                       mirror_horizontal_, mirror_changed);
+}
+
 void TouchHandle::BeginDrag() {
   DCHECK(enabled_);
   if (is_dragging_)
     return;
   EndFade();
   is_dragging_ = true;
   is_drag_within_tap_region_ = true;
   client_->OnHandleDragBegin(*this);
 }
 
 void TouchHandle::EndDrag() {
   DCHECK(enabled_);
   if (!is_dragging_)
     return;
 
   is_dragging_ = false;
   is_drag_within_tap_region_ = false;
   client_->OnHandleDragEnd(*this);
 
   if (deferred_orientation_ != TouchHandleOrientation::UNDEFINED) {
     TouchHandleOrientation deferred_orientation = deferred_orientation_;
     deferred_orientation_ = TouchHandleOrientation::UNDEFINED;
     SetOrientation(deferred_orientation);
+    // Handle layout may is deferred while the handle is dragged.
+    UpdateLayout();
   }
 
   if (animate_deferred_fade_) {
     BeginFade();
   } else {
     // As drawable visibility assignment is deferred while dragging, push the
     // change by forcing fade completion.
     EndFade();
   }
 }
 
 void TouchHandle::BeginFade() {
   DCHECK(enabled_);
   DCHECK(!is_dragging_);
   animate_deferred_fade_ = false;
   const float target_alpha = is_visible_ ? 1.f : 0.f;
   if (target_alpha == alpha_) {
     EndFade();
     return;
   }
 
   fade_end_time_ = base::TimeTicks::Now() +
                    base::TimeDelta::FromMillisecondsD(
                        kFadeDurationMs * std::abs(target_alpha - alpha_));
-  fade_start_position_ = position_;
+  fade_start_position_ = focus_bottom_;
   client_->SetNeedsAnimate();
 }
 
 void TouchHandle::EndFade() {
   DCHECK(enabled_);
   animate_deferred_fade_ = false;
   fade_end_time_ = base::TimeTicks();
   SetAlpha(is_visible_ ? 1.f : 0.f);
 }
 
 void TouchHandle::SetAlpha(float alpha) {
   alpha = std::max(0.f, std::min(1.f, alpha));
   if (alpha_ == alpha)
     return;
   alpha_ = alpha;
   drawable_->SetAlpha(alpha);
 }
 
 }  // namespace ui