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 {
@@ skipping 134 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},
   };
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
@@ skipping 60 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 += (window->bounds().width() - next_window->bounds().width()) / 2;

[oshima, 2014/08/20 13:41:59]

could be just me and you may ignore but

dy -= (next - window) / 2;

maybe slightly easier to read.

[sadrul, 2014/08/20 22:34:24]

Done.

+
   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(&aura::Window::SetBounds,
+                   base::Unretained(next_window),
+                   window->bounds())));
+    settings.AddObserver(new ui::ClosureAnimationObserver(
+        base::Bind(&aura::Window::SetTransform,
+                   base::Unretained(next_window),
+                   gfx::Transform())));

[oshima, 2014/08/20 13:41:59]

I'd be nice to have a utility observer to set the final bounds after animation.

[sadrul, 2014/08/20 22:34:24]

Done.

+
+    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();

[oshima, 2014/08/20 13:41:59]

Is this important now? looks like we show all windows in overview mode but never
hide windows behind active window(s), so a window behind it.

I agree that we need to implement this state (sorry it was on my plate)

[sadrul, 2014/08/20 22:34:24]

It's not important in the sense that not doing a Hide() here doesn't break
anything visually. But I am adding it explicitly here since we explicitly do a
Show() in OnTitleDragStarted().

I plan on having the overview controller also hide the windows when we get out
of the overview mode (since it explicitly makes them all visible when going into
overview mode too). It's a little trickier though, since it needs to know about
split-view mode and left/right windows. I have a plan for fixing that though,
and will address it in a follow-up CL.

 }
 
 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