Stick windows to sides of workspaces

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>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/default_window_resizer.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
+#include "ash/wm/workspace/stuck_edge_types.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_types.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/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
@@ skipping 325 matching lines @@
   if (bounds != window()->bounds())
     window()->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  // When the window is not in the normal show state, we do not snap thw window.
+  // When the window is not in the normal show state, we do not snap the window.
   // This happens when the user minimizes or maximizes the window by keyboard
   // shortcut while dragging it. If the window is the result of dragging a tab
   // out of a maximized window, it's already in the normal show state when this
   // is called, so it does not matter.
   if (wm::IsWindowNormal(window()) &&
       (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
        !window()->GetProperty(kPanelAttachedKey)) &&
       (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
     if (!GetRestoreBoundsInScreen(window())) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
           window()->parent(), details_.initial_bounds_in_parent);
       SetRestoreBoundsInScreen(window(), details_.restore_bounds.IsEmpty() ?
                                initial_bounds :
                                details_.restore_bounds);
     }
-    window()->SetBounds(snap_sizer_->target_bounds());
+    gfx::Rect bounds = snap_sizer_->target_bounds();
+    window()->SetBounds(bounds);
+
+    gfx::Rect bounds_in_parent = ScreenAsh::ConvertRectToScreen(
+        window()->parent(),
+        ScreenAsh::GetMaximizedWindowBoundsInParent(window()));
+    int stuck_edges_mask =
+        internal::WorkspaceWindowResizer::CalculateStuckEdges(
+            bounds, bounds_in_parent);
+    if (GetStuckToEdge(window()) != stuck_edges_mask &&
+        CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kAshEnableDockedWindows))
+      SetStuckToEdge(window(), stuck_edges_mask);
     return;
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
@@ skipping 320 matching lines @@
   }
   if (ShouldStickToEdge(bounds->y() - top_edge, sticky_size)) {
     bounds->set_y(top_edge);
   } else if (ShouldStickToEdge(bottom_edge - bounds->bottom(), sticky_size) &&
              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());
   }
+  int stuck_edges_mask = CalculateStuckEdges(*bounds, work_area);
+  if (GetStuckToEdge(window()) != stuck_edges_mask &&
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableDockedWindows))
+    SetStuckToEdge(window(), stuck_edges_mask);
 }
 
 void WorkspaceWindowResizer::StickToWorkAreaOnResize(
     const gfx::Rect& work_area,
     int sticky_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();
@@ skipping 11 matching lines @@
   if (edges & MAGNETISM_EDGE_BOTTOM &&
       ShouldStickToEdge(bottom_edge - bounds->bottom(), sticky_size)) {
     bounds->set_height(bottom_edge - bounds->y());
   }
   if (edges & MAGNETISM_EDGE_RIGHT &&
       ShouldStickToEdge(right_edge - bounds->right(), sticky_size)) {
     bounds->set_width(right_edge - bounds->x());
   }
 }
 
+int WorkspaceWindowResizer::CalculateStuckEdges(
+    const gfx::Rect& bounds,
+    const gfx::Rect& work_area) {
+  int stuck_edges_mask = STUCK_EDGE_NONE;
+  if (bounds.x() == work_area.x())
+    stuck_edges_mask |= STUCK_EDGE_LEFT;
+  if (bounds.right() == work_area.right())
+    stuck_edges_mask |= STUCK_EDGE_RIGHT;
+  if (bounds.y() == work_area.y())
+    stuck_edges_mask |= STUCK_EDGE_TOP;
+  if (bounds.bottom() == work_area.bottom())
+    stuck_edges_mask |= STUCK_EDGE_BOTTOM;
+  return stuck_edges_mask;
+}
+
 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) {
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
@@ skipping 75 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