Index: content/browser/renderer_host/input/touch_selection_controller.cc |
diff --git a/content/browser/renderer_host/input/touch_selection_controller.cc b/content/browser/renderer_host/input/touch_selection_controller.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..bc913fde56e0bf997dfe5412ef147fce17e4e757 |
--- /dev/null |
+++ b/content/browser/renderer_host/input/touch_selection_controller.cc |
@@ -0,0 +1,435 @@ |
+// 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 "content/browser/renderer_host/input/touch_selection_controller.h" |
+ |
+#include "base/auto_reset.h" |
+#include "base/logging.h" |
+#include "third_party/WebKit/public/web/WebInputEvent.h" |
+ |
+namespace content { |
+namespace { |
+ |
+TouchHandleOrientation ToTouchHandleOrientation(cc::SelectionBoundType type) { |
+ switch (type) { |
+ case cc::SELECTION_BOUND_LEFT: |
+ return TOUCH_HANDLE_LEFT; |
+ case cc::SELECTION_BOUND_RIGHT: |
+ return TOUCH_HANDLE_RIGHT; |
+ case cc::SELECTION_BOUND_CENTER: |
+ return TOUCH_HANDLE_CENTER; |
+ case cc::SELECTION_BOUND_EMPTY: |
+ return TOUCH_HANDLE_ORIENTATION_UNDEFINED; |
+ } |
+ NOTREACHED() << "Invalid selection bound type: " << type; |
+ return TOUCH_HANDLE_ORIENTATION_UNDEFINED; |
+} |
+ |
+} // namespace |
+ |
+TouchSelectionController::TouchSelectionController( |
+ TouchSelectionControllerClient* client, |
+ base::TimeDelta tap_timeout, |
+ float tap_slop) |
+ : client_(client), |
+ tap_timeout_(tap_timeout), |
+ tap_slop_(tap_slop), |
+ response_pending_input_event_(INPUT_EVENT_TYPE_NONE), |
+ start_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED), |
+ end_orientation_(TOUCH_HANDLE_ORIENTATION_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) { |
+ DCHECK(client_); |
+ HideAndDisallowShowingAutomatically(); |
+} |
+ |
+TouchSelectionController::~TouchSelectionController() { |
+} |
+ |
+void TouchSelectionController::OnSelectionBoundsChanged( |
+ const cc::ViewportSelectionBound& start, |
+ const cc::ViewportSelectionBound& end) { |
+ if (start == start_ && end_ == end) |
+ return; |
+ |
+ start_ = start; |
+ end_ = end; |
+ start_orientation_ = ToTouchHandleOrientation(start_.type); |
+ end_orientation_ = ToTouchHandleOrientation(end_.type); |
+ |
+ 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. |
+ InputEventType causal_input_event = response_pending_input_event_; |
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE; |
+ base::AutoReset<InputEventType> auto_reset_response_pending_input_event( |
+ &response_pending_input_event_, causal_input_event); |
+ |
+ const bool is_selection_dragging = |
+ is_selection_active_ && (start_selection_handle_->is_dragging() || |
+ end_selection_handle_->is_dragging()); |
+ |
+ // It's possible that the bounds temporarily overlap while a selection handle |
+ // is being dragged, incorrectly reporting a CENTER orientation. |
+ // TODO(jdduke): This safeguard is racy, as it's possible the delayed response |
+ // from handle positioning occurs *after* the handle dragging has ceased. |
+ // Instead, prevent selection -> insertion transitions without an intervening |
+ // action or selection clearing of some sort, crbug.com/392696. |
+ if (is_selection_dragging) { |
+ if (start_orientation_ == TOUCH_HANDLE_CENTER) |
+ start_orientation_ = start_selection_handle_->orientation(); |
+ if (end_orientation_ == TOUCH_HANDLE_CENTER) |
+ end_orientation_ = end_selection_handle_->orientation(); |
+ } |
+ |
+ if (GetStartPosition() != GetEndPosition() || |
+ (is_selection_dragging && |
+ start_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED && |
+ end_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED)) { |
+ OnSelectionChanged(); |
+ return; |
+ } |
+ |
+ if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_) { |
+ OnInsertionChanged(); |
+ return; |
+ } |
+ |
+ HideAndDisallowShowingAutomatically(); |
+} |
+ |
+bool TouchSelectionController::WillHandleTouchEvent( |
+ const ui::MotionEvent& event) { |
+ if (is_insertion_active_) { |
+ DCHECK(insertion_handle_); |
+ return insertion_handle_->WillHandleTouchEvent(event); |
+ } |
+ |
+ if (is_selection_active_) { |
+ DCHECK(start_selection_handle_); |
+ DCHECK(end_selection_handle_); |
+ if (start_selection_handle_->is_dragging()) |
+ return start_selection_handle_->WillHandleTouchEvent(event); |
+ |
+ if (end_selection_handle_->is_dragging()) |
+ return end_selection_handle_->WillHandleTouchEvent(event); |
+ |
+ const gfx::PointF event_pos(event.GetX(), event.GetY()); |
+ if ((event_pos - GetStartPosition()).LengthSquared() <= |
+ (event_pos - GetEndPosition()).LengthSquared()) |
+ return start_selection_handle_->WillHandleTouchEvent(event); |
+ else |
+ return end_selection_handle_->WillHandleTouchEvent(event); |
+ } |
+ |
+ return false; |
+} |
+ |
+void TouchSelectionController::OnLongPressEvent() { |
+ response_pending_input_event_ = LONG_PRESS; |
+ ShowSelectionHandlesAutomatically(); |
+ ShowInsertionHandleAutomatically(); |
+ ResetCachedValuesIfInactive(); |
+} |
+ |
+void TouchSelectionController::AllowShowingFromCurrentSelection() { |
+ if (is_selection_active_ || is_insertion_active_) |
+ return; |
+ |
+ activate_selection_automatically_ = true; |
+ activate_insertion_automatically_ = true; |
+ if (GetStartPosition() != GetEndPosition()) |
+ OnSelectionChanged(); |
+ else if (start_orientation_ == TOUCH_HANDLE_CENTER && selection_editable_) |
+ OnInsertionChanged(); |
+} |
+ |
+void TouchSelectionController::OnTapEvent() { |
+ response_pending_input_event_ = TAP; |
+ ShowInsertionHandleAutomatically(); |
+ if (selection_empty_) |
+ DeactivateInsertion(); |
+ ResetCachedValuesIfInactive(); |
+} |
+ |
+void TouchSelectionController::HideAndDisallowShowingAutomatically() { |
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE; |
+ DeactivateInsertion(); |
+ DeactivateSelection(); |
+ activate_insertion_automatically_ = false; |
+ activate_selection_automatically_ = false; |
+} |
+ |
+void TouchSelectionController::SetTemporarilyHidden(bool hidden) { |
+ if (temporarily_hidden_ == hidden) |
+ return; |
+ temporarily_hidden_ = hidden; |
+ |
+ TouchHandle::AnimationStyle animation_style = GetAnimationStyle(true); |
+ if (is_selection_active_) { |
+ start_selection_handle_->SetVisible(GetStartVisible(), animation_style); |
+ end_selection_handle_->SetVisible(GetEndVisible(), animation_style); |
+ } |
+ if (is_insertion_active_) |
+ insertion_handle_->SetVisible(GetStartVisible(), animation_style); |
+} |
+ |
+void TouchSelectionController::OnSelectionEditable(bool editable) { |
+ if (selection_editable_ == editable) |
+ return; |
+ selection_editable_ = editable; |
+ ResetCachedValuesIfInactive(); |
+ if (!selection_editable_) |
+ DeactivateInsertion(); |
+} |
+ |
+void TouchSelectionController::OnSelectionEmpty(bool empty) { |
+ if (selection_empty_ == empty) |
+ return; |
+ selection_empty_ = empty; |
+ ResetCachedValuesIfInactive(); |
+} |
+ |
+bool TouchSelectionController::Animate(base::TimeTicks frame_time) { |
+ if (is_insertion_active_) |
+ return insertion_handle_->Animate(frame_time); |
+ |
+ if (is_selection_active_) { |
+ bool needs_animate = start_selection_handle_->Animate(frame_time); |
+ needs_animate |= end_selection_handle_->Animate(frame_time); |
+ return needs_animate; |
+ } |
+ |
+ return false; |
+} |
+ |
+void TouchSelectionController::OnHandleDragBegin(const TouchHandle& handle) { |
+ if (&handle == insertion_handle_.get()) { |
+ client_->OnSelectionEvent(INSERTION_DRAG_STARTED, handle.position()); |
+ return; |
+ } |
+ |
+ gfx::PointF base, extent; |
+ if (&handle == start_selection_handle_.get()) { |
+ base = end_selection_handle_->position() + GetEndLineOffset(); |
+ extent = start_selection_handle_->position() + GetStartLineOffset(); |
+ } else { |
+ base = start_selection_handle_->position() + GetStartLineOffset(); |
+ extent = end_selection_handle_->position() + GetEndLineOffset(); |
+ } |
+ |
+ // When moving the handle we want to move only the extent point. Before doing |
+ // so we must make sure that the base point is set correctly. |
+ client_->SelectBetweenCoordinates(base, extent); |
+ |
+ client_->OnSelectionEvent(SELECTION_DRAG_STARTED, handle.position()); |
+} |
+ |
+void TouchSelectionController::OnHandleDragUpdate(const TouchHandle& handle, |
+ const gfx::PointF& position) { |
+ // As the position corresponds to the bottom left point of the selection |
+ // bound, offset it by half the corresponding line height. |
+ gfx::Vector2dF line_offset = &handle == end_selection_handle_.get() |
+ ? GetStartLineOffset() |
+ : GetEndLineOffset(); |
+ gfx::PointF line_position = position + line_offset; |
+ if (&handle == insertion_handle_.get()) { |
+ client_->MoveCaret(line_position); |
+ } else { |
+ client_->MoveRangeSelectionExtent(line_position); |
+ } |
+} |
+ |
+void TouchSelectionController::OnHandleDragEnd(const TouchHandle& handle) { |
+ if (&handle != insertion_handle_.get()) |
+ client_->OnSelectionEvent(SELECTION_DRAG_STOPPED, handle.position()); |
+} |
+ |
+void TouchSelectionController::OnHandleTapped(const TouchHandle& handle) { |
+ if (insertion_handle_ && &handle == insertion_handle_.get()) |
+ client_->OnSelectionEvent(INSERTION_TAPPED, handle.position()); |
+} |
+ |
+void TouchSelectionController::SetNeedsAnimate() { |
+ client_->SetNeedsAnimate(); |
+} |
+ |
+scoped_ptr<TouchHandleDrawable> TouchSelectionController::CreateDrawable() { |
+ return client_->CreateDrawable(); |
+} |
+ |
+base::TimeDelta TouchSelectionController::GetTapTimeout() const { |
+ return tap_timeout_; |
+} |
+ |
+float TouchSelectionController::GetTapSlop() const { |
+ return tap_slop_; |
+} |
+ |
+void TouchSelectionController::ShowInsertionHandleAutomatically() { |
+ if (activate_insertion_automatically_) |
+ return; |
+ activate_insertion_automatically_ = true; |
+ ResetCachedValuesIfInactive(); |
+} |
+ |
+void TouchSelectionController::ShowSelectionHandlesAutomatically() { |
+ if (activate_selection_automatically_) |
+ return; |
+ activate_selection_automatically_ = true; |
+ ResetCachedValuesIfInactive(); |
+} |
+ |
+void TouchSelectionController::OnInsertionChanged() { |
+ DeactivateSelection(); |
+ |
+ if (response_pending_input_event_ == TAP && selection_empty_) { |
+ HideAndDisallowShowingAutomatically(); |
+ return; |
+ } |
+ |
+ if (!activate_insertion_automatically_) |
+ return; |
+ |
+ 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); |
+} |
+ |
+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()); |
+} |
+ |
+void TouchSelectionController::ActivateInsertion() { |
+ DCHECK(!is_selection_active_); |
+ |
+ if (!insertion_handle_) |
+ insertion_handle_.reset(new TouchHandle(this, TOUCH_HANDLE_CENTER)); |
+ |
+ if (!is_insertion_active_) { |
+ is_insertion_active_ = true; |
+ insertion_handle_->SetEnabled(true); |
+ 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_->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_->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) { |
+ is_selection_active_ = true; |
+ response_pending_input_event_ = INPUT_EVENT_TYPE_NONE; |
+ client_->OnSelectionEvent(SELECTION_SHOWN, GetStartPosition()); |
+ } |
+} |
+ |
+void TouchSelectionController::DeactivateSelection() { |
+ if (!is_selection_active_) |
+ return; |
+ DCHECK(start_selection_handle_); |
+ DCHECK(end_selection_handle_); |
+ start_selection_handle_->SetEnabled(false); |
+ end_selection_handle_->SetEnabled(false); |
+ is_selection_active_ = false; |
+ client_->OnSelectionEvent(SELECTION_CLEARED, gfx::PointF()); |
+} |
+ |
+void TouchSelectionController::ResetCachedValuesIfInactive() { |
+ if (is_selection_active_ || is_insertion_active_) |
+ return; |
+ start_ = cc::ViewportSelectionBound(); |
+ end_ = cc::ViewportSelectionBound(); |
+ start_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED; |
+ end_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED; |
+} |
+ |
+const gfx::PointF& TouchSelectionController::GetStartPosition() const { |
+ return start_.edge_bottom; |
+} |
+ |
+const gfx::PointF& TouchSelectionController::GetEndPosition() const { |
+ return end_.edge_bottom; |
+} |
+ |
+gfx::Vector2dF TouchSelectionController::GetStartLineOffset() const { |
+ return gfx::ScaleVector2d(start_.edge_top - start_.edge_bottom, 0.5f); |
+} |
+ |
+gfx::Vector2dF TouchSelectionController::GetEndLineOffset() const { |
+ return gfx::ScaleVector2d(end_.edge_top - end_.edge_bottom, 0.5f); |
+} |
+ |
+bool TouchSelectionController::GetStartVisible() const { |
+ return start_.visible && !temporarily_hidden_; |
+} |
+ |
+bool TouchSelectionController::GetEndVisible() const { |
+ return end_.visible && !temporarily_hidden_; |
+} |
+ |
+TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle( |
+ bool was_active) const { |
+ return was_active && client_->SupportsAnimation() |
+ ? TouchHandle::ANIMATION_SMOOTH |
+ : TouchHandle::ANIMATION_NONE; |
+} |
+ |
+} // namespace content |