Support for Adaptive Handle Orientation

ui/touch_selection/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 "ui/touch_selection/touch_handle.h"
 
 #include <cmath>
 
 namespace ui {
 
@@ skipping 55 matching lines @@
                          TouchHandleOrientation orientation)
     : drawable_(client->CreateDrawable()),
       client_(client),
       orientation_(orientation),
       deferred_orientation_(TouchHandleOrientation::UNDEFINED),
       alpha_(0.f),
       animate_deferred_fade_(false),
       enabled_(true),
       is_visible_(false),
       is_dragging_(false),
-      is_drag_within_tap_region_(false) {
+      is_drag_within_tap_region_(false),
+      mirror_vertical_(false),
+      mirror_horizontal_(false) {
   DCHECK_NE(orientation, TouchHandleOrientation::UNDEFINED);
   drawable_->SetEnabled(enabled_);
-  drawable_->SetOrientation(orientation_);
+  drawable_->SetLayout(focus_bottom_, orientation_, false, false);
   drawable_->SetAlpha(alpha_);
-  drawable_->SetFocus(position_);
 }
 
 TouchHandle::~TouchHandle() {
 }
 
 void TouchHandle::SetEnabled(bool enabled) {
   if (enabled_ == enabled)
     return;
   if (!enabled) {
     EndDrag();
     EndFade();
   }
   enabled_ = enabled;
   drawable_->SetEnabled(enabled);
 }
 
 void TouchHandle::SetVisible(bool visible, AnimationStyle animation_style) {
   DCHECK(enabled_);
   if (is_visible_ == visible)
     return;
 
   is_visible_ = visible;
 
   // Handle repositioning may have been deferred while previously invisible.
-  if (visible)
-    drawable_->SetFocus(position_);
+  UpdateLayout();
 
   bool animate = animation_style != ANIMATION_NONE;
   if (is_dragging_) {
     animate_deferred_fade_ = animate;
     return;
   }
 
   if (animate)
     BeginFade();
   else
     EndFade();
 }
 
-void TouchHandle::SetPosition(const gfx::PointF& position) {
-  DCHECK(enabled_);
-  if (position_ == position)
+void TouchHandle::SetFocus(const gfx::PointF& top, const gfx::PointF& bottom) {
+  if (focus_top_ == top && focus_bottom_ == bottom)
     return;
-  position_ = position;
-  // Suppress repositioning a handle while invisible or fading out to prevent it
-  // from "ghosting" outside the visible bounds. The position will be pushed to
-  // the drawable when the handle regains visibility (see |SetVisible()|).
-  if (is_visible_)
-    drawable_->SetFocus(position_);
+
+  focus_top_ = top;
+  focus_bottom_ = bottom;
+  UpdateLayout();

[jdduke (slow), 2015/05/11 15:40:15]

Nice, I think this is a bit easier to follow.

[AviD, 2015/05/19 16:26:27]

Acknowledged.

+}
+
+void TouchHandle::SetViewportRect(const gfx::RectF viewport_rect) {
+  if (viewport_rect_ == viewport_rect)
+    return;
+
+  viewport_rect_ = viewport_rect;
+  UpdateLayout();
 }
 
 void TouchHandle::SetOrientation(TouchHandleOrientation orientation) {
   DCHECK(enabled_);
   DCHECK_NE(orientation, TouchHandleOrientation::UNDEFINED);
   if (is_dragging_) {
     deferred_orientation_ = orientation;
     return;
   }
   DCHECK_EQ(deferred_orientation_, TouchHandleOrientation::UNDEFINED);
+
   if (orientation_ == orientation)
     return;
 
   orientation_ = orientation;
-  drawable_->SetOrientation(orientation);
+  UpdateLayout();
 }
 
 bool TouchHandle::WillHandleTouchEvent(const MotionEvent& event) {
   if (!enabled_)
     return false;
 
   if (!is_dragging_ && event.GetAction() != MotionEvent::ACTION_DOWN)
     return false;
 
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN: {
       if (!is_visible_)
         return false;
       const gfx::PointF touch_point(event.GetX(), event.GetY());
       const float touch_radius = std::max(
           kMinTouchMajorForHitTesting,
           std::min(kMaxTouchMajorForHitTesting, event.GetTouchMajor())) * 0.5f;
       if (!RectIntersectsCircle(drawable_->GetVisibleBounds(),
                                 touch_point,
                                 touch_radius)) {
         EndDrag();
         return false;
       }
       touch_down_position_ = touch_point;
-      touch_to_focus_offset_ = position_ - touch_down_position_;
+      touch_to_focus_offset_ = focus_bottom_ - touch_down_position_;
       touch_down_time_ = event.GetEventTime();
       BeginDrag();
     } break;
 
     case MotionEvent::ACTION_MOVE: {
       gfx::PointF touch_move_position(event.GetX(), event.GetY());
       if (is_drag_within_tap_region_) {
         const float tap_slop = client_->GetTapSlop();
         is_drag_within_tap_region_ =
             (touch_move_position - touch_down_position_).LengthSquared() <
@@ skipping 27 matching lines @@
 }
 
 bool TouchHandle::Animate(base::TimeTicks frame_time) {
   if (fade_end_time_ == base::TimeTicks())
     return false;
 
   DCHECK(enabled_);
 
   float time_u =
       1.f - (fade_end_time_ - frame_time).InMillisecondsF() / kFadeDurationMs;
-  float position_u =
-      (position_ - fade_start_position_).LengthSquared() / kFadeDistanceSquared;
+  float position_u = (focus_bottom_ - fade_start_position_).LengthSquared() /
+                     kFadeDistanceSquared;
   float u = std::max(time_u, position_u);
   SetAlpha(is_visible_ ? u : 1.f - u);
 
   if (u >= 1.f) {
     EndFade();
     return false;
   }
 
   return true;
 }
 
+void TouchHandle::UpdateLayout() {
+  // Suppress repositioning a handle while invisible or fading out to prevent it
+  // from "ghosting" outside the visible bounds. The position will be pushed to
+  // the drawable when the handle regains visibility (see |SetVisible()|).
+  if (!is_visible_)
+    return;
+
+  gfx::RectF handle_bounds = drawable_->GetVisibleBounds();

[mfomitchev, 2015/05/13 22:19:14]

move this inside the if

[AviD, 2015/05/19 16:26:27]

Done.

+
+  // Update mirror values only when dragging has stopped to prevent unwanted
+  // inversion while dragging of handles
+  if (!is_dragging_) {
+    mirror_horizontal_ = false;
+    mirror_vertical_ = false;
+
+    if (focus_bottom_.y() + handle_bounds.height() > viewport_rect_.bottom()) {
+      mirror_vertical_ = true;
+    }
+
+    if (orientation_ == TouchHandleOrientation::LEFT &&
+        focus_bottom_.x() - handle_bounds.width() < viewport_rect_.x()) {

[mfomitchev, 2015/05/13 22:19:14]

This assumes that handle is drawn without any offset to the focus position, but
in reality there's focal_offset_from_origin_ equal to 1/4 of the handle width,
so we will be a bit too eager to flip horizontally.

By the way, I don't understand why do we have that focal_offset_from_origin_? Is
there exactly 1/4 whitespace padding on handle images? jdduke, perhaps you know?

[jdduke (slow), 2015/05/14 15:20:10]

I believe so, yes. The |handle_bounds| should give us the bounds in the right
(viewport) coordinates, so as you say we should be using those coordinates
instead of just the width/height.

[jdduke (slow), 2015/05/14 15:20:10]

Good catch, |handle_bounds| should already be in viewport coordinates, but it's
using coordinates from the previous frame, so we have a bit of a chicken and egg
here. Also, I think the |GetVisibleBounds()| call may now be incorrect for
mirrored handles... hmm...
I believe so, yes.

[mfomitchev, 2015/05/14 15:52:39]

Yeah, and the coordinates from the previous frame may already reflect values for
a mirrored handle, so we can't use them. Perhaps we can expose the value of
focal_offset_from_origin for a non-mirrored handle, and then we can offset the
width by that amount?
It's correct for the previous frame, but not necessarily after we update the
layout, right?

[AviD, 2015/05/19 16:26:27]

The focal_offset_from_origin is always 1/4th the width. But the handles
sometimes have an extra transparent region after the handle image. For Samsung
platform handles, the width is 1/4th the width of the image.

eg: Left handle drawable is like:

______________
|        /|   |
|       /.|   |
|      /..|   |
|     /...|   |
|    /....|   |
|____\____|___|

<1/4> <1/2> <1/4>


@jdduke: is this same for all handles? if it is so, then would it be okay if we
check (handle_width*0.5) for checking mirror on the y axis condition? (or check
for (handle_width*0.75) otherwise)

[jdduke (slow), 2015/05/19 18:59:26]

We've made this assumption until now and it's worked. I think Android would have
a hard time changing this fact, but we probably cannot assume this for other
platforms.

Worst case, we're slightly over aggressive in flipping the handles, but I don't
necessarily think that's a bad thing? I'll have to try it out and see how it
feels.

[AviD, 2015/05/21 09:23:14]

I have changed it to (handle_bounds.width() * 0.75f) to consider the focal
offset only. The extra transparent padding would result in flipping the handles
slightly earlier.

On 2015/05/19 18:59:26, jdduke wrote:

+      mirror_horizontal_ = true;
+    }
+
+    if (orientation_ == TouchHandleOrientation::RIGHT &&

[mfomitchev, 2015/05/13 22:19:14]

else if

[AviD, 2015/05/19 16:26:28]

Done.

+        focus_bottom_.x() + handle_bounds.width() > viewport_rect_.right()) {
+      mirror_horizontal_ = true;
+    }
+  }
+
+  gfx::PointF position = mirror_vertical_ ? focus_top_ : focus_bottom_;
+
+  drawable_->SetLayout(position, orientation_, mirror_vertical_,
+                       mirror_horizontal_);
+}
+
 void TouchHandle::BeginDrag() {
   DCHECK(enabled_);
   if (is_dragging_)
     return;
   EndFade();
   is_dragging_ = true;
   is_drag_within_tap_region_ = true;
   client_->OnHandleDragBegin(*this);
 }
 
 void TouchHandle::EndDrag() {
   DCHECK(enabled_);
   if (!is_dragging_)
     return;
 
   is_dragging_ = false;
   is_drag_within_tap_region_ = false;
   client_->OnHandleDragEnd(*this);
 
   if (deferred_orientation_ != TouchHandleOrientation::UNDEFINED) {
     TouchHandleOrientation deferred_orientation = deferred_orientation_;
     deferred_orientation_ = TouchHandleOrientation::UNDEFINED;
     SetOrientation(deferred_orientation);
+    UpdateLayout();

[mfomitchev, 2015/05/13 22:19:14]

// Handle layout may is deferred while the handle is dragged.

[AviD, 2015/05/19 16:26:27]

Done.

   }
 
   if (animate_deferred_fade_) {
     BeginFade();
   } else {
     // As drawable visibility assignment is deferred while dragging, push the
     // change by forcing fade completion.
     EndFade();
   }
 }
 
 void TouchHandle::BeginFade() {
   DCHECK(enabled_);
   DCHECK(!is_dragging_);
   animate_deferred_fade_ = false;
   const float target_alpha = is_visible_ ? 1.f : 0.f;
   if (target_alpha == alpha_) {
     EndFade();
     return;
   }
 
   fade_end_time_ = base::TimeTicks::Now() +
                    base::TimeDelta::FromMillisecondsD(
                        kFadeDurationMs * std::abs(target_alpha - alpha_));
-  fade_start_position_ = position_;
+  fade_start_position_ = focus_bottom_;
   client_->SetNeedsAnimate();
 }
 
 void TouchHandle::EndFade() {
   DCHECK(enabled_);
   animate_deferred_fade_ = false;
   fade_end_time_ = base::TimeTicks();
   SetAlpha(is_visible_ ? 1.f : 0.f);
 }
 
 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 ui