Stack panels so that part of them will always be visible.

ash/wm/panel_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/panel_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/launcher/launcher.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
 #include "base/auto_reset.h"
+#include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 const int kPanelMarginEdge = 4;
 const int kPanelMarginMiddle = 8;
 
 const int kMinimizedHeight = 24;
 
 const float kMaxHeightFactor = .80f;
 const float kMaxWidthFactor = .50f;
 }
 
 namespace ash {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager public implementation:
-
 PanelLayoutManager::PanelLayoutManager(aura::Window* panel_container)
     : panel_container_(panel_container),
       in_layout_(false),
       dragged_panel_(NULL),
-      launcher_(NULL) {
+      launcher_(NULL),
+      last_active_panel_(NULL) {
   DCHECK(panel_container);
+  Shell::GetRootWindow()->AddObserver(this);
 }
 
 PanelLayoutManager::~PanelLayoutManager() {
   if (launcher_)
     launcher_->RemoveIconObserver(this);
+  Shell::GetRootWindow()->RemoveObserver(this);
 }
 
 void PanelLayoutManager::StartDragging(aura::Window* panel) {
   DCHECK(!dragged_panel_);
   DCHECK(panel->parent() == panel_container_);
   dragged_panel_ = panel;
 }
 
 void PanelLayoutManager::FinishDragging() {
   DCHECK(dragged_panel_);
@@ skipping 28 matching lines @@
                    gfx::Rect(old_bounds.x(),
                              old_bounds.bottom() - kMinimizedHeight,
                              old_bounds.width(),
                              kMinimizedHeight));
   }
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, aura::LayoutManager implementation:
-
 void PanelLayoutManager::OnWindowResized() {
   Relayout();
 }
 
 void PanelLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   panel_windows_.push_back(child);
   Relayout();
 }
 
 void PanelLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   PanelList::iterator found =
       std::find(panel_windows_.begin(), panel_windows_.end(), child);
   if (found != panel_windows_.end())
     panel_windows_.erase(found);
 
   if (dragged_panel_ == child)
     dragged_panel_ = NULL;
 
+  if (last_active_panel_ == child)
+    last_active_panel_ = NULL;
+
   Relayout();
 }
 
 void PanelLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
 }
 
 void PanelLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
                                                         bool visible) {
   Relayout();
 }
