Make touch-resizing windows to screen edge possible

ash/wm/workspace/workspace_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/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 18 matching lines @@
 #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/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace ash {
 
-scoped_ptr<WindowResizer> CreateWindowResizer(aura::Window* window,
-                                              const gfx::Point& point_in_parent,
-                                              int window_component) {
+scoped_ptr<WindowResizer> CreateWindowResizer(
+    aura::Window* window,
+    const gfx::Point& point_in_parent,
+    int window_component,
+    aura::client::WindowMoveSource source) {
   DCHECK(window);
   // No need to return a resizer when the window cannot get resized.
   if (!wm::CanResizeWindow(window) && window_component != HTCAPTION)
     return scoped_ptr<WindowResizer>();
 
   WindowResizer* window_resizer = NULL;
   if (window->parent() &&
       window->parent()->id() == internal::kShellWindowId_WorkspaceContainer) {
     // Allow dragging maximized windows if it's not tracked by workspace. This
     // is set by tab dragging code.
     if (!wm::IsWindowNormal(window) &&
         (window_component != HTCAPTION || GetTrackedByWorkspace(window)))
       return scoped_ptr<WindowResizer>();
     window_resizer = internal::WorkspaceWindowResizer::Create(
         window,
         point_in_parent,
         window_component,
+        source,
         std::vector<aura::Window*>());
   } else if (wm::IsWindowNormal(window)) {
     window_resizer = DefaultWindowResizer::Create(
-        window, point_in_parent, window_component);
+        window, point_in_parent, window_component, source);
   }
   if (window_resizer) {
     window_resizer = internal::DragWindowResizer::Create(
-        window_resizer, window, point_in_parent, window_component);
+        window_resizer, window, point_in_parent, window_component, source);
   }
   if (window_resizer && window->type() == aura::client::WINDOW_TYPE_PANEL) {
     window_resizer = PanelWindowResizer::Create(
-        window_resizer, window, point_in_parent, window_component);
+        window_resizer, window, point_in_parent, window_component, source);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
 // Distance in pixels that the cursor must move past an edge for a window
 // to move or resize beyond that edge.
 const int kStickyDistancePixels = 64;
 
+// Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
+// when resizing a window using touchscreen.
+const int kScreenEdgeInsetForTouchResize = 16;

[sky, 2013/06/14 15:57:27]

I thought we were going to make this 32?

[mohsen, 2013/06/14 16:21:48]

32 was for the case that we only wanted to use snapping. But now that we align
border immediately with touch, 16 is enough. But, we can change it to 32 if you
think that's better?

[sky, 2013/06/14 16:25:07]

I only mention it since I thought we agreed on 32 in the email thread. Maybe I'm
wrong?

[mohsen, 2013/06/14 18:17:17]

Well, I thought that was for when we only have snapping. Anyway, I changed it
back to 32.

+
 // Returns true if the window should stick to the edge.
 bool ShouldStickToEdge(int distance_from_edge, int sticky_size) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableStickyEdges)) {
     return distance_from_edge < 0 &&
            distance_from_edge > -sticky_size;
   }
   return distance_from_edge < sticky_size &&
                               distance_from_edge > -sticky_size * 2;
 }
@@ skipping 210 matching lines @@
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->UnlockCursor();
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location_in_parent,
     int window_component,
+    aura::client::WindowMoveSource source,
     const std::vector<aura::Window*>& attached_windows) {
-  Details details(window, location_in_parent, window_component);
+  Details details(window, location_in_parent, window_component, source);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
                                   int event_flags) {
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
   } else if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAshEnableStickyEdges)) {
     sticky_size = kStickyDistancePixels;
+  } else if ((details_.bounds_change & kBoundsChange_Resizes) &&
+      details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
+    sticky_size = kScreenEdgeInsetForTouchResize;

[sky, 2013/06/14 15:57:27]

Do you want this only effect snapping to screen bounds?

[mohsen, 2013/06/14 16:21:48]

The problem only happens for resizing to the screen edge. Snapping to other
windows works with the current configuration. Do you think we have better be
consistent in both cases?

[sky, 2013/06/14 16:25:07]

My point is that doing the change here effects *all* cases, not just the one you
care about. I don't necessarily know if this is a problem. I'm just pointing it
out. It seems reasonable to increase the size for everything during touch, which
matches what you're doing here. But I don't know how that feels in practice. I
raise the issue to make sure you understand the impact of your change.

[mohsen, 2013/06/14 18:17:17]

I think this sticy_size is only used for snapping to screen edges. The one used
for other windows is MagnetismMathcer::kMagneticDistance
(https://code.google.com/p/chromium/codesearch#chromium/src/ash/wm/workspace/m...)
used here:
https://code.google.com/p/chromium/codesearch#chromium/src/ash/wm/workspace/m....
Also my tests show that this only affects snapping to screen edge.

[sky, 2013/06/14 19:22:22]

Ah yes, you are right. Sorry about that.

   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
 
   if (wm::IsWindowNormal(window()))
     AdjustBoundsForMainWindow(sticky_size, &bounds);
 
   if (bounds != window()->bounds()) {
@@ skipping 505 matching lines @@
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window()));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash