Add panels as a single group of windows per display for overview window cycling.

ash/wm/overview/scoped_transform_overview_window.cc

 // Copyright 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/overview/window_selector_window.h"
+#include "ash/wm/overview/scoped_transform_overview_window.h"
 
 #include "ash/shell.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/corewm/shadow_types.h"
 #include "ui/views/corewm/window_animations.h"
 #include "ui/views/corewm/window_util.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 
 namespace {
 
-const int kOverviewWindowTransitionMilliseconds = 100;
-
 // Creates a copy of |window| with |recreated_layer| in the |target_root|.
 views::Widget* CreateCopyOfWindow(aura::RootWindow* target_root,
                                   aura::Window* src_window,
                                   ui::Layer* recreated_layer) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = src_window->parent();
   params.can_activate = false;
   params.keep_on_top = true;
@@ skipping 92 matching lines @@
 
 // The animation settings used for window selector animations.
 class WindowSelectorAnimationSettings
     : public ui::ScopedLayerAnimationSettings {
  public:
   WindowSelectorAnimationSettings(aura::Window* window) :
       ui::ScopedLayerAnimationSettings(window->layer()->GetAnimator()) {
     SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     SetTransitionDuration(base::TimeDelta::FromMilliseconds(
-        kOverviewWindowTransitionMilliseconds));
+        ScopedTransformOverviewWindow::kTransitionMilliseconds));
   }
 
   virtual ~WindowSelectorAnimationSettings() {
   }
 };
 
 }  // namespace
 
-WindowSelectorWindow::WindowSelectorWindow(aura::Window* window)
+const int ScopedTransformOverviewWindow::kTransitionMilliseconds = 100;
+
+ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(
+        aura::Window* window)
     : window_(window),
       window_copy_(NULL),
       layer_(NULL),
       minimized_(window->GetProperty(aura::client::kShowStateKey) ==
                  ui::SHOW_STATE_MINIMIZED),
+      overview_started_(false),
       original_transform_(window->layer()->GetTargetTransform()) {
 }
 
-WindowSelectorWindow::~WindowSelectorWindow() {
+ScopedTransformOverviewWindow::~ScopedTransformOverviewWindow() {
   if (window_) {
     WindowSelectorAnimationSettings animation_settings(window_);
     gfx::Transform transform;
     window_->SetTransform(original_transform_);
     if (minimized_ && window_->GetProperty(aura::client::kShowStateKey) !=
         ui::SHOW_STATE_MINIMIZED) {
       // Setting opacity 0 and visible false ensures that the property change
       // to SHOW_STATE_MINIMIZED will not animate the window from its original
       // bounds to the minimized position.
       window_->layer()->SetOpacity(0);
-      window_->layer()->SetVisible(false);
+      window_->Hide();
       window_->SetProperty(aura::client::kShowStateKey,
                            ui::SHOW_STATE_MINIMIZED);
     }
   }
   // If a copy of the window was created, clean it up.
   if (window_copy_) {
     if (window_) {
       // If the initial window wasn't destroyed, the copy needs to be animated
       // out. CleanupWidgetAfterAnimationObserver will destroy the widget and
       // layer after the animation is complete.
       new CleanupWidgetAfterAnimationObserver(window_copy_, layer_);
       WindowSelectorAnimationSettings animation_settings(
           window_copy_->GetNativeWindow());
       window_copy_->GetNativeWindow()->SetTransform(original_transform_);
     } else {
       window_copy_->Close();
       if (layer_)
         views::corewm::DeepDeleteLayers(layer_);
     }
     window_copy_ = NULL;
     layer_ = NULL;
   }
 }
 
-bool WindowSelectorWindow::Contains(const aura::Window* window) const {
+bool ScopedTransformOverviewWindow::Contains(const aura::Window* window) const {
   if (window_copy_ && window_copy_->GetNativeWindow()->Contains(window))
     return true;
   return window_->Contains(window);
 }
 
-void WindowSelectorWindow::RestoreWindowOnExit() {
+void ScopedTransformOverviewWindow::RestoreWindow() {
+  if (minimized_ && window_->GetProperty(aura::client::kShowStateKey) ==
+      ui::SHOW_STATE_MINIMIZED) {
+    window_->Show();
+  }
+}
+
+void ScopedTransformOverviewWindow::RestoreWindowOnExit() {
   minimized_ = false;
   original_transform_ = gfx::Transform();
 }
 
-void WindowSelectorWindow::OnWindowDestroyed() {
+void ScopedTransformOverviewWindow::OnWindowDestroyed() {
   window_ = NULL;
 }
 
-void WindowSelectorWindow::TransformToFitBounds(
-    aura::RootWindow* root_window,
-    const gfx::Rect& target_bounds) {
-  if (minimized_ && window_->GetProperty(aura::client::kShowStateKey) ==
-      ui::SHOW_STATE_MINIMIZED) {
-    window_->Show();
-  }
-  fit_bounds_ = target_bounds;
-  const gfx::Rect bounds = window_->GetBoundsInScreen();
+gfx::Transform ScopedTransformOverviewWindow::
+    GetTransformForRectPreservingAspectRatio(const gfx::Rect& rect,
+                                             const gfx::Rect& bounds) {
+  DCHECK(!rect.IsEmpty());
+  DCHECK(!bounds.IsEmpty());
   float scale = std::min(1.0f,
-      std::min(static_cast<float>(target_bounds.width()) / bounds.width(),
-               static_cast<float>(target_bounds.height()) / bounds.height()));
+      std::min(static_cast<float>(bounds.width()) / rect.width(),
+               static_cast<float>(bounds.height()) / rect.height()));
   gfx::Transform transform;
   gfx::Vector2d offset(
-      0.5 * (target_bounds.width() - scale * bounds.width()),
-      0.5 * (target_bounds.height() - scale * bounds.height()));
-  transform.Translate(target_bounds.x() - bounds.x() + offset.x(),
-                      target_bounds.y() - bounds.y() + offset.y());
+      0.5 * (bounds.width() - scale * rect.width()),
+      0.5 * (bounds.height() - scale * rect.height()));
+  transform.Translate(bounds.x() - rect.x() + offset.x(),
+                      bounds.y() - rect.y() + offset.y());
   transform.Scale(scale, scale);
+  return transform;
+}
+
+void ScopedTransformOverviewWindow::SetTransform(
+    aura::RootWindow* root_window,
+    const gfx::Transform& transform) {
+  // If this is the first transform, perform one-time window modifications
+  // necessary for overview mode.
+  if (!overview_started_) {
+    OnOverviewStarted();
+    overview_started_ = true;
+  }
+
   if (root_window != window_->GetRootWindow()) {
     if (!window_copy_) {
       DCHECK(!layer_);
       layer_ = views::corewm::RecreateWindowLayers(window_, true);
       window_copy_ = CreateCopyOfWindow(root_window, window_, layer_);
     }
     WindowSelectorAnimationSettings animation_settings(
         window_copy_->GetNativeWindow());
     window_copy_->GetNativeWindow()->SetTransform(transform);
   }
   WindowSelectorAnimationSettings animation_settings(window_);
   window_->SetTransform(transform);
 }
 
+void ScopedTransformOverviewWindow::OnOverviewStarted() {
+  RestoreWindow();
+}
+
 }  // namespace ash