[Android] Composited selection handle rendering

content/browser/renderer_host/input/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 "content/browser/renderer_host/input/touch_handle.h"
+
+namespace content {
+
+namespace {
+
+// Maximum duration of a fade sequence.
+const double kFadeDurationMs = 200;
+
+// Maximum amount of travel for a fade sequence. This avoids handle "ghosting"
+// when the handle is moving rapidly while the fade is active.
+const double kFadeDistanceSquared = 20.f * 20.f;
+
+}  // namespace
+
+// Responsible for rendering a selection or insertion handle for text editing.
+TouchHandle::TouchHandle(TouchHandleClient* client,
+                         TouchHandleOrientation orientation)
+    : drawable_(client->CreateDrawable()),
+      client_(client),
+      orientation_(orientation),
+      deferred_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
+      alpha_(0.f),
+      is_visible_(false),
+      is_dragging_(false) {
+  DCHECK_NE(orientation, TOUCH_HANDLE_ORIENTATION_UNDEFINED);
+  drawable_->SetOrientation(orientation_);
+  drawable_->SetAlpha(alpha_);
+  drawable_->SetVisible(is_visible_);
+}
+
+TouchHandle::~TouchHandle() {
+}
+
+void TouchHandle::SetVisible(bool visible) {
+  if (is_visible_ == visible)
+    return;
+  is_visible_ = visible;
+  drawable_->SetVisible(visible);
+  CancelFade();
+}
+
+void TouchHandle::SetVisibleAnimated(bool visible) {
+  if (is_visible_ == visible)
+    return;
+  is_visible_ = visible;
+  // The fade will be reschedule once dragging completes.
+  if (is_dragging_)
+    return;
+  ScheduleFade();
+}
+
+void TouchHandle::SetPosition(const gfx::PointF& position) {
+  if (position_ == position)
+    return;
+  position_ = position;
+  // Avoid positioning handles outside their visible bounds during a fade.
+  if (!fade_end_time_.is_null() && !is_visible_)
+    return;
+  drawable_->SetFocus(position_);
+}
+
+void TouchHandle::SetOrientation(TouchHandleOrientation orientation) {
+  DCHECK_NE(orientation, TOUCH_HANDLE_ORIENTATION_UNDEFINED);
+  if (is_dragging_) {
+    deferred_orientation_ = orientation;
+    return;
+  }
+
+  deferred_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;
+
+  if (orientation_ == orientation)
+    return;
+
+  orientation_ = orientation;
+  drawable_->SetOrientation(orientation);
+}
+
+void TouchHandle::Hide() {
+  SetVisible(false);
+  CancelFade();
+  is_dragging_ = false;
+}
+
+bool TouchHandle::WillHandleTouchEvent(const ui::MotionEvent& event) {
+  if (!is_dragging_ && event.GetAction() != ui::MotionEvent::ACTION_DOWN)
+    return false;
+
+  switch (event.GetAction()) {
+    case ui::MotionEvent::ACTION_DOWN: {
+      gfx::PointF touch_position = gfx::PointF(event.GetX(), event.GetY());
+      if (!is_visible_ || !drawable_->ContainsPoint(touch_position))
+        return false;
+      down_position_ = touch_position;
+      touch_to_focus_offset_ = position_ - down_position_;
+      touch_timer_ = event.GetEventTime();
+      BeginDrag();
+    } break;
+
+    case ui::MotionEvent::ACTION_MOVE: {
+      gfx::PointF new_position =
+          gfx::PointF(event.GetX(), event.GetY()) + touch_to_focus_offset_;
+      client_->OnHandleDragUpdate(*this, new_position);
+    } break;
+
+    case ui::MotionEvent::ACTION_UP: {
+      base::TimeDelta delay = event.GetEventTime() - touch_timer_;
+      if (delay < base::TimeDelta::FromMilliseconds(180))
+        client_->OnHandleTapped(*this);
+
+      EndDrag();
+    } break;
+
+    case ui::MotionEvent::ACTION_CANCEL:
+      EndDrag();
+      break;
+
+    default:
+      break;
+  };
+  return true;
+}
+
+bool TouchHandle::Animate(base::TimeTicks frame_time) {
+  if (fade_end_time_ == base::TimeTicks())
+    return false;
+
+  float time_u =
+      1.f - (fade_end_time_ - frame_time).InMillisecondsF() / kFadeDurationMs;
+  float position_u =
+      (position_ - fade_start_position_).LengthSquared() / kFadeDistanceSquared;
+  float u = std::max(time_u, position_u);
+  SetAlpha(is_visible_ ? u : 1.f - u);
+
+  if (u >= 1.f) {
+    CancelFade();
+    return false;
+  }
+
+  return true;
+}
+
+void TouchHandle::BeginDrag() {
+  if (is_dragging_)
+    return;
+  is_dragging_ = true;
+  client_->OnHandleDragBegin(*this);
+}
+
+void TouchHandle::EndDrag() {
+  if (!is_dragging_)
+    return;
+
+  is_dragging_ = false;
+  client_->OnHandleDragEnd(*this);
+
+  if (deferred_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED)
+    SetOrientation(deferred_orientation_);
+
+  ScheduleFade();
+}
+
+void TouchHandle::ScheduleFade() {
+  const float target_alpha = is_visible_ ? 1.f : 0.f;
+  if (target_alpha == alpha_)
+    return;
+
+  drawable_->SetVisible(true);
+  fade_end_time_ = base::TimeTicks::Now() +
+                   base::TimeDelta::FromMillisecondsD(
+                       kFadeDurationMs * std::abs(target_alpha - alpha_));
+  fade_start_position_ = position_;
+  client_->SetNeedsAnimate();
+}
+
+void TouchHandle::CancelFade() {
+  fade_end_time_ = base::TimeTicks();
+  SetAlpha(is_visible_ ? 1.f : 0.f);
+  drawable_->SetVisible(is_visible_);

[cjhopman, 2014/07/07 22:13:40]

Should this call drawable_->SetFocus(position_)? When fading out position
updates aren't set to the drawable and so these would be out of sync at this
point (though it probably doesn't really matter since it isn't visible).

[jdduke (slow), 2014/07/08 00:54:44]

Yeah, may not matter but probably best for consistency.

+}
+
+void TouchHandle::SetAlpha(float alpha) {
+  alpha = std::max(0.f, std::min(1.f, alpha));
+  if (alpha_ == alpha)
+    return;
+  alpha_ = alpha;
+  drawable_->SetAlpha(alpha);
+}
+
+}  // namespace content