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);
+  panel->Hide();
+  if (wm::IsActiveWindow(panel))
+    wm::DeactivateWindow(panel);
+  Relayout();
+}
+
+void PanelLayoutManager::RestorePanel(aura::Window* panel) {
+  panel->Show();
+  Relayout();
+}
+
 void PanelLayoutManager::Relayout() {
   if (!launcher_ || !launcher_->widget())
     return;
 
   if (in_layout_)
     return;
   base::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(
+            aura::client::GetFocusClient(panel)->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 76 matching lines @@
   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