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()
     : tap_timeout(base::TimeDelta::FromMilliseconds(100)),
       tap_slop(8),
+      enable_adaptive_handle_orientation(false),
       enable_longpress_drag_selection(false),
-      show_on_tap_for_empty_editable(false) {
-}
+      show_on_tap_for_empty_editable(false) {}
 
 TouchSelectionController::Config::~Config() {
 }
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     const Config& config)
     : client_(client),
       config_(config),
       force_next_update_(false),
@@ skipping 78 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) {

[jdduke (slow), 2015/08/17 17:20:53]

I don't think we should rely on the |OnViewportChanged| signal being called
every frame. I'd rather we trigger UpdateHandleLayoutIfRequired() in
OnSelectionChanged/OnInsertionChanged after we finish pushing the properties.

This might mean we get two updates when the viewport is changed, but I'd rather
that than rely on this getting called every frame.

[AviD, 2015/08/18 13:56:14]

Done.

+    UpdateHandleLayoutIfRequired();
+    return;
+  }
+
+  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 once per frame update if necessary.
+  UpdateHandleLayoutIfRequired();
+}
+
+void TouchSelectionController::UpdateHandleLayoutIfRequired() {

[jdduke (slow), 2015/08/17 17:20:53]

Nit: Move the definition down into the same order as the declaration.

[AviD, 2015/08/18 13:56:14]

Done.

+  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();
+  }
+}
+
 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::GetTapTimeout() const {
   return config_.tap_timeout;
 }
 
+bool TouchSelectionController::IsEnabledAdaptiveHandleOrientation() 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());
 
   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());
 
   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_);
     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 34 matching lines @@
 }
 
 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);
+  UpdateHandleLayoutIfRequired();

[jdduke (slow), 2015/08/17 17:20:53]

I don't think this is necessary.

[AviD, 2015/08/18 13:56:14]

Right. If I move UpdateHandleLayoutIfRequired() to onSelectionChanged() and
onInsertionChanged(), this would not be required.

 }
 
 gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const {
   return ComputeLineOffsetFromBottom(start_);
 }
 
 gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const {
   return ComputeLineOffsetFromBottom(end_);
 }
 
@@ skipping 27 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