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/shell_window_ids.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/base_layout_manager.h"
+#include "ash/wm/dock/dock_edge_types.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.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"
@@ skipping 18 matching lines @@
 typedef std::map<const aura::Window*, gfx::Rect> BoundsMap;
 
 // Adds an entry from |window| to its bounds and recursively invokes this for
 // all children.
 void BuildWindowBoundsMap(const aura::Window* window, BoundsMap* bounds_map) {
   (*bounds_map)[window] = window->bounds();
   for (size_t i = 0; i < window->children().size(); ++i)
     BuildWindowBoundsMap(window->children()[i], bounds_map);
 }
 
-// Resets |window|s bounds from |bounds_map| if currently empty. Recusively
+// Resets |window|s bounds from |bounds_map| if currently empty. Recursively
 // invokes this for all children.
 void ResetBoundsIfNecessary(const BoundsMap& bounds_map, aura::Window* window) {
   if (window->bounds().IsEmpty() && window->GetTargetBounds().IsEmpty()) {
     BoundsMap::const_iterator i = bounds_map.find(window);
     if (i != bounds_map.end())
       window->SetBounds(i->second);
   }
   for (size_t i = 0; i < window->children().size(); ++i)
     ResetBoundsIfNecessary(bounds_map, window->children()[i]);
 }
 
 // Resets |window|s bounds from |bounds_map| if |window| is marked as a
-// constrained window. Recusively invokes this for all children.
+// constrained window. Recursively invokes this for all children.
 // TODO(sky): this should key off window type.
 void ResetConstrainedWindowBoundsIfNecessary(const BoundsMap& bounds_map,
                                              aura::Window* window) {
   if (window->GetProperty(aura::client::kConstrainedWindowKey)) {
     BoundsMap::const_iterator i = bounds_map.find(window);
     if (i != bounds_map.end())
       window->SetBounds(i->second);
   }
   for (size_t i = 0; i < window->children().size(); ++i)
     ResetConstrainedWindowBoundsIfNecessary(bounds_map, window->children()[i]);
@@ skipping 15 matching lines @@
   if (root_window_) {
     root_window_->RemoveObserver(this);
     root_window_->RemoveRootWindowObserver(this);
   }
   for (WindowSet::const_iterator i = windows_.begin(); i != windows_.end(); ++i)
     (*i)->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(Window* child) {
+  LOG(INFO) << this << " OnWindowAddedToLayout " << child;
   // Adjust window bounds in case that the new child is out of the workspace.
   AdjustWindowSizeForScreenChange(child, ADJUST_WINDOW_WINDOW_ADDED);
 
   windows_.insert(child);
   child->AddObserver(this);
 
   // Only update the bounds if the window has a show state that depends on the
   // workspace area.
   if (wm::IsWindowMaximized(child) || wm::IsWindowFullscreen(child))
     UpdateBoundsFromShowState(child);
 
   workspace_manager()->OnWindowAddedToWorkspace(workspace_, child);
 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(Window* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
   workspace_manager()->OnWillRemoveWindowFromWorkspace(workspace_, child);
 }
 
 void WorkspaceLayoutManager::OnWindowRemovedFromLayout(Window* child) {
+  LOG(INFO) << this << " OnWindowRemovedFromLayout " << child;
   workspace_manager()->OnWindowRemovedFromWorkspace(workspace_, child);
 }
 
 void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(Window* child,
                                                             bool visible) {
   if (visible && wm::IsWindowMinimized(child)) {
     // Attempting to show a minimized window. Unminimize it.
     child->SetProperty(aura::client::kShowStateKey,
                        child->GetProperty(aura::client::kRestoreShowStateKey));
     child->ClearProperty(aura::client::kRestoreShowStateKey);
@@ skipping 103 matching lines @@
     workspace_manager()->OnTrackedByWorkspaceChanged(workspace_, window);
   }
 
   if (key == aura::client::kAlwaysOnTopKey &&
       window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     internal::AlwaysOnTopController* controller =
         window->GetRootWindow()->GetProperty(
             internal::kAlwaysOnTopControllerKey);
     controller->GetContainer(window)->AddChild(window);
   }
+
+  if (key == ash::internal::kDockEdges &&
+      GetDockEdges(window) != static_cast<int>(old)) {
+    LOG(INFO) << "Stuck property changed to " << GetDockEdges(window);
+    aura::Window* dock_container = ash::Shell::GetContainer(
+        root_window_,
+        ash::internal::kShellWindowId_DockContainer);
+    DCHECK(dock_container);
+    int edges = GetDockEdges(window) & (DOCK_EDGE_RIGHT | DOCK_EDGE_LEFT);
+    if (edges &&
+        0 == (static_cast<int>(old) & (DOCK_EDGE_RIGHT | DOCK_EDGE_LEFT))) {
+      LOG(INFO) << "adding " << window << " to dock " << dock_container;
+      dock_container->AddChild(window);
+    }
+  }
 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
   }
 }
 
 void WorkspaceLayoutManager::ShowStateChanged(
@@ skipping 132 matching lines @@
   }
   return false;
 }
 
 WorkspaceManager* WorkspaceLayoutManager::workspace_manager() {
   return workspace_->workspace_manager();
 }
 
 }  // namespace internal
 }  // namespace ash