@@ skipping 25 matching lines @@
       panel_windows_.erase(dragged_panel_iter);
       panel_windows_.insert(new_position, dragged_panel_);
     }
   }
 
   SetChildBoundsDirect(child, bounds);
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// PanelLayoutManager, aura::LauncherIconObserver implementation:
-
+// PanelLayoutManager, ash::LauncherIconObserver implementation:
 void PanelLayoutManager::OnLauncherIconPositionsChanged() {
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// PanelLayoutManager, aura::WindowObserver implementation:
+void PanelLayoutManager::OnWindowPropertyChanged(aura::Window* window,
+                                                 const void* key,
+                                                 intptr_t old) {
+  if (key == aura::client::kRootWindowActiveWindowKey) {
+    aura::Window* active = window->GetProperty(
+        aura::client::kRootWindowActiveWindowKey);
+    if (active && active->type() == aura::client::WINDOW_TYPE_PANEL)
+      UpdateStacking(active);
+  }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager private implementation:
-
 void PanelLayoutManager::Relayout() {
   if (in_layout_)
     return;
   AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   ash::Shell* shell = ash::Shell::GetInstance();
 
+  aura::Window* active_panel = NULL;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
-    aura::Window* panel_win = *iter;
-    if (!panel_win->IsVisible() || panel_win == dragged_panel_)
+    aura::Window* panel = *iter;
+    if (!panel->IsVisible() || panel == dragged_panel_)
       continue;
 
     gfx::Rect icon_bounds =
-        shell->launcher()->GetScreenBoundsOfItemIconForWindow(panel_win);
+        shell->launcher()->GetScreenBoundsOfItemIconForWindow(panel);
 
     // An empty rect indicates that there is no icon for the panel in the
     // launcher. Just use the current bounds, as there's no icon to draw the
     // panel above.
+    // TODO(dcheng): Need to anchor to overflow icon.
     if (icon_bounds.IsEmpty())
       continue;
 
+    if (panel->HasFocus()) {
+      DCHECK(!active_panel);
+      active_panel = panel;
+    }
+
     gfx::Point icon_origin = icon_bounds.origin();
     aura::Window::ConvertPointToWindow(panel_container_->GetRootWindow(),
                                        panel_container_, &icon_origin);
 
-    gfx::Rect bounds = panel_win->bounds();
+    // TODO(dcheng): Need to clamp to screen edges.
+    gfx::Rect bounds = panel->bounds();
     bounds.set_x(
         icon_origin.x() + icon_bounds.width() / 2 - bounds.width() / 2);
     bounds.set_y(icon_origin.y() - bounds.height());
-    SetChildBoundsDirect(panel_win, bounds);
+    SetChildBoundsDirect(panel, bounds);
   }
+
+  UpdateStacking(active_panel);
+}
+
+void PanelLayoutManager::UpdateStacking(aura::Window* active_panel) {
+  // We want to to stack the panels like a deck of cards:

[sky, 2012/04/26 04:30:31]

Be warned, we're going to make the launcher support vertical tiling soon. This
code will need to be updated then.

[dcheng, 2012/04/26 06:30:59]

Doh. Thanks for the heads up. We're definitely going to have to think about how
to make panels appear decent when oriented vertically... the current design
doesn't really provide for that.

+  // ,--,--,--,-------.--.--.
+  // |  |  |  |       |  |  |
+  // |  |  |  |       |  |  |
+  //
+  // Since there's no way of extracting a panel ordering from the launcher,
+  // we build an ordering based on the x-coordinate of the panel bounds...
+  // It's a little hacky...

[sky, 2012/04/26 04:30:31]

You can actually get this information from the LauncherDelegate and model. I'm
not opposed to exposing a method to get the set of windows shown from the
launcher.

[dcheng, 2012/04/26 06:30:59]

I've updated this comment to better reflect the current state of affairs. Since
we want dragged panels to trigger this stacking even though it doesn't affect
the launcher icon positions, we actually do need to use the x coordinate.

+  std::map<int, aura::Window*> window_ordering;
+
+  for (PanelList::const_iterator it = panel_windows_.begin();
+       it != panel_windows_.end(); ++it) {
+    window_ordering.insert(std::make_pair((*it)->bounds().x(), *it));
+  }
+
+  if (!active_panel) {

[sky, 2012/04/26 04:30:31]

Since this can early return, make it first.

[dcheng, 2012/04/26 06:30:59]

Done.

+    if (!last_active_panel_)
+      return;
+    active_panel = last_active_panel_;

[sky, 2012/04/26 04:30:31]

Should you return if last_active_panel_ is NULL?

[dcheng, 2012/04/26 06:30:59]

No, this can happen if this is the first time a panel has been focused.

[sky, 2012/04/26 16:05:10]

Can't it also happen if last_active_panel_ is closed? And if it is NULL, won't
it cause problems below (269 in particular, not sure if we ignore NULL).

[dcheng, 2012/04/26 18:10:25]

Good point--it didn't occur to me since there's no easy way to create a panel
that's not focused by default. However, shouldn't the return on line 247 be
handling that already?

[sky, 2012/04/26 19:06:59]

Of course. You're right.

+  }
+
+  aura::Window* previous_panel = NULL;
+  for (std::map<int, aura::Window*>::const_iterator it =
+       window_ordering.begin();
+       it != window_ordering.end() && it->second != active_panel; ++it) {
+    if (previous_panel)
+      panel_container_->StackChildAbove(it->second, previous_panel);
+    previous_panel = it->second;
+  }
+
+  previous_panel = NULL;
+  for (std::map<int, aura::Window*>::const_reverse_iterator it =
+       window_ordering.rbegin();
+       it != window_ordering.rend() && it->second != active_panel; ++it) {
+    if (previous_panel)
+      panel_container_->StackChildAbove(it->second, previous_panel);
+    previous_panel = it->second;
+  }
+
+  panel_container_->StackChildAtTop(active_panel);
+  last_active_panel_ = active_panel;
 }
 
 }  // namespace internal
 }  // namespace ash