Make touch-resizing windows to screen edge possible

ash/wm/window_resizer.cc

 // Copyright (c) 2012 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 "ash/wm/window_resizer.h"
 
+#include <cmath>
+
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
@@ skipping 83 matching lines @@
 const int WindowResizer::kBoundsChangeDirection_Horizontal = 1;
 // static
 const int WindowResizer::kBoundsChangeDirection_Vertical = 2;
 
 WindowResizer::Details::Details()
     : window(NULL),
       window_component(HTNOWHERE),
       bounds_change(0),
       position_change_direction(0),
       size_change_direction(0),
-      is_resizable(false) {
+      is_resizable(false),
+      is_touch(false) {
 }
 
 WindowResizer::Details::Details(aura::Window* window,
                                 const gfx::Point& location,
                                 int window_component)
     : window(window),
       initial_bounds_in_parent(window->bounds()),
       restore_bounds(gfx::Rect()),
       initial_location_in_parent(location),
       initial_opacity(window->layer()->opacity()),
       window_component(window_component),
       bounds_change(GetBoundsChangeForWindowComponent(window_component)),
       position_change_direction(
           GetPositionChangeDirectionForWindowComponent(window_component)),
       size_change_direction(
           GetSizeChangeDirectionForWindowComponent(window_component)),
-      is_resizable(bounds_change != kBoundsChangeDirection_None) {
+      is_resizable(bounds_change != kBoundsChangeDirection_None),
+      is_touch(false) {
+  // Set |is_touch| if |current_event| is not NULL. |current_event| may be NULL
+  // in unit tests that don't use synthetically generated events and test window
+  // resizers directly.
+  if (window->GetRootWindow()->current_event())

[sky, 2013/06/04 21:18:55]

I don't like grabbing the current event, it's too error prone. Please pass the
state in you need.

+    is_touch = window->GetRootWindow()->current_event()->IsGestureEvent();
   if (wm::IsWindowNormal(window) &&
       GetRestoreBoundsInScreen(window) &&
       window_component == HTCAPTION)
     restore_bounds = *GetRestoreBoundsInScreen(window);
 }
 
 WindowResizer::Details::~Details() {
 }
 
 WindowResizer::WindowResizer() {
@@ skipping 36 matching lines @@
   if (!details.is_resizable)
     return details.initial_bounds_in_parent;
 
   gfx::Point location = passed_location;
   gfx::Rect work_area =
       ScreenAsh::GetDisplayWorkAreaBoundsInParent(details.window);
 
   int delta_x = location.x() - details.initial_location_in_parent.x();
   int delta_y = location.y() - details.initial_location_in_parent.y();
 
+  // Adjust values of |delta_x| and |delta_y| for touch resizes.
+  AdjustDeltaForTouch(details, &delta_x, &delta_y);
+
   // The minimize size constraint may limit how much we change the window
   // position.  For example, dragging the left edge to the right should stop
   // repositioning the window when the minimize size is reached.
   gfx::Size size = GetSizeForDrag(details, &delta_x, &delta_y);
   gfx::Point origin = GetOriginForDrag(details, delta_x, delta_y);
   gfx::Rect new_bounds(origin, size);
 
   // Sizing has to keep the result on the screen. Note that this correction
   // has to come first since it might have an impact on the origin as well as
   // on the size.
@@ skipping 64 matching lines @@
                             new_bounds_in_screen.x())));
       new_bounds =
           ScreenAsh::ConvertRectFromScreen(parent, new_bounds_in_screen);
     }
   }
 
   return new_bounds;
 }
 
 // static
+void WindowResizer::AdjustDeltaForTouch(const Details& details,

[sky, 2013/06/04 21:18:55]

Is all of this to snap the edge to the edge of the screen? Do we only care about
workspace windows or all windows? It seems like we should be able to share some
of the code in WorkspaceWindowResizer that snaps resizes. Something like
MagneticallySnapResizeToOtherWindows but that snaps to the screen edges.

[mohsen, 2013/06/05 16:20:00]

This code is not for snapping. Its purpose is to move window border faster than
the finger (when necessary) so that the border catches up the finger at the edge
of the screen (see:
https://code.google.com/p/chromium/issues/detail?id=151168#c6). For the snapping
part, I have just increased the snapping distance (for touch-resizing) used by
existing snapping code.

[sky, 2013/06/07 19:26:30]

This seems disconcerting and while I get what Dana is suggesting I don't see the
point of it. Aren't the changes in worskpacewindowresize all that is necessary
to fix the bug? If you prefer, I can bring this discussion back to the bug, or
email Alex.

[sky, 2013/06/07 19:26:30]

Aren't the changes in WorkspaceWindowResize enough to fix this bug? I'm a bit
skeptical of slowly shifting the position as you drag, that seems a bit odd. In
particular I'm worried the slight shift as dragging is going to make it so it
feels as though the border is shifting under the finger. I'm happy to continue
this discussion in the bug or email Alex if you prefer.

[mohsen, 2013/06/07 20:06:57]

The change in WorkspaceWindowResizer increases snapping distance from 8 to 16
for touch. Even with this increase we should try hard to drag as close to the
window border as possible to move the border close enough to the edge to trigger
the snapping. That's where the slight shift helps a lot. Anyway, I'm fine with
either discussing under the bug or emailing Alex, whichever you think is more
appropriate.

+                                        int* delta_x,
+                                        int* delta_y) {
+  if (!details.is_touch || !(details.bounds_change & kBoundsChange_Resizes))
+    return;
+
+  if (details.size_change_direction & kBoundsChangeDirection_Horizontal) {
+    if (IsRightEdge(details.window_component) && *delta_x > 0) {
+      int display_width = Shell::GetScreen()->GetDisplayNearestWindow(
+          details.window).bounds().width();
+      int right = details.initial_bounds_in_parent.right();
+      float window_distance = display_width - right;
+      float touch_distance = display_width -
+          details.initial_location_in_parent.x();
+      *delta_x = static_cast<int>(
+          ceil(*delta_x * window_distance / touch_distance));
+    } else if (!IsRightEdge(details.window_component) && *delta_x < 0) {
+      float window_distance = details.initial_bounds_in_parent.x();
+      float touch_distance = details.initial_location_in_parent.x();
+      *delta_x = static_cast<int>(
+          floor(*delta_x * window_distance / touch_distance));
+    }
+  }
+  if (details.size_change_direction & kBoundsChangeDirection_Vertical) {
+    if (IsBottomEdge(details.window_component) && *delta_y > 0) {
+      int display_height = Shell::GetScreen()->GetDisplayNearestWindow(
+          details.window).bounds().height();
+      int bottom = details.initial_bounds_in_parent.bottom();
+      float window_distance = display_height - bottom;
+      float touch_distance = display_height -
+          details.initial_location_in_parent.y();
+      *delta_y = static_cast<int>(
+          ceil(*delta_y * window_distance / touch_distance));
+    } else if (!IsBottomEdge(details.window_component) && *delta_y < 0) {
+      float window_distance = details.initial_bounds_in_parent.y();
+      float touch_distance = details.initial_location_in_parent.y();
+      *delta_y = static_cast<int>(
+          floor(*delta_y * window_distance / touch_distance));
+    }
+  }
+}
+
+// static
 bool WindowResizer::IsBottomEdge(int window_component) {
   return window_component == HTBOTTOMLEFT ||
       window_component == HTBOTTOM ||
       window_component == HTBOTTOMRIGHT ||
       window_component == HTGROWBOX;
 }
 
 // static
 gfx::Point WindowResizer::GetOriginForDrag(const Details& details,
                                            int delta_x,
@@ skipping 85 matching lines @@
     if (height > max_height) {
       height = max_height;
       *delta_y = -y_multiplier * (details.initial_bounds_in_parent.height() -
                                   max_height);
     }
   }
   return height;
 }
 
 }  // namespace aura