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());
+  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 235 matching lines @@
 
   const bool was_active = is_insertion_active_;
   const gfx::PointF position = GetStartPosition();
   if (!is_insertion_active_)
     ActivateInsertion();
   else
     client_->OnSelectionEvent(INSERTION_MOVED, position);
 
   insertion_handle_->SetVisible(GetStartVisible(),
                                 GetAnimationStyle(was_active));
-  insertion_handle_->SetPosition(position);
+  insertion_handle_->UpdatePosition();
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
   if (!activate_selection_automatically_)
     return;
 
   const bool was_active = is_selection_active_;
   ActivateSelection();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(was_active);
   start_selection_handle_->SetVisible(GetStartVisible(), animation);
   end_selection_handle_->SetVisible(GetEndVisible(), animation);
 
-  start_selection_handle_->SetPosition(GetStartPosition());
-  end_selection_handle_->SetPosition(GetEndPosition());
+  start_selection_handle_->UpdatePosition();
+  end_selection_handle_->UpdatePosition();
 }
 
 void TouchSelectionController::ActivateInsertion() {
   DCHECK(!is_selection_active_);
 
   if (!insertion_handle_)
     insertion_handle_.reset(
         new TouchHandle(this, TouchHandleOrientation::CENTER));
 
   if (!is_insertion_active_) {
     is_insertion_active_ = true;
     insertion_handle_->SetEnabled(true);
+    insertion_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
+    insertion_handle_->SetViewportRect(viewport_rect_);
     client_->OnSelectionEvent(INSERTION_SHOWN, GetStartPosition());
   }
 }
 
 void TouchSelectionController::DeactivateInsertion() {
   if (!is_insertion_active_)
     return;
   DCHECK(insertion_handle_);
   is_insertion_active_ = false;
   insertion_handle_->SetEnabled(false);
   client_->OnSelectionEvent(INSERTION_CLEARED, gfx::PointF());
 }
 
 void TouchSelectionController::ActivateSelection() {
   DCHECK(!is_insertion_active_);
 
   if (!start_selection_handle_) {
     start_selection_handle_.reset(new TouchHandle(this, start_orientation_));
   } else {
     start_selection_handle_->SetEnabled(true);
+    start_selection_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
+    start_selection_handle_->SetViewportRect(viewport_rect_);
     start_selection_handle_->SetOrientation(start_orientation_);
   }
 
   if (!end_selection_handle_) {
     end_selection_handle_.reset(new TouchHandle(this, end_orientation_));
   } else {
     end_selection_handle_->SetEnabled(true);
+    end_selection_handle_->SetFocus(end_.edge_top(), end_.edge_bottom());
+    end_selection_handle_->SetViewportRect(viewport_rect_);
     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_CLEARED update to avoid unnecessary state changes.
   if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
     if (is_selection_active_) {
       // The active selection session finishes with the start of the new one.
       LogSelectionEnd();
@@ skipping 67 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