Stick windows to sides of workspaces

ash/wm/workspace/workspace_layout_manager.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_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/screen_ash.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/base_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace/stuck_edge_types.h"
 #include "ash/wm/workspace/workspace.h"
 #include "ash/wm/workspace/workspace_manager.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/events/event.h"
@@ skipping 282 matching lines @@
 void WorkspaceLayoutManager::AdjustWindowSizeForScreenChange(
     Window* window,
     AdjustWindowReason reason) {
   if (GetTrackedByWorkspace(window) &&
       !SetMaximizedOrFullscreenBounds(window)) {
     if (reason == ADJUST_WINDOW_SCREEN_SIZE_CHANGED) {
       // The work area may be smaller than the full screen.  Put as much of the
       // window as possible within the display area.
       gfx::Rect bounds = window->bounds();
       bounds.AdjustToFit(work_area_);
+      bounds = AdjustWindowBoundsForStuckEdges(window, bounds);
       window->SetBounds(bounds);
     } else if (reason == ADJUST_WINDOW_DISPLAY_INSETS_CHANGED) {
       gfx::Rect bounds = window->bounds();
       ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_, &bounds);
+      bounds = AdjustWindowBoundsForStuckEdges(window, bounds);
       if (window->bounds() != bounds)
         window->SetBounds(bounds);
     } else if (reason == ADJUST_WINDOW_WINDOW_ADDED) {
       gfx::Rect bounds = window->bounds();
       int min_width = bounds.width() * kMinimumPercentOnScreenArea;
       int min_height = bounds.height() * kMinimumPercentOnScreenArea;
       ash::wm::AdjustBoundsToEnsureWindowVisibility(
           work_area_, min_width, min_height, &bounds);
       if (window->bounds() != bounds)
         window->SetBounds(bounds);
     }
   }
 }
 
 void WorkspaceLayoutManager::UpdateBoundsFromShowState(Window* window) {
   // See comment in SetMaximizedOrFullscreenBounds() as to why we use parent in
   // these calculation.
+  int stuck_edges_mask = GetStuckToEdge(window);
   switch (window->GetProperty(aura::client::kShowStateKey)) {
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_NORMAL: {
       const gfx::Rect* restore = GetRestoreBoundsInScreen(window);
       if (restore) {
         gfx::Rect bounds_in_parent =
             ScreenAsh::ConvertRectFromScreen(window->parent()->parent(),
                                              *restore);
         SetChildBoundsDirect(
             window,
             BaseLayoutManager::BoundsWithScreenEdgeVisible(
                 window->parent()->parent(),
                 bounds_in_parent));
+
+        // getting unstuck
+        stuck_edges_mask = STUCK_EDGE_NONE;
       }
       ClearRestoreBounds(window);
       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED:
     case ui::SHOW_STATE_FULLSCREEN:
       SetMaximizedOrFullscreenBounds(window);
+      stuck_edges_mask = STUCK_EDGE_NONE;
       break;
 
     default:
       break;
   }
+  if (GetStuckToEdge(window) != stuck_edges_mask &&
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableDockedWindows))
+    SetStuckToEdge(window, stuck_edges_mask);
 }
 
 bool WorkspaceLayoutManager::SetMaximizedOrFullscreenBounds(
     aura::Window* window) {
   if (!GetTrackedByWorkspace(window))
     return false;
 
   // During animations there is a transform installed on the workspace
   // windows. For this reason this code uses the parent so that the transform is
   // ignored.
   if (wm::IsWindowMaximized(window)) {
     SetChildBoundsDirect(
         window, ScreenAsh::GetMaximizedWindowBoundsInParent(
             window->parent()->parent()));
     return true;
   }
   if (wm::IsWindowFullscreen(window)) {
     SetChildBoundsDirect(
         window,
         ScreenAsh::GetDisplayBoundsInParent(window->parent()->parent()));
     return true;
   }
   return false;
 }
 
+gfx::Rect WorkspaceLayoutManager::AdjustWindowBoundsForStuckEdges(
+    aura::Window* window,
+    const gfx::Rect& bounds) {

[flackr, 2013/05/22 02:00:56]

We should do all docked window specific layout changes in a new layout manager
(call it docked_layout_manager). This layout manager would be similar to
panel_layout_manager except that it would only affect docked windows.

However, it seems like the change you're making is more general than docked
windows. You're keeping windows on the edge they were placed on. If this was
desirable it could belong here, I just think we should get approval for such a
feature before landing it. This is tangential to being able to dock windows
though.

+  gfx::Rect new_bounds(bounds);
+  if ((GetStuckToEdge(window) & STUCK_EDGE_LEFT) &&
+      bounds.x() != work_area_.x())
+    new_bounds.set_x(work_area_.x());
+  if ((GetStuckToEdge(window) & STUCK_EDGE_RIGHT) &&
+      new_bounds.right() != work_area_.right()) {
+    if (GetStuckToEdge(window) & STUCK_EDGE_LEFT)
+      new_bounds.set_width(work_area_.right() - new_bounds.x());
+    else
+      new_bounds.set_x(work_area_.right() - bounds.width());
+  }
+  if ((GetStuckToEdge(window) & STUCK_EDGE_TOP) && bounds.y() != work_area_.y())
+    new_bounds.set_y(work_area_.y());
+  if ((GetStuckToEdge(window) & STUCK_EDGE_BOTTOM) &&
+      new_bounds.bottom() != work_area_.bottom()) {
+    if (GetStuckToEdge(window) & STUCK_EDGE_TOP)
+      new_bounds.set_height(work_area_.bottom() - new_bounds.y());
+    else
+      new_bounds.set_y(work_area_.bottom() - bounds.height());
+  }
+  return new_bounds;
+}
+
 WorkspaceManager* WorkspaceLayoutManager::workspace_manager() {
   return workspace_->workspace_manager();
 }
 
 }  // namespace internal
 }  // namespace ash