athena: Fix switching to a window of a different size.

athena/wm/window_manager_impl.cc

 // Copyright 2014 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 "athena/wm/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/bezel_controller.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
 #include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
+#include "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/closure_animation_observer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
 
 namespace athena {
 namespace {
 class WindowManagerImpl* instance = NULL;
+
+void SetWindowState(aura::Window* window,
+                    const gfx::Rect& bounds,
+                    const gfx::Transform& transform) {
+  window->SetBounds(bounds);
+  window->SetTransform(transform);
+}
+
 }  // namespace
 
 class AthenaContainerLayoutManager : public aura::LayoutManager {
  public:
   AthenaContainerLayoutManager();
   virtual ~AthenaContainerLayoutManager();
 
  private:
   // aura::LayoutManager:
   virtual void OnWindowResized() OVERRIDE;
@@ skipping 123 matching lines @@
 
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
   bezel_controller_->set_left_right_delegate(
       active ? NULL : split_view_controller_.get());
   if (active) {
     split_view_controller_->DeactivateSplitMode();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                      OnOverviewModeEnter());
+    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
+
     // Re-stack all windows in the order defined by window_list_provider_.
     aura::Window::Windows window_list = window_list_provider_->GetWindowList();
     aura::Window::Windows::iterator it;
     for (it = window_list.begin(); it != window_list.end(); ++it)
       container_->StackChildAtTop(*it);
     overview_ = WindowOverviewMode::Create(
         container_.get(), window_list_provider_.get(), this);
   } else {
     CHECK(!split_view_controller_->IsSplitViewModeActive());
     overview_.reset();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                      OnOverviewModeExit());
+    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
   }
 }
 
 void WindowManagerImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
        AF_NONE},
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_CONTROL_DOWN,
        CMD_TOGGLE_SPLIT_VIEW, AF_NONE},
   };
@@ skipping 81 matching lines @@
       behind = (iter == windows.rend()) ? NULL : *iter;
   }
 
   return behind;
 }
 
 void WindowManagerImpl::OnTitleDragStarted(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
-  // Make sure |window| is active. Also make sure that |next_window| is visible,
-  // and positioned to match the top-left edge of |window|.
+  // Make sure |window| is active.
   wm::ActivateWindow(window);
+
+  // Make sure |next_window| is visibile.
   next_window->Show();
+
+  // Position |next_window| correctly (left aligned if it's larger than
+  // |window|, and center aligned otherwise).
   int dx = window->bounds().x() - next_window->bounds().x();
+  if (next_window->bounds().width() < window->bounds().width())
+    dx -= (next_window->bounds().width() - window->bounds().width()) / 2;
+
   if (dx) {
     gfx::Transform transform;
     transform.Translate(dx, 0);
     next_window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnTitleDragCompleted(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
-  if (split_view_controller_->IsSplitViewModeActive())
+  if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->ReplaceWindow(window, next_window);
-  else
+    wm::ActivateWindow(next_window);
+  } else {
+    ui::ScopedLayerAnimationSettings
+        settings(next_window->layer()->GetAnimator());
+    settings.AddObserver(new ui::ClosureAnimationObserver(
+        base::Bind(&SetWindowState,
+                   base::Unretained(next_window),
+                   window->bounds(),
+                   gfx::Transform())));
+
+    gfx::Transform transform;
+    transform.Scale(window->bounds().width() / next_window->bounds().width(),
+                    window->bounds().height() / next_window->bounds().height());
+    transform.Translate(window->bounds().x() - next_window->bounds().x(), 0);
+    next_window->SetTransform(transform);
+
     OnSelectWindow(next_window);
-  wm::ActivateWindow(next_window);
+  }
+  window->Hide();
 }
 
 void WindowManagerImpl::OnTitleDragCanceled(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   next_window->SetTransform(gfx::Transform());
+  next_window->Hide();
 }
 
 // static
 WindowManager* WindowManager::Create() {
   DCHECK(!instance);
   new WindowManagerImpl;
   DCHECK(instance);
   return instance;
 }
 
 // static
 void WindowManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena