Compact layout mananger animates windows rather than the default container layer.

ash/wm/compact_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/compact_layout_manager.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
+#include "base/memory/scoped_vector.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 typedef std::vector<aura::Window*> WindowList;
 typedef std::vector<aura::Window*>::const_iterator WindowListConstIter;
 
 // Convenience method to get the layer of this container.
 ui::Layer* GetDefaultContainerLayer() {
   return Shell::GetInstance()->GetContainer(
       internal::kShellWindowId_DefaultContainer)->layer();
 }
 
 // Whether it is a window that should be animated on entrance.
 bool ShouldAnimateOnEntrance(aura::Window* window) {
   return window &&
       window->type() == aura::client::WINDOW_TYPE_NORMAL &&
       window_util::IsWindowMaximized(window);
 }
 
-// Adjust layer bounds to grow or shrink in |delta_width|.
-void AdjustContainerLayerWidth(int delta_width) {
-  gfx::Rect bounds(GetDefaultContainerLayer()->bounds());
-  bounds.set_width(bounds.width() + delta_width);
-  GetDefaultContainerLayer()->SetBounds(bounds);
-  GetDefaultContainerLayer()->GetCompositor()->WidgetSizeChanged(
-      GetDefaultContainerLayer()->bounds().size());
-}
 }  // namespace
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, public:
 
 CompactLayoutManager::CompactLayoutManager()
     : status_area_widget_(NULL),
       current_window_(NULL) {
 }
 
 CompactLayoutManager::~CompactLayoutManager() {
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, LayoutManager overrides:
 
 void CompactLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   // Windows added to this container does not need extra animation.
   if (child->type() == aura::client::WINDOW_TYPE_NORMAL)
     child->SetProperty(aura::client::kAnimationsDisabledKey, true);
   BaseLayoutManager::OnWindowAddedToLayout(child);
   UpdateStatusAreaVisibility();
-  if (windows().size() > 1 &&
-      child->type() == aura::client::WINDOW_TYPE_NORMAL) {
-    // The first window is already contained in the current layer,
-    // add subsequent windows to layer bounds calculation.
-    AdjustContainerLayerWidth(child->bounds().width());
-  }
 }
 
 void CompactLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   BaseLayoutManager::OnWillRemoveWindowFromLayout(child);
   UpdateStatusAreaVisibility();
-  if (windows().size() > 1 && ShouldAnimateOnEntrance(child))
-    AdjustContainerLayerWidth(-child->bounds().width());
-
   if (child == current_window_) {
     LayoutWindows(current_window_);
     SwitchToReplacementWindow();
   }
   // Allow window to be animated by others.
   if (child->type() == aura::client::WINDOW_TYPE_NORMAL)
     child->SetProperty(aura::client::kAnimationsDisabledKey, false);
 }
 
 void CompactLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
