Allow Chrome apps to create Ash Panels (apps v2)

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 <map>
 
 #include "ash/launcher/launcher.h"
 #include "ash/shell.h"
 #include "ash/wm/frame_painter.h"
 #include "ash/wm/property_util.h"
+#include "ash/wm/window_animations.h"
+#include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
+#include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/background.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 const int kPanelMarginEdge = 4;
 const int kPanelMarginMiddle = 8;
 
-const int kMinimizedHeight = 24;
-
 const float kMaxHeightFactor = .80f;
 const float kMaxWidthFactor = .50f;
 
 // Callout arrow dimensions.
 const int kArrowWidth = 20;
 const int kArrowHeight = 10;
 
 class CalloutWidgetBackground : public views::Background {
  public:
   CalloutWidgetBackground() {}
@@ skipping 52 matching lines @@
   if (launcher_)
     launcher_->RemoveIconObserver(this);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       RemoveObserver(this);
 }
 
 void PanelLayoutManager::StartDragging(aura::Window* panel) {
   DCHECK(!dragged_panel_);
   DCHECK(panel->parent() == panel_container_);
   dragged_panel_ = panel;
+  Relayout();
 }
 
 void PanelLayoutManager::FinishDragging() {
   DCHECK(dragged_panel_);
   dragged_panel_ = NULL;
   Relayout();
 }
 
 void PanelLayoutManager::SetLauncher(ash::Launcher* launcher) {
   launcher_ = launcher;
   launcher_->AddIconObserver(this);
 }
 
 void PanelLayoutManager::ToggleMinimize(aura::Window* panel) {
   DCHECK(panel->parent() == panel_container_);
   if (panel->GetProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_MINIMIZED) {
-    const gfx::Rect& old_bounds = panel->bounds();
     panel->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
-
-    gfx::Rect new_bounds(old_bounds);
-    const gfx::Rect* restore_bounds = GetRestoreBoundsInScreen(panel);
-    if (restore_bounds) {
-      new_bounds.set_height(restore_bounds->height());
-      new_bounds.set_y(old_bounds.bottom() - restore_bounds->height());
-      SetChildBounds(panel, new_bounds);
-      ClearRestoreBounds(panel);
-    }
   } else {
-    const gfx::Rect& old_bounds = panel->bounds();
     panel->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-    SetRestoreBoundsInParent(panel, old_bounds);
-    SetChildBounds(panel,
-                   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) {
   if (child == callout_widget_->GetNativeWindow())
     return;
   panel_windows_.push_back(child);
+  child->AddObserver(this);
   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);
+  child->RemoveObserver(this);
 
   if (dragged_panel_ == child)
     dragged_panel_ = NULL;
 
   if (last_active_panel_ == child)
     last_active_panel_ = NULL;
 
   Relayout();
 }
 
@@ skipping 41 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, ash::LauncherIconObserver implementation:
 
 void PanelLayoutManager::OnLauncherIconPositionsChanged() {
   // TODO: As this is called for every animation step now. Relayout needs to be
   // updated to use current icon position instead of use the ideal bounds so
   // that the panels slide with their icons instead of jumping.
   Relayout();
 }
 
+/////////////////////////////////////////////////////////////////////////////
+// PanelLayoutManager, WindowObserver implementation:
+
+void PanelLayoutManager::OnWindowPropertyChanged(aura::Window* window,
+                                                 const void* key,
+                                                 intptr_t old) {
+  if (key != aura::client::kShowStateKey)
+    return;
+  ui::WindowShowState new_state =
+      window->GetProperty(aura::client::kShowStateKey);
+  if (new_state == ui::SHOW_STATE_MINIMIZED)
+    MinimizePanel(window);
+  else
+    RestorePanel(window);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager, aura::client::ActivationChangeObserver implementation:
 void PanelLayoutManager::OnWindowActivated(aura::Window* active,
                                            aura::Window* old_active) {
   if (active && active->type() == aura::client::WINDOW_TYPE_PANEL) {
     UpdateStacking(active);
     UpdateCallout(active);
   } else {
     UpdateCallout(NULL);
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager private implementation:
+
+void PanelLayoutManager::MinimizePanel(aura::Window* panel) {
+  SetWindowVisibilityAnimationType(
+      panel, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);

[sky, 2012/11/20 02:05:05]

I believe WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE finds the location in the
launcher, but I don't believe there is an item in the launcher for panel. You
sure this does the right thing?

[stevenjb, 2012/11/20 21:20:58]

Ash panels (now aka Utility Windows) do have a launcher icon, that's kind of the
whole point of this :)

We don't call SetChildWindowVisibilityChangesAnimated() for panel_container, so
this doesn't actually trigger any animation, but I went ahead and tested that it
does work if we decide to turn the animation on.

+  panel->Hide();
+  if (wm::IsActiveWindow(panel))
+    wm::DeactivateWindow(panel);
+  Relayout();
+}
+
+void PanelLayoutManager::RestorePanel(aura::Window* panel) {
+  panel->Show();
+  wm::ActivateWindow(panel);

[sky, 2012/11/20 02:05:05]

Isn't this done else where?

[stevenjb, 2012/11/20 21:20:58]

I did some investigating and determined that this was never getting called,
which seemed wrong. I changed the logic in ShellWindow to call
GetBaseWindow()->Restore() if the window was minimized, which caused this to get
triggered correctly.

In doing so I also decided that we shouldn't be calling ActivateWindow here,
since panels do not activate by default when shown (e.g. when triggered from an
app), we should be doing the activation explicitly in
ShellWindowLauncherController.

+  Relayout();
+}
+
 void PanelLayoutManager::Relayout() {
   if (!launcher_ || !launcher_->widget())
     return;
 
   if (in_layout_)
     return;
   AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
   int launcher_top = launcher_->widget()->GetWindowBoundsInScreen().y();
   aura::Window* active_panel = NULL;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = *iter;
     if (!panel->IsVisible() || panel == dragged_panel_)
       continue;
 
     gfx::Rect icon_bounds =
         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()) {
+    if (panel->HasFocus() ||
+        panel->Contains(panel->GetFocusManager()->GetFocusedWindow())) {
       DCHECK(!active_panel);
       active_panel = panel;
     }
 
     gfx::Point icon_origin = icon_bounds.origin();
     aura::Window::ConvertPointToTarget(panel_container_->GetRootWindow(),
                                        panel_container_, &icon_origin);
 
     // TODO(dcheng): Need to clamp to screen edges.
     gfx::Rect bounds = panel->bounds();
@@ skipping 50 matching lines @@
   }
 
   panel_container_->StackChildAtTop(active_panel);
   last_active_panel_ = active_panel;
 }
 
 void PanelLayoutManager::UpdateCallout(aura::Window* active_panel) {
   weak_factory_.InvalidateWeakPtrs();
   // TODO(dcheng): This doesn't account for panels in overflow. They should have
   // a callout as well.
-  if (!active_panel ||
-      launcher_->GetScreenBoundsOfItemIconForWindow(active_panel).IsEmpty()) {
+  if (!active_panel) {
     callout_widget_->Hide();
     return;
   }
+  if (launcher_->GetScreenBoundsOfItemIconForWindow(active_panel).IsEmpty()) {
+    callout_widget_->Hide();
+    return;
+  }
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PanelLayoutManager::ShowCalloutHelper,
                  weak_factory_.GetWeakPtr(),
                  active_panel));
 }
 
 void PanelLayoutManager::ShowCalloutHelper(aura::Window* active_panel) {
   DCHECK(active_panel);
   gfx::Rect bounds = active_panel->GetBoundsInRootWindow();
   gfx::Rect callout_bounds = callout_widget_->GetWindowBoundsInScreen();
   callout_bounds.set_x(
       bounds.x() + (bounds.width() - callout_bounds.width()) / 2);
   callout_bounds.set_y(bounds.bottom());
   SetChildBoundsDirect(callout_widget_->GetNativeWindow(), callout_bounds);
   panel_container_->StackChildAtTop(callout_widget_->GetNativeWindow());
   callout_widget_->Show();
 }
 
 }  // namespace internal
 }  // namespace ash