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_former_child_(NULL),
       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_(NULL) {
   DCHECK(dock_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
 
@@ skipping 46 matching lines @@
           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 |dragged_former_child_| if it is added back;
+  if (dragged_former_child_) {
+    if (dragged_former_child_->parent() != dock_container_)
+      dragged_former_child_->RemoveObserver(this);
+    dragged_former_child_ = NULL;
+  }
+
   Relayout();
   UpdateDockBounds();
 }
 
 // static
 bool DockedWindowLayoutManager::ShouldWindowDock(aura::Window* window,
                                                  const gfx::Point& location) {
   DockedWindowLayoutManager* layout_manager = GetDockLayoutManager(window,
                                                                    location);
   const DockedAlignment alignment = layout_manager->CalculateAlignment();
@@ skipping 77 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 no longer need |dragged_former_child_| if it is added back.
+  if (child == dragged_former_child_)
+    dragged_former_child_ = NULL;
+  else
+    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_)
+    dragged_former_child_ = child;
+  else
+    child->RemoveObserver(this);
+
   // 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_former_child_)
+    Relayout();
+  if (window == dragged_former_child_)
+    LOG(INFO) << "OnWindowBoundsChanged";
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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_former_child_)
+    visible_windows.push_back(dragged_former_child_);
+
+  // 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)));

[flackr, 2013/07/18 22:16:53]

The clamping within the work area should never be necessary right? It might be
nice to instead just have a DCHECK for this.

[varkha, 2013/07/18 22:58:14]

I think it may still need clamping in valid corner cases, e.g. when there are
two windows, one slim and one very tall (i.e. almost screen-tall which can
happen when a shelf was hidden and then shown again - making that window taller
than a work area). Tall window being second will start initially above the work
area and end below it. With clamping it will still end below the shelf top (work
area boundary) but at least it will be on screen and draggable.

+    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_)
+      return;
+    active_window = last_active_;
+  }
+
+  // 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_ = 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