Add ash-enable-sticky-edges for 'sticky' instead of 'snap' behavior.

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 56 matching lines @@
     window_resizer = PanelWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
-// Duration of the animation when snapping the window into place.
-const int kSnapDurationMS = 100;
-
-// Returns true if should snap to the edge.
-bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
-  return distance_from_edge < grid_size &&
-      distance_from_edge > -grid_size * 2;
-}
-
-// Returns the coordinate along the secondary axis to snap to.
+// Returns the coordinate along the secondary axis to stick to.
 int CoordinateAlongSecondaryAxis(SecondaryMagnetismEdge edge,
                                  int leading,
                                  int trailing,
                                  int none) {
   switch (edge) {
     case SECONDARY_MAGNETISM_EDGE_LEADING:
       return leading;
     case SECONDARY_MAGNETISM_EDGE_TRAILING:
       return trailing;
     case SECONDARY_MAGNETISM_EDGE_NONE:
@@ skipping 83 matching lines @@
         x = attach_origin.x();
         w = src.right() - x;
       } else if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_TRAILING) {
         w += attach_origin.x() - src.x();
       }
       break;
   }
   return gfx::Rect(x, y, w, h);
 }
 
-// Converts a window comopnent edge to the magnetic edge to snap to.
+// Converts a window comopnent edge to the magnetic edge to stick to.

[flackr, 2013/04/16 00:32:14]

nit: s/comopnent/component

[stevenjb, 2013/04/16 20:08:20]

Done.

 uint32 WindowComponentToMagneticEdge(int window_component) {
   switch (window_component) {
     case HTTOPLEFT:
       return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_TOP;
     case HTTOPRIGHT:
       return MAGNETISM_EDGE_TOP | MAGNETISM_EDGE_RIGHT;
     case HTBOTTOMLEFT:
       return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_BOTTOM;
     case HTBOTTOMRIGHT:
       return MAGNETISM_EDGE_RIGHT | MAGNETISM_EDGE_BOTTOM;
@@ skipping 104 matching lines @@
     const std::vector<aura::Window*>& attached_windows) {
   Details details(window, location_in_parent, window_component);
   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;
 
-  const int snap_size =
-      event_flags & ui::EF_CONTROL_DOWN ? 0 : kScreenEdgeInset;
+  const bool is_sticky = !(event_flags & ui::EF_CONTROL_DOWN);
+
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
 
   if (wm::IsWindowNormal(window()))
-    AdjustBoundsForMainWindow(snap_size, &bounds);
+    AdjustBoundsForMainWindow(is_sticky, &bounds);
 
   if (bounds != window()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details_.restore_bounds.IsEmpty())
         ClearRestoreBounds(window());
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
@@ skipping 257 matching lines @@
   for (size_t i = 0; i < attached_windows_.size(); i++) {
     int initial_size = initial_size_[i];
     aura::WindowDelegate* delegate = attached_windows_[i]->delegate();
     int min = PrimaryAxisSize(delegate->GetMinimumSize());
     int max = PrimaryAxisSize(delegate->GetMaximumSize());
 
     sizes->push_back(WindowSize(initial_size, min, max));
   }
 }
 
-void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
+void WorkspaceWindowResizer::MagneticallyStickToOtherWindows(
+    gfx::Rect* bounds) {
   if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
     bounds->set_origin(
         OriginForMagneticAttach(*bounds, magnetism_window_->bounds(),
                                 magnetism_edge_));
   }
 }
 
-void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
+void WorkspaceWindowResizer::MagneticallyStickResizeToOtherWindows(
     gfx::Rect* bounds) {
   const uint32 edges = WindowComponentToMagneticEdge(details_.window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
     *bounds = BoundsForMagneticResizeAttach(
           *bounds, magnetism_window_->bounds(), magnetism_edge_);
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
                                                     uint32 edges) {
   MagnetismMatcher matcher(bounds, edges);
 
-  // If we snapped to a window then check it first. That way we don't bounce
+  // If we stuck to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
     if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->bounds(), &magnetism_edge_)) {
       return true;
     }
     window_tracker_.Remove(magnetism_window_);
     magnetism_window_ = NULL;
   }
 
   aura::Window* parent = window()->parent();
   const aura::Window::Windows& windows(parent->children());
   for (aura::Window::Windows::const_reverse_iterator i = windows.rbegin();
        i != windows.rend() && !matcher.AreEdgesObscured(); ++i) {
     aura::Window* other = *i;
     if (other == window() || !other->IsVisible())
       continue;
     if (matcher.ShouldAttach(other->bounds(), &magnetism_edge_)) {
       magnetism_window_ = other;
       window_tracker_.Add(magnetism_window_);
       return true;
     }
   }
   return false;
 }
 
