Add shoftcut (ctrl-f6) to toggle split view

athena/wm/split_view_controller.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/split_view_controller.h"
 
 #include <cmath>
 
+#include "athena/common/closure_animation_observer.h"

[mfomitchev, 2014/08/12 18:52:50]

Nice. Not part of this CL, but perhaps ClosureAnimationObserver could live
somewhere in ui/? E.g. there are parts of GestureNav code which might be able to
use it.

 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "base/bind.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
-namespace {
-
-// An animation observer that runs a callback at the end of the animation, and
-// destroys itself.
-class CallbackAnimationObserver : public ui::ImplicitAnimationObserver {
- public:
-  explicit CallbackAnimationObserver(const base::Closure& closure)
-      : closure_(closure) {}
-
-  virtual ~CallbackAnimationObserver() {}
-
- private:
-  // Overridden from ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
-    if (!closure_.is_null())
-      closure_.Run();
-    delete this;
-  }
-
-  const base::Closure closure_;
-
-  DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
-};
-
-}  // namespace
 
 SplitViewController::SplitViewController(
     aura::Window* container,
     WindowListProvider* window_list_provider,
     WindowManager* window_manager)
     : state_(INACTIVE),
       container_(container),
       window_manager_(window_manager),
       window_list_provider_(window_list_provider),
       current_activity_window_(NULL),
       left_window_(NULL),
       right_window_(NULL),
       separator_position_(0),
       weak_factory_(this) {
   window_manager->AddObserver(this);
 }
 
 SplitViewController::~SplitViewController() {
   window_manager_->RemoveObserver(this);
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
   return state_ == ACTIVE;
 }
 
+void SplitViewController::ToggleSplitView() {
+  if (IsSplitViewModeActive()) {
+    const gfx::Transform transform;

[mfomitchev, 2014/08/12 18:52:50]

Can you add a TODO(mfomitchev): Use UpdateLayout()?
I don't think it can handle this transition now, but it should be able to once I
do more work on it.

+    left_window_->SetTransform(transform);
+    right_window_->SetTransform(transform);
+    left_window_->SetBounds(container_->bounds());
+    right_window_->SetBounds(container_->bounds());
+    left_window_ = NULL;
+    right_window_ = NULL;
+    current_activity_window_ = NULL;
+    state_ = INACTIVE;
+  } else if (window_list_provider_->GetWindowList().size() > 1) {
+    left_window_ = GetCurrentActivityWindow();

[mfomitchev, 2014/08/12 18:52:50]

I'd use left_window_ and right_window if they are non-NULL. Ideally I'd also use
UpdateLayout() here instead of setting transform/bounds manually.

Something along these lines:

if (!left_window_) {
  // Init left_window_ and right_window_.
  // We can assume/DCHECK that GetCurrentActivityWindow() is 
  // the last window in window_list_provider_->GetWindowList().
}
DCHECK(right_window);
state_ = ACTIVE;
UpdateLayout(true);

[mfomitchev, 2014/08/13 15:08:47]

You can also use ActivateSplitMode() if you land this after
https://codereview.chromium.org/459613008/

+    const aura::Window::Windows& windows =
+        window_list_provider_->GetWindowList();
+    const aura::Window::Windows::const_iterator iter =
+        std::find(windows.begin(), windows.end(), left_window_);
+    // TODO(oshima): Make WindowManagerImpl accessible within athena/wm.
+    right_window_ = (iter == windows.begin() ? *(iter + 1) : * (iter - 1));
+
+    separator_position_ = container_->bounds().width() / 2;
+
+    const gfx::Transform transform;
+    left_window_->SetTransform(transform);
+    right_window_->SetTransform(transform);
+    const gfx::Rect& bounds = container_->bounds();
+    int middle = bounds.width() / 2;
+    left_window_->SetBounds(gfx::Rect(0, 0, middle, bounds.height()));
+    right_window_->SetBounds(gfx::Rect(middle, 0, middle, bounds.height()));
+    state_ = ACTIVE;
+  }
+}
+
 void SplitViewController::UpdateLayout(bool animate) {
-  if  (!left_window_)
+  if (!left_window_)
     return;
   CHECK(right_window_);
   gfx::Transform left_transform;
   gfx::Transform right_transform;
-  int container_width = container_->GetBoundsInScreen().width();
+  int container_width = container_->bounds().width();
   if (state_ == ACTIVE) {
     // This method should only be called once in ACTIVE state when
     // the left and rightwindows are still full screen and need to be resized.
     CHECK_EQ(left_window_->bounds().width(), container_width);
     CHECK_EQ(right_window_->bounds().width(), container_width);
     // Windows should be resized via an animation when entering the ACTIVE
     // state.
     CHECK(animate);
     // We scale the windows here, but when the animation finishes, we reset
     // the scaling and update the window bounds to the proper size - see
@@ skipping 12 matching lines @@
 }
 
 void SplitViewController::SetWindowTransform(aura::Window* window,
                                              const gfx::Transform& transform,
                                              bool animate) {
   if (animate) {
     scoped_refptr<ui::LayerAnimator> animator = window->layer()->GetAnimator();
     ui::ScopedLayerAnimationSettings settings(animator);
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    settings.AddObserver(new CallbackAnimationObserver(
+    settings.AddObserver(new ClosureAnimationObserver(
         base::Bind(&SplitViewController::OnAnimationCompleted,
                    weak_factory_.GetWeakPtr(),
                    window)));
     window->SetTransform(transform);
   } else {
     window->SetTransform(transform);
   }
 }
 
 void SplitViewController::OnAnimationCompleted(aura::Window* window) {
@@ skipping 23 matching lines @@
       if (state_ == INACTIVE)
         right_window_ = NULL;
     }
   }
 }
 
 void SplitViewController::UpdateSeparatorPositionFromScrollDelta(float delta) {
   gfx::Screen* screen = gfx::Screen::GetScreenFor(container_);
   const gfx::Rect& display_bounds =
       screen->GetDisplayNearestWindow(container_).bounds();
-  gfx::Rect container_bounds = container_->GetBoundsInScreen();
+  gfx::Rect container_bounds = container_->bounds();
   separator_position_ =
       delta > 0 ? ((int)delta) + display_bounds.x() - container_bounds.x()
                 : display_bounds.right() - container_bounds.x() + delta;
 }
 
 aura::Window* SplitViewController::GetCurrentActivityWindow() {
   if (!current_activity_window_) {
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
     if (windows.empty())
       return NULL;
@@ skipping 46 matching lines @@
   UpdateLayout(false);
 }
 
 // Max distance from the scroll end position to the middle of the screen where
 // we would go into the split view mode.
 const int kMaxDistanceFromMiddle = 120;
 void SplitViewController::ScrollEnd() {
   if (state_ != SCROLLING)
     return;
 
-  int container_width = container_->GetBoundsInScreen().width();
+  int container_width = container_->bounds().width();
   if (std::abs(container_width / 2 - separator_position_) <=
       kMaxDistanceFromMiddle) {
     state_ = ACTIVE;
     separator_position_ = container_width / 2;
   } else if (separator_position_ < container_width / 2) {
     separator_position_ = 0;
     current_activity_window_ = right_window_;
     state_ = INACTIVE;
   } else {
     separator_position_ = container_width;
     current_activity_window_ = left_window_;
     state_ = INACTIVE;
   }
   UpdateLayout(true);
 }
 
 void SplitViewController::ScrollUpdate(float delta) {
   if (state_ != SCROLLING)
     return;
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in vertical orientation, in full screen.
-  bool result = (!window_manager_->IsOverviewModeActive() &&
-                 !IsSplitViewModeActive() &&
-                 window_list_provider_->GetWindowList().size() >= 2);
+  bool result =
+      (!window_manager_->IsOverviewModeActive() && !IsSplitViewModeActive() &&
+       window_list_provider_->GetWindowList().size() >= 2);
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowManagerObserver overrides
 void SplitViewController::OnOverviewModeEnter() {
   if (state_ == ACTIVE) {
-    CHECK(left_window_);
-    CHECK(right_window_);
-    window_list_provider_->MoveToFront(right_window_);
-    window_list_provider_->MoveToFront(left_window_);
-    // TODO(mfomitchev): This shouldn't be done here, but the overview mode's
-    // transition animation currently looks bad if the starting transform of
-    // any window is not gfx::Transform().
-    right_window_->SetTransform(gfx::Transform());
+    ToggleSplitView();

[mfomitchev, 2014/08/12 18:52:50]

Not doing MoveToFront() can screw up the window order. 

Also, you can imagine ToggleSplitView() doing animations in the future which we
wouldn't want here.

I don't know if there's a good reason to change this now. This code will be
rewritten anyway once we implement overview-splitview.

   } else if (current_activity_window_) {
+    CHECK_EQ(INACTIVE, state_);

[mfomitchev, 2014/08/12 18:52:50]

This may not hold - you can hit the overview hot key when SplitViewController is
in the SCROLLING state.

     window_list_provider_->MoveToFront(current_activity_window_);
+    left_window_ = NULL;
+    right_window_ = NULL;
+    current_activity_window_ = NULL;
   }
-  state_ = INACTIVE;
-  left_window_ = NULL;
-  right_window_ = NULL;
-  current_activity_window_ = NULL;
 }
 
 void SplitViewController::OnOverviewModeExit() {
 }
 
 }  // namespace athena