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 55 matching lines @@
                          TouchHandleOrientation orientation)
     : drawable_(client->CreateDrawable()),
       client_(client),
       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_->SetOrientation(orientation_, false, false);
   drawable_->SetAlpha(alpha_);
   drawable_->SetFocus(position_);
 }
 
 TouchHandle::~TouchHandle() {
 }
 
 void TouchHandle::SetEnabled(bool enabled) {
   if (enabled_ == enabled)
     return;
@@ skipping 33 matching lines @@
   if (position_ == position)
     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_);
 }
 
-void TouchHandle::SetOrientation(TouchHandleOrientation orientation) {
+void TouchHandle::SetOrientation(TouchHandleOrientation orientation,
+                                 const gfx::RectF viewport_rect,
+                                 const gfx::PointF handle_bottom) {
   DCHECK(enabled_);
   DCHECK_NE(orientation, TouchHandleOrientation::UNDEFINED);
   if (is_dragging_) {
     deferred_orientation_ = orientation;
+    deferred_viewport_rect_ = viewport_rect;
+    deferred_handle_bottom_ = handle_bottom;
     return;
   }
   DCHECK_EQ(deferred_orientation_, TouchHandleOrientation::UNDEFINED);
-  if (orientation_ == orientation)
+
+  bool mirror_state_changed =
+      SetInvertHandleParameters(viewport_rect, handle_bottom);
+  if (orientation_ == orientation && !mirror_state_changed)
     return;
 
   orientation_ = orientation;
-  drawable_->SetOrientation(orientation);
+  drawable_->SetOrientation(orientation, mirror_vertical_, mirror_horizontal_);
+}
+
+bool TouchHandle::SetInvertHandleParameters(const gfx::RectF viewport_rect,
+                                            const gfx::PointF handle_bottom) {
+  bool mirror_vertical = false;
+  bool mirror_horizontal = false;
+  bool mirror_state_changed = false;
+  gfx::RectF handle_bounds = drawable_->GetVisibleBounds();
+
+  if (handle_bottom.y() + handle_bounds.height() > viewport_rect.bottom()) {
+    mirror_vertical = true;
+  }
+
+  if (orientation_ == TouchHandleOrientation::LEFT &&
+      handle_bottom.x() - handle_bounds.width() < viewport_rect.x()) {
+    mirror_horizontal = true;
+  }
+
+  if (orientation_ == TouchHandleOrientation::RIGHT &&
+      handle_bottom.x() + handle_bounds.width() > viewport_rect.right()) {
+    mirror_horizontal = true;
+  }
+
+  mirror_state_changed = mirror_vertical_ != mirror_vertical ||
+                         mirror_horizontal_ != mirror_horizontal;
+  mirror_vertical_ = mirror_vertical;
+  mirror_horizontal_ = mirror_horizontal;
+
+  return mirror_state_changed;
 }
 
 bool TouchHandle::WillHandleTouchEvent(const MotionEvent& event) {
   if (!enabled_)
     return false;
 
   if (!is_dragging_ && event.GetAction() != MotionEvent::ACTION_DOWN)
     return false;
 
   switch (event.GetAction()) {
@@ skipping 87 matching lines @@
   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);
+    SetOrientation(deferred_orientation, deferred_viewport_rect_,
+                   deferred_handle_bottom_);
   }
 
   if (animate_deferred_fade_) {
     BeginFade();
   } else {
     // As drawable visibility assignment is deferred while dragging, push the
     // change by forcing fade completion.
     EndFade();
   }
 }
@@ skipping 23 matching lines @@
 }
 
 void TouchHandle::SetAlpha(float alpha) {
   alpha = std::max(0.f, std::min(1.f, alpha));
   if (alpha_ == alpha)
     return;
   alpha_ = alpha;
   drawable_->SetAlpha(alpha);
 }
 
+gfx::RectF TouchHandle::GetHandleBounds() {
+  return drawable_->GetVisibleBounds();
+}
+
 }  // namespace ui