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"
@@ skipping 133 matching lines @@
   // Some windows rely on this to set their initial bounds.
   if (!SetMaximizedOrFullscreenBounds(child)) {
     // Non-maximized/full-screen windows have their size constrained to the
     // work-area.
     child_bounds.set_width(std::min(work_area_.width(), child_bounds.width()));
     child_bounds.set_height(
         std::min(work_area_.height(), child_bounds.height()));
     SetChildBoundsDirect(child, child_bounds);
   }
   workspace_manager()->OnWorkspaceWindowChildBoundsChanged(workspace_, child);
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshEnableGutter)) {
+    if (child->type() == aura::client::WINDOW_TYPE_NORMAL &&
+        wm::CanResizeWindow(child)) {
+      int stuck_edges_mask = CalculateStuckEdges(child);
+      if (GetStuckToEdge(child) != stuck_edges_mask)
+        SetStuckToEdge(child, stuck_edges_mask);
+    }
+  }
 }
 
 void WorkspaceLayoutManager::OnRootWindowResized(const aura::RootWindow* root,
                                                  const gfx::Size& old_size) {
   AdjustWindowSizesForScreenChange(ADJUST_WINDOW_SCREEN_SIZE_CHANGED);
 }
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   if (workspace_manager()->active_workspace_ == workspace_) {
     const gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
@@ skipping 144 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 = EDGE_NONE;
   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));
       }
       ClearRestoreBounds(window);
+      stuck_edges_mask = CalculateStuckEdges(window);

[flackr, 2013/05/01 17:34:04]

We probably only want to "stick" windows when they're being moved in
workspace_window_resizer.cc. Doing so for all bounds updates would allow for
confusing behaviors like a restored window creating a gutter or creating a
gutter after a resize.

[varkha, 2013/05/18 03:06:37]

Done.

       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED:
     case ui::SHOW_STATE_FULLSCREEN:
       SetMaximizedOrFullscreenBounds(window);
+      stuck_edges_mask = EDGE_ALL;
       break;
 
     default:
       break;
   }
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshEnableGutter))
+    if (window->type() == aura::client::WINDOW_TYPE_NORMAL &&
+        wm::CanResizeWindow(window))
+      if (GetStuckToEdge(window) != stuck_edges_mask)
+        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;
 }
 
+int WorkspaceLayoutManager::CalculateStuckEdges(aura::Window* window) {
+  int stuck_edges_mask = EDGE_NONE;
+  if (window->bounds().x() == work_area_.x())
+    stuck_edges_mask |= EDGE_LEFT;
+  if (window->bounds().right() == work_area_.right())
+    stuck_edges_mask |= EDGE_RIGHT;
+  if (window->bounds().y() == work_area_.y())
+    stuck_edges_mask |= EDGE_TOP;
+  if (window->bounds().bottom() == work_area_.bottom())
+    stuck_edges_mask |= EDGE_BOTTOM;
+  return stuck_edges_mask;
+}
+
+gfx::Rect WorkspaceLayoutManager::AdjustWindowBoundsForStuckEdges(
+    aura::Window* window,
+    const gfx::Rect& bounds) {
+  gfx::Rect adjusted_bounds(bounds);
+  if ((0 != (GetStuckToEdge(window) & EDGE_RIGHT) &&

[flackr, 2013/05/01 17:34:04]

why the 0 !=? This should be fine as just if ((GetStuckToEdge(window) &
EDGE_RIGHT) && ...

[varkha, 2013/05/18 03:06:37]

Done.

+      bounds.right() != work_area_.right()) ||

[flackr, 2013/05/01 17:34:04]

These seem like they should be handled separately as they don't share much code.
i.e. rather than
if (A || B) {
  if (A) {

  } else { // B

}
just:
if (A) {

} else if (B) {

}

[varkha, 2013/05/18 03:06:37]

Done.

+      (0 != (GetStuckToEdge(window) & EDGE_LEFT) &&
+      bounds.x() != work_area_.x())) {
+    if (0 != (GetStuckToEdge(window) & EDGE_LEFT)) {
+      adjusted_bounds.set_x(work_area_.x());
+      adjusted_bounds.set_width(work_area_.width());
+    } else {
+      adjusted_bounds.set_x(work_area_.width() - bounds.width());
+    }
+  } else {

[flackr, 2013/05/01 17:34:04]

} else if (X) {
  ..
}
instead of:
} else {
  if (X) {
    ..
  }
}

[varkha, 2013/05/18 03:06:37]

The code got broken when I was chasing launcher auto-hide. Simplified.

+    if (0 != (GetStuckToEdge(window) & EDGE_LEFT) &&
+        bounds.x() != work_area_.x())

[flackr, 2013/05/01 17:34:04]

This seems the same as the case above.

[varkha, 2013/05/18 03:06:37]

Done.

+      adjusted_bounds.set_x(work_area_.x());
+  }
+  if ((0 != (GetStuckToEdge(window) & EDGE_BOTTOM) &&
+      bounds.bottom() != work_area_.bottom()) ||
+      (0 != (GetStuckToEdge(window) & EDGE_TOP) &&
+      bounds.y() != work_area_.y())) {
+    if (0 != (GetStuckToEdge(window) & EDGE_TOP)) {
+      adjusted_bounds.set_y(work_area_.y());
+      adjusted_bounds.set_height(work_area_.height());
+    } else {
+      adjusted_bounds.set_y(work_area_.height() - bounds.height());
+    }
+  } else {
+    if (0 != (GetStuckToEdge(window) & EDGE_TOP) &&
+        bounds.y() != work_area_.y())
+      adjusted_bounds.set_y(work_area_.y());
+  }

[flackr, 2013/05/01 17:34:04]

I don't think we'll support sticking to the bottom or top for now.

[varkha, 2013/05/18 03:06:37]

The top and bottom are useful when launcher auto-hide changes. This way a window
that is right- or left-maximized maintains its docked state nicely through
transitions.

+  return adjusted_bounds;
+}
+
 WorkspaceManager* WorkspaceLayoutManager::workspace_manager() {
   return workspace_->workspace_manager();
 }
 
 }  // namespace internal
 }  // namespace ash