@@ skipping 51 matching lines @@
     }
     // Animate to |window| when there is a stacking change.
     AnimateSlideTo(window->bounds().x());
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, AnimationDelegate overrides:
 
 void CompactLayoutManager::OnImplicitAnimationsCompleted() {
-  if (!GetDefaultContainerLayer()->GetAnimator()->is_animating())
-    HideWindows();
+  if (AreWindowsAnimating())
+    return;
+  HideWindows();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, private:
 
 void CompactLayoutManager::UpdateStatusAreaVisibility() {
   if (!status_area_widget_)
     return;
   // Full screen windows should hide the status area widget.
   bool has_fullscreen = window_util::HasFullscreenWindow(windows());
   bool widget_visible = status_area_widget_->IsVisible();
   if (has_fullscreen && widget_visible)
     status_area_widget_->Hide();
   else if (!has_fullscreen && !widget_visible)
     status_area_widget_->Show();
 }
 
 void CompactLayoutManager::AnimateSlideTo(int offset_x) {
-  GetDefaultContainerLayer()->GetAnimator()->RemoveObserver(this);
-  ui::ScopedLayerAnimationSettings settings(
-      GetDefaultContainerLayer()->GetAnimator());
-  settings.AddObserver(this);
-  ui::Transform transform;
-  transform.ConcatTranslate(-offset_x, 0);
-  GetDefaultContainerLayer()->SetTransform(transform);  // Will be animated!
+  // If we were waiting for another implicit animation to complete, forget
+  // about it since we're about to start observing a new animation.
+  StopObservingImplicitAnimations();
+  ScopedVector<ui::ScopedLayerAnimationSettings> settings;
+  ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
+  const WindowList& windows_list = shell_delegate->GetCycleWindowList(
+      ShellDelegate::SOURCE_KEYBOARD,
+      ShellDelegate::ORDER_LINEAR);
+  for (WindowListConstIter const_it = windows_list.begin();
+       const_it != windows_list.end();
+       ++const_it) {
+    settings.push_back(new ui::ScopedLayerAnimationSettings(
+        (*const_it)->layer()->GetAnimator()));
+    settings[settings.size() - 1]->AddObserver(this);

[alicet1, 2012/02/14 16:04:39]

settings.back()?

+    settings[settings.size() - 1]->SetPreemptionStrategy(
+        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+    gfx::Rect bounds = (*const_it)->layer()->bounds();

[alicet1, 2012/02/14 16:04:39]

should this be GetTargetBounds() ?

+    bounds.Offset(-offset_x, 0);
+    (*const_it)->layer()->SetBounds(bounds);
+  }
+}
+
+bool CompactLayoutManager::AreWindowsAnimating() const {
+  ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
+  const WindowList& windows_list = shell_delegate->GetCycleWindowList(
+      ShellDelegate::SOURCE_KEYBOARD,
+      ShellDelegate::ORDER_LINEAR);
+  for (WindowListConstIter const_it = windows_list.begin();
+       const_it != windows_list.end();
+       ++const_it) {
+    if ((*const_it)->layer()->GetAnimator()->is_animating())
+      return true;
+  }
+  return false;
 }
 
 void CompactLayoutManager::LayoutWindows(aura::Window* skip) {
   ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
   const WindowList& windows_list = shell_delegate->GetCycleWindowList(
       ShellDelegate::SOURCE_KEYBOARD,
       ShellDelegate::ORDER_LINEAR);
+  bool first_window = true;
   int new_x = 0;
   for (WindowListConstIter const_it = windows_list.begin();
        const_it != windows_list.end();
        ++const_it) {
     if (*const_it != skip) {
       gfx::Rect new_bounds((*const_it)->bounds());
-      new_bounds.set_x(new_x);
+      if (first_window) {
+        new_x = new_bounds.x();
+        first_window = false;
+      } else
+        new_bounds.set_x(new_x);
       SetChildBoundsDirect(*const_it, new_bounds);
       (*const_it)->layer()->SetVisible(true);
       new_x += (*const_it)->bounds().width();
     }
   }
 }
 
 void CompactLayoutManager::HideWindows() {
   // If we do not know which one is the current window, or if the current
   // window is not visible, do not attempt to hide the windows.
   if (current_window_ == NULL)
     return;
   // Current window should be visible, if not it is an error and we shouldn't
   // proceed.
   if (!current_window_->layer()->visible())
     NOTREACHED() << "Current window is invisible";
 
   ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
   const WindowList& windows_list = shell_delegate->GetCycleWindowList(
       ShellDelegate::SOURCE_KEYBOARD,
       ShellDelegate::ORDER_LINEAR);
   for (WindowListConstIter const_it = windows_list.begin();
        const_it != windows_list.end();
        ++const_it) {
-    if (*const_it != current_window_)
+    if (*const_it != current_window_ &&
+        (*const_it)->layer()->GetTargetVisibility())
       (*const_it)->layer()->SetVisible(false);
   }
 }
 
 aura::Window* CompactLayoutManager::FindReplacementWindow(
     aura::Window* window) {
   ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
   const WindowList& windows_list = shell_delegate->GetCycleWindowList(
       ShellDelegate::SOURCE_KEYBOARD,
       ShellDelegate::ORDER_LINEAR);
@@ skipping 15 matching lines @@
 void CompactLayoutManager::SwitchToReplacementWindow() {
   current_window_ = FindReplacementWindow(current_window_);
   if (current_window_) {
     ActivateWindow(current_window_);
     AnimateSlideTo(current_window_->bounds().x());
   }
 }
 
 }  // namespace internal
 }  // namespace ash