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 25 matching lines @@
   }
   NOTREACHED() << "Invalid selection bound type: " << type;
   return TouchHandleOrientation::UNDEFINED;
 }
 
 }  // namespace
 
 TouchSelectionController::Config::Config()
     : max_tap_duration(base::TimeDelta::FromMilliseconds(300)),
       tap_slop(8),
+      enable_adaptive_handle_orientation(false),
       enable_longpress_drag_selection(false),
       show_on_tap_for_empty_editable(false) {}
 
 TouchSelectionController::Config::~Config() {
 }
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     const Config& config)
     : client_(client),
@@ skipping 80 matching lines @@
 
   if (start_orientation_ == TouchHandleOrientation::CENTER &&
       selection_editable_) {
     OnInsertionChanged();
     return;
   }
 
   HideAndDisallowShowingAutomatically();
 }
 
+void TouchSelectionController::OnViewportChanged(
+    const gfx::RectF viewport_rect) {
+  // Trigger a force update if the viewport is changed, so that
+  // it triggers a call to change the mirror values if required.
+  if (viewport_rect_ == viewport_rect) {
+    return;
+  }

[jdduke (slow), 2015/09/14 15:19:40]

Nit: No need for braces on the return line.

[AviD, 2015/09/14 15:57:40]

Done.

+
+  viewport_rect_ = viewport_rect;
+
+  if (active_status_ == INACTIVE)
+    return;
+
+  if (active_status_ == INSERTION_ACTIVE) {
+    DCHECK(insertion_handle_);
+    insertion_handle_->SetViewportRect(viewport_rect);
+  } else if (active_status_ == SELECTION_ACTIVE) {
+    DCHECK(start_selection_handle_);
+    DCHECK(end_selection_handle_);
+    start_selection_handle_->SetViewportRect(viewport_rect);
+    end_selection_handle_->SetViewportRect(viewport_rect);
+  }
+
+  // Update handle layout after setting the new Viewport size.
+  UpdateHandleLayoutIfNecessary();
+}
+
 bool TouchSelectionController::WillHandleTouchEvent(const MotionEvent& event) {
   if (config_.enable_longpress_drag_selection &&
       longpress_drag_selector_.WillHandleTouchEvent(event)) {
     return true;
   }
 
   if (active_status_ == INSERTION_ACTIVE) {
     DCHECK(insertion_handle_);
     return insertion_handle_->WillHandleTouchEvent(event);
   }
@@ skipping 218 matching lines @@
 }
 
 scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() {
   return client_->CreateDrawable();
 }
 
 base::TimeDelta TouchSelectionController::GetMaxTapDuration() const {
   return config_.max_tap_duration;
 }
 
+bool TouchSelectionController::IsAdaptiveHandleOrientationEnabled() const {
+  return config_.enable_adaptive_handle_orientation;
+}
+
 void TouchSelectionController::OnLongPressDragActiveStateChanged() {
   // The handles should remain hidden for the duration of a longpress drag,
   // including the time between a longpress and the start of drag motion.
   RefreshHandleVisibility();
 }
 
 gfx::PointF TouchSelectionController::GetSelectionStart() const {
   return GetStartPosition();
 }
 
@@ skipping 39 matching lines @@
     HideAndDisallowShowingAutomatically();
     return;
   }
 
   if (!activate_insertion_automatically_)
     return;
 
   const bool activated = ActivateInsertionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
+  insertion_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
   insertion_handle_->SetVisible(GetStartVisible(), animation);
-  insertion_handle_->SetPosition(GetStartPosition());
+
+  UpdateHandleLayoutIfNecessary();
 
   client_->OnSelectionEvent(activated ? INSERTION_HANDLE_SHOWN
                                       : INSERTION_HANDLE_MOVED);
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
   if (!activate_selection_automatically_)
     return;
 
   const bool activated = ActivateSelectionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