-void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
-    int snap_size,
-    gfx::Rect* bounds) {
+void WorkspaceWindowResizer::AdjustBoundsForMainWindow(bool is_sticky,
+                                                       gfx::Rect* bounds) {
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
   wm::ConvertPointToScreen(window()->parent(), &last_mouse_location_in_screen);
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(
       last_mouse_location_in_screen);
   gfx::Rect work_area =
       ScreenAsh::ConvertRectFromScreen(window()->parent(), display.work_area());
   if (details_.window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight on the bottom.
     int max_y = work_area.bottom() - kMinOnscreenHeight;
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
       // cursor reaches the work area above if any.
       bounds->set_y(work_area.y());
     }
 
-    if (snap_size > 0) {
-      SnapToWorkAreaEdges(work_area, snap_size, bounds);
-      MagneticallySnapToOtherWindows(bounds);
+    if (is_sticky) {
+      StickToWorkAreaEdges(work_area, bounds);
+      MagneticallyStickToOtherWindows(bounds);
     }
-  } else if (snap_size > 0) {
-    MagneticallySnapResizeToOtherWindows(bounds);
-    if (!magnetism_window_ && snap_size > 0)
-      SnapResizeToWorkAreaBounds(work_area, snap_size, bounds);
+  } else if (is_sticky) {
+    MagneticallyStickResizeToOtherWindows(bounds);
+    if (!magnetism_window_)
+      StickyResizeToWorkAreaBounds(work_area, bounds);
   }
 
   if (attached_windows_.empty())
     return;
 
   if (details_.window_component == HTRIGHT) {
     bounds->set_width(std::min(bounds->width(),
                                work_area.right() - total_min_ - bounds->x()));
   } else {
     DCHECK_EQ(HTBOTTOM, details_.window_component);
     bounds->set_height(std::min(bounds->height(),
                                 work_area.bottom() - total_min_ - bounds->y()));
   }
 }
 
-void WorkspaceWindowResizer::SnapToWorkAreaEdges(
+void WorkspaceWindowResizer::StickToWorkAreaEdges(
     const gfx::Rect& work_area,
-    int snap_size,
     gfx::Rect* bounds) const {
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
-  if (ShouldSnapToEdge(bounds->x() - left_edge, snap_size)) {
+  if (wm::ShouldStickToEdge(bounds->x() - left_edge)) {
     bounds->set_x(left_edge);
-  } else if (ShouldSnapToEdge(right_edge - bounds->right(),
-                              snap_size)) {
+  } else if (wm::ShouldStickToEdge(right_edge - bounds->right())) {
     bounds->set_x(right_edge - bounds->width());
   }
-  if (ShouldSnapToEdge(bounds->y() - top_edge, snap_size)) {
+  if (wm::ShouldStickToEdge(bounds->y() - top_edge)) {
     bounds->set_y(top_edge);
-  } else if (ShouldSnapToEdge(bottom_edge - bounds->bottom(), snap_size) &&
+  } else if (wm::ShouldStickToEdge(bottom_edge - bounds->bottom()) &&
              bounds->height() < (bottom_edge - top_edge)) {
     // Only snap to the bottom if the window is smaller than the work area.
     // Doing otherwise can lead to window snapping in weird ways as it bounces
     // between snapping to top then bottom.
     bounds->set_y(bottom_edge - bounds->height());
   }
 }
 
-void WorkspaceWindowResizer::SnapResizeToWorkAreaBounds(
+void WorkspaceWindowResizer::StickyResizeToWorkAreaBounds(
     const gfx::Rect& work_area,
-    int snap_size,
     gfx::Rect* bounds) const {
   const uint32 edges = WindowComponentToMagneticEdge(details_.window_component);
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
   if (edges & MAGNETISM_EDGE_TOP &&
-      ShouldSnapToEdge(bounds->y() - top_edge, snap_size)) {
+      wm::ShouldStickToEdge(bounds->y() - top_edge)) {
     bounds->set_height(bounds->bottom() - top_edge);
     bounds->set_y(top_edge);
   }
   if (edges & MAGNETISM_EDGE_LEFT &&
-      ShouldSnapToEdge(bounds->x() - left_edge, snap_size)) {
+      wm::ShouldStickToEdge(bounds->x() - left_edge)) {
     bounds->set_width(bounds->right() - left_edge);
     bounds->set_x(left_edge);
   }
   if (edges & MAGNETISM_EDGE_BOTTOM &&
-      ShouldSnapToEdge(bottom_edge - bounds->bottom(), snap_size)) {
+      wm::ShouldStickToEdge(bottom_edge - bounds->bottom())) {
     bounds->set_height(bottom_edge - bounds->y());
   }
   if (edges & MAGNETISM_EDGE_RIGHT &&
-      ShouldSnapToEdge(right_edge - bounds->right(), snap_size)) {
+      wm::ShouldStickToEdge(right_edge - bounds->right())) {
     bounds->set_width(right_edge - bounds->x());
   }
 }
 
 int WorkspaceWindowResizer::PrimaryAxisSize(const gfx::Size& size) const {
   return PrimaryAxisCoordinate(size.width(), size.height());
 }
 
 int WorkspaceWindowResizer::PrimaryAxisCoordinate(int x, int y) const {
   switch (details_.window_component) {
@@ skipping 79 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