Implement automatic layout and stacking for docked windows

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
@@ skipping 11 matching lines @@
 #include "ui/aura/window.h"
 #include "ui/gfx/rect.h"
 
 namespace ash {
 namespace internal {
 
 // Minimum, maximum width of the dock area and a width of the gap
 const int DockedWindowLayoutManager::kMinDockWidth = 200;
 const int DockedWindowLayoutManager::kMaxDockWidth = 450;
 const int DockedWindowLayoutManager::kMinDockGap = 2;
+const int kWindowIdealSpacing = 4;
 
 namespace {
 
 DockedWindowLayoutManager* GetDockLayoutManager(aura::Window* window,
                                                 const gfx::Point& location) {
   gfx::Rect near_location(location, gfx::Size());
   aura::Window* dock = Shell::GetContainer(
       wm::GetRootWindowMatching(near_location),
       kShellWindowId_DockedContainer);
   return static_cast<internal::DockedWindowLayoutManager*>(
       dock->layout_manager());
 }
 
 // Certain windows (minimized, hidden or popups) do not matter to docking.
 bool IsUsedByLayout(aura::Window* window) {
   return (window->IsVisible() &&
           !wm::IsWindowMinimized(window) &&
           window->type() != aura::client::WINDOW_TYPE_POPUP);
 }
 
+bool CompareWindowPos(const aura::Window* win1, const aura::Window* win2) {
+  return win1->GetTargetBounds().CenterPoint().y() <
+      win2->GetTargetBounds().CenterPoint().y();
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockLayoutManager public implementation:
 DockedWindowLayoutManager::DockedWindowLayoutManager(
     aura::Window* dock_container)
     : dock_container_(dock_container),
       in_layout_(false),
       dragged_window_(NULL),
       launcher_(NULL),
       shelf_layout_manager_(NULL),
       shelf_hidden_(false),
       docked_width_(0),
-      alignment_(DOCKED_ALIGNMENT_NONE) {
+      alignment_(DOCKED_ALIGNMENT_NONE),
+      last_active_window_(NULL) {
   DCHECK(dock_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
 
@@ skipping 21 matching lines @@
 }
 
 void DockedWindowLayoutManager::StartDragging(aura::Window* window) {
   if (window->parent() != dock_container_)
     return;
   DCHECK(!dragged_window_);
   dragged_window_ = window;
   Relayout();
 }
 
 void DockedWindowLayoutManager::FinishDragging() {

[flackr, 2013/07/19 17:53:32]

I think you need to observe OnWindowDestroying or OnWindowDestroyed for if
dragged_window_ is destroyed during a drag. Since it's being dragged (and may
even be in a different parent) you could still have a pointer to a deleted
window if it was destroyed mid drag (i.e. by the app / window.close()).

[varkha, 2013/07/20 01:26:25]

True (tested). Panels layout doesn't have this trouble because
OnWindowRemovedFromLayout is still called (because dragged_window_ can only be a
parent of panel container). Is there anything else that you can think of that
may be broken now that dragged_window_ is allowed to be not a child of
docked_container?

[flackr, 2013/07/22 21:19:49]

Can't think of anything else, just making sure to track the window being
destroyed, or make sure FinishDragging gets called before it is (which might
already be the case).

   if (!dragged_window_)
     return;
 
   // If this is the first window getting docked - update alignment.
   if (alignment_ == DOCKED_ALIGNMENT_NONE) {
     alignment_ = AlignmentOfWindow(dragged_window_);
   } else {
     // There were some docked windows before. Check if the |dragged_window_|
     // was the only one remaining and if so possibly switch alignment to
     // opposite side. Ignore popups.
     bool found_docked_window = false;
     for (size_t i = 0; i < dock_container_->children().size(); ++i) {
       aura::Window* window(dock_container_->children()[i]);
       if (window != dragged_window_ &&
           window->type() != aura::client::WINDOW_TYPE_POPUP) {
         found_docked_window = true;
         break;
       }
     }
     if (!found_docked_window)
       alignment_ = AlignmentOfWindow(dragged_window_);
   }
-  dragged_window_ = NULL;
+
+  // We no longer need to observe |dragged_window_| unless it is added back;
+  if (dragged_window_) {
+    if (dragged_window_->parent() != dock_container_)
+      dragged_window_->RemoveObserver(this);
+    dragged_window_ = NULL;
+  }
 
   Relayout();
   UpdateDockBounds();
 }
 
 // static
 bool DockedWindowLayoutManager::ShouldWindowDock(aura::Window* window,
                                                  const gfx::Point& location) {
   DockedWindowLayoutManager* layout_manager = GetDockLayoutManager(window,
                                                                    location);
@@ skipping 78 matching lines @@
   UpdateDockBounds();
 }
 
 void DockedWindowLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   if (child->type() == aura::client::WINDOW_TYPE_POPUP)
     return;
 
   // If this is the first window getting docked - update alignment.
   if (alignment_ == DOCKED_ALIGNMENT_NONE)
     alignment_ = AlignmentOfWindow(child);
-  child->AddObserver(this);
+  // We need to observe a child unless it is a |dragged_window_| that just got
+  // added back in which case we are already observing it.
+  if (child != dragged_window_)
+    child->AddObserver(this);
   Relayout();
   UpdateDockBounds();
 }
 
 void DockedWindowLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
   if (child->type() == aura::client::WINDOW_TYPE_POPUP)
     return;
 
   // Try to find a child that is not a popup and is not being dragged.
   bool found_docked_window = false;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* window(dock_container_->children()[i]);
     if (window != dragged_window_ &&
         window->type() != aura::client::WINDOW_TYPE_POPUP) {
       found_docked_window = true;
       break;
     }
   }
   if (!found_docked_window)
     alignment_ = DOCKED_ALIGNMENT_NONE;
 
-  child->RemoveObserver(this);
+  // Keep track of former children if they are dragged as they can be reparented
+  // temporarily just for the drag.
+  if (child != dragged_window_)
+    child->RemoveObserver(this);
+
+  if (last_active_window_ == child)
+    last_active_window_ = NULL;
+
   // Close the dock and expand workspace work area.
   Relayout();
 
   // When a panel is removed from this layout manager it may still be dragged.
   // Delay updating dock and workspace bounds until the drag is completed. This
   // preserves the docked area width until the panel drag is finished.
   if (child->type() != aura::client::WINDOW_TYPE_PANEL)
     UpdateDockBounds();
 }
 
@@ skipping 57 matching lines @@
   // The window property will still be set, but no actual change will occur
   // until WillChangeVisibilityState is called when the shelf is visible again
   if (shelf_hidden_)
     return;
   if (wm::IsWindowMinimized(window))
     MinimizeWindow(window);
   else
     RestoreWindow(window);
 }
 
+void DockedWindowLayoutManager::OnWindowBoundsChanged(
+    aura::Window* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
+  if (window == dragged_window_)
+    Relayout();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DockLayoutManager, aura::client::ActivationChangeObserver implementation:
 
 void DockedWindowLayoutManager::OnWindowActivated(aura::Window* gained_active,
                                                   aura::Window* lost_active) {
   // Ignore if the window that is not managed by this was activated.
   aura::Window* ancestor = NULL;
   for (aura::Window* parent = gained_active;
        parent; parent = parent->parent()) {
     if (parent->parent() == dock_container_) {
@@ skipping 62 matching lines @@
   return DOCKED_ALIGNMENT_NONE;
 }
 
 void DockedWindowLayoutManager::Relayout() {
   if (in_layout_ || alignment_ == DOCKED_ALIGNMENT_NONE)
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   gfx::Rect dock_bounds = dock_container_->bounds();
   aura::Window* active_window = NULL;
+  aura::Window::Windows visible_windows;
   docked_width_ = 0;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* window(dock_container_->children()[i]);
 
     if (!IsUsedByLayout(window))
       continue;
 
     // If the shelf is currently hidden (full-screen mode), hide window until
     // full-screen mode is exited.
     if (shelf_hidden_) {
       // The call to Hide does not set the minimize property, so the window will
       // be restored when the shelf becomes visible again.
       window->Hide();
       continue;
     }
-
     if (window->HasFocus() ||
         window->Contains(
             aura::client::GetFocusClient(window)->GetFocusedWindow())) {
       DCHECK(!active_window);
       active_window = window;
     }
+    visible_windows.push_back(window);
+  }
 
-    // all docked windows other than the one currently dragged remain stuck
-    // to the screen edge
+  // Consider windows that were formerly children of the |dock_container_|
+  // when fanning out other child windows.
+  if (dragged_window_ && dragged_window_->parent() != dock_container_)
+    visible_windows.push_back(dragged_window_);
+
+  // Sort windows by their center positions and fan out overlapping
+  // windows.
+  std::sort(visible_windows.begin(), visible_windows.end(), CompareWindowPos);
+  gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
+      dock_container_);
+  const gfx::Rect work_area = display.work_area();
+  int available_room = work_area.height();
+  for (aura::Window::Windows::const_iterator iter = visible_windows.begin();
+      iter != visible_windows.end(); ++iter) {
+    available_room -= (*iter)->bounds().height();
+  }
+  const int num_windows = visible_windows.size();
+  const int delta = available_room /
+      ((available_room > 0 || num_windows <= 1) ?
+          num_windows + 1 : num_windows - 1);
+  int y_pos = (available_room > 0) ? delta : 0;
+
+  for (aura::Window::Windows::const_iterator iter = visible_windows.begin();
+      iter != visible_windows.end(); ++iter) {
+    aura::Window* window = *iter;
     gfx::Rect bounds = window->GetTargetBounds();
-    if (window != dragged_window_) {
-      switch (alignment_) {
-        case DOCKED_ALIGNMENT_LEFT:
-          bounds.set_x(0);
-          break;
-        case DOCKED_ALIGNMENT_RIGHT:
-          bounds.set_x(dock_bounds.right() - bounds.width());
-          break;
-        case DOCKED_ALIGNMENT_NONE:
-          NOTREACHED() << "Relayout called when dock alignment is 'NONE'";
-          break;
-      }
-      // Keep the dock at least kMinDockWidth when all windows in it overhang.
-      docked_width_ = std::min(kMaxDockWidth,
-                               std::max(docked_width_,
-                                        bounds.width() > kMaxDockWidth ?
-                                            kMinDockWidth : bounds.width()));
+    // Do not force position of a single window.
+    if (num_windows == 1)
+      y_pos = bounds.y();
+
+    // Fan out windows evenly distributing the overlap or remaining free space.
+    bounds.set_y(std::max(work_area.y(),
+                          std::min(work_area.bottom() - bounds.height(),
+                                   y_pos)));
+    y_pos += bounds.height() + delta;
+
+    // All docked windows other than the one currently dragged remain stuck
+    // to the screen edge.
+    if (window == dragged_window_)
+      continue;
+    switch (alignment_) {
+      case DOCKED_ALIGNMENT_LEFT:
+        bounds.set_x(0);
+        break;
+      case DOCKED_ALIGNMENT_RIGHT:
+        bounds.set_x(dock_bounds.right() - bounds.width());
+        break;
+      case DOCKED_ALIGNMENT_NONE:
+        NOTREACHED() << "Relayout called when dock alignment is 'NONE'";
+        break;
     }
+    // Keep the dock at least kMinDockWidth when all windows in it overhang.
+    docked_width_ = std::min(kMaxDockWidth,
+                             std::max(docked_width_,
+                                      bounds.width() > kMaxDockWidth ?
+                                          kMinDockWidth : bounds.width()));
     SetChildBoundsDirect(window, bounds);
   }
   UpdateStacking(active_window);
 }
 
 void DockedWindowLayoutManager::UpdateDockBounds() {
   int dock_inset = docked_width_ + (docked_width_ > 0 ? kMinDockGap : 0);
   gfx::Rect bounds = gfx::Rect(
       alignment_ == DOCKED_ALIGNMENT_RIGHT ?
           dock_container_->bounds().right() - dock_inset:
           dock_container_->bounds().x(),
       dock_container_->bounds().y(),
       dock_inset,
       dock_container_->bounds().height());
   docked_bounds_ = bounds +
       dock_container_->GetBoundsInScreen().OffsetFromOrigin();
   FOR_EACH_OBSERVER(
       DockedWindowLayoutManagerObserver,
       observer_list_,
       OnDockBoundsChanging(bounds));
 }
 
 void DockedWindowLayoutManager::UpdateStacking(aura::Window* active_window) {
-  // TODO(varkha): Implement restacking to ensure that all docked windows are at
-  // least partially visible and selectable.
+  if (!active_window) {
+    if (!last_active_window_)
+      return;
+    active_window = last_active_window_;
+  }
+
+  // We want to to stack the windows like a deck of cards:
+  //  ,------.
+  // |,------.|
+  // |,------.|
+  // | active |
+  // | window |
+  // |`------'|
+  // |`------'|
+  //  `------'
+  // We use the middle of each window to figure out how to stack the window.
+  // This allows us to update the stacking when a window is being dragged around
+  // by the titlebar.
+  std::map<int, aura::Window*> window_ordering;
+  for (aura::Window::Windows::const_iterator it =
+           dock_container_->children().begin();
+       it != dock_container_->children().end(); ++it) {
+    gfx::Rect bounds = (*it)->bounds();
+    window_ordering.insert(std::make_pair(bounds.y() + bounds.height() / 2,
+                                          *it));
+  }
+  int active_center_y = active_window->bounds().CenterPoint().y();
+
+  aura::Window* previous_window = NULL;
+  for (std::map<int, aura::Window*>::const_iterator it =
+       window_ordering.begin();
+       it != window_ordering.end() && it->first < active_center_y; ++it) {
+    if (previous_window)
+      dock_container_->StackChildAbove(it->second, previous_window);
+    previous_window = it->second;
+  }
+
+  previous_window = NULL;
+  for (std::map<int, aura::Window*>::const_reverse_iterator it =
+       window_ordering.rbegin();
+       it != window_ordering.rend() && it->first > active_center_y; ++it) {
+    if (previous_window)
+      dock_container_->StackChildAbove(it->second, previous_window);
+    previous_window = it->second;
+  }
+
+  if (active_window->parent() == dock_container_)
+    dock_container_->StackChildAtTop(active_window);
+  if (dragged_window_ && dragged_window_->parent() == dock_container_)
+    dock_container_->StackChildAtTop(dragged_window_);
+  last_active_window_ = active_window;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // keyboard::KeyboardControllerObserver implementation:
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   UpdateDockBounds();
 }
 
 }  // namespace internal
 }  // namespace ash