+
+  start_selection_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
+  end_selection_handle_->SetFocus(end_.edge_top(), end_.edge_bottom());
+
+  start_selection_handle_->SetOrientation(start_orientation_);
+  end_selection_handle_->SetOrientation(end_orientation_);
+
   start_selection_handle_->SetVisible(GetStartVisible(), animation);
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
-  start_selection_handle_->SetPosition(GetStartPosition());
-  end_selection_handle_->SetPosition(GetEndPosition());
+
+  UpdateHandleLayoutIfNecessary();
 
   client_->OnSelectionEvent(activated ? SELECTION_HANDLES_SHOWN
                                       : SELECTION_HANDLES_MOVED);
 }
 
 bool TouchSelectionController::ActivateInsertionIfNecessary() {
   DCHECK_NE(SELECTION_ACTIVE, active_status_);
 
   if (!insertion_handle_) {
     insertion_handle_.reset(
-        new TouchHandle(this, TouchHandleOrientation::CENTER));
+        new TouchHandle(this, TouchHandleOrientation::CENTER, viewport_rect_));
   }
 
   if (active_status_ == INACTIVE) {
     active_status_ = INSERTION_ACTIVE;
+    insertion_handle_->SetViewportRect(viewport_rect_);
     insertion_handle_->SetEnabled(true);
     return true;
   }
   return false;
 }
 
 void TouchSelectionController::DeactivateInsertion() {
   if (active_status_ != INSERTION_ACTIVE)
     return;
   DCHECK(insertion_handle_);
   active_status_ = INACTIVE;
   insertion_handle_->SetEnabled(false);
   client_->OnSelectionEvent(INSERTION_HANDLE_CLEARED);
 }
 
 bool TouchSelectionController::ActivateSelectionIfNecessary() {
   DCHECK_NE(INSERTION_ACTIVE, active_status_);
 
   if (!start_selection_handle_) {
-    start_selection_handle_.reset(new TouchHandle(this, start_orientation_));
+    start_selection_handle_.reset(
+        new TouchHandle(this, start_orientation_, viewport_rect_));
   } else {
+    start_selection_handle_->SetViewportRect(viewport_rect_);
     start_selection_handle_->SetEnabled(true);
-    start_selection_handle_->SetOrientation(start_orientation_);
   }
 
   if (!end_selection_handle_) {
-    end_selection_handle_.reset(new TouchHandle(this, end_orientation_));
+    end_selection_handle_.reset(
+        new TouchHandle(this, end_orientation_, viewport_rect_));
   } else {
+    end_selection_handle_->SetViewportRect(viewport_rect_);

[jdduke (slow), 2015/09/14 15:19:40]

Nit: Can we set the viewport after we set enabled (both here and for the
insertion handle)? I think a common condition in our property setting is that
properties affectiving visibility only change when the handle is enabled.

[AviD, 2015/09/14 15:57:40]

Done.

     end_selection_handle_->SetEnabled(true);
-    end_selection_handle_->SetOrientation(end_orientation_);
   }
 
   // As a long press received while a selection is already active may trigger
   // an entirely new selection, notify the client but avoid sending an
   // intervening SELECTION_HANDLES_CLEARED update to avoid unnecessary state
   // changes.
   if (active_status_ == INACTIVE ||
       response_pending_input_event_ == LONG_PRESS) {
     if (active_status_ == SELECTION_ACTIVE) {
       // The active selection session finishes with the start of the new one.
@@ skipping 26 matching lines @@
   // Only force the update if the reported selection is non-empty but still
   // considered "inactive", i.e., it wasn't preceded by a user gesture or
   // the handles have since been explicitly hidden.
   if (active_status_ == INACTIVE &&
       start_.type() != SelectionBound::EMPTY &&
       end_.type() != SelectionBound::EMPTY) {
     force_next_update_ = true;
   }
 }
 
+void TouchSelectionController::UpdateHandleLayoutIfNecessary() {
+  if (active_status_ == INSERTION_ACTIVE) {
+    DCHECK(insertion_handle_);
+    insertion_handle_->UpdateHandleLayout();
+  } else if (active_status_ == SELECTION_ACTIVE) {
+    DCHECK(start_selection_handle_);
+    DCHECK(end_selection_handle_);
+    start_selection_handle_->UpdateHandleLayout();
+    end_selection_handle_->UpdateHandleLayout();
+  }
+}
+
 void TouchSelectionController::RefreshHandleVisibility() {
   TouchHandle::AnimationStyle animation_style = GetAnimationStyle(true);
   if (active_status_ == SELECTION_ACTIVE) {
     start_selection_handle_->SetVisible(GetStartVisible(), animation_style);
     end_selection_handle_->SetVisible(GetEndVisible(), animation_style);
   }
   if (active_status_ == INSERTION_ACTIVE)
     insertion_handle_->SetVisible(GetStartVisible(), animation_style);
 }
 
@@ skipping 35 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