Adding split view divider widget.

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/screen/public/screen_manager.h"
 #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/closure_animation_observer.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 {
 
-// Returns a target transform which is suitable for animating a windows's
-// bounds.
-gfx::Transform GetTargetTransformForBoundsAnimation(const gfx::Rect& from,
-                                                    const gfx::Rect& to) {
+// Returns a target transform required to transform |from| to |to|.
+gfx::Transform GetTransformForBounds(const gfx::Rect& from,
+                                     const gfx::Rect& to) {
   gfx::Transform transform;
   transform.Translate(to.x() - from.x(), to.y() - from.y());
   transform.Scale(to.width() / static_cast<float>(from.width()),
                   to.height() / static_cast<float>(from.height()));
   return transform;
 }
 
 bool IsLandscapeOrientation(gfx::Display::Rotation rotation) {
   return rotation == gfx::Display::ROTATE_0 ||
          rotation == gfx::Display::ROTATE_180;
 }
 
 }  // namespace
 
 SplitViewController::SplitViewController(
     aura::Window* container,
     WindowListProvider* window_list_provider)
     : state_(INACTIVE),
       container_(container),
       window_list_provider_(window_list_provider),
       left_window_(NULL),
       right_window_(NULL),
-      separator_position_(0),
+      divider_position_(0),
       weak_factory_(this) {
 }
 
 SplitViewController::~SplitViewController() {
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
   return state_ == ACTIVE;
 }
 
@@ skipping 33 matching lines @@
 
   SetState(ACTIVE);
   if (right_window_ != right) {
     right_window_ = right;
     container_->StackChildAtTop(right_window_);
   }
   if (left_window_ != left) {
     left_window_ = left;
     container_->StackChildAtTop(left_window_);
   }
+  if (!divider_widget_) {
+    divider_widget_.reset(CreateDividerWidget());
+    divider_widget_->Show();
+  }
+

[sadrul, 2014/09/12 04:30:36]

Show() should be outside of the if?

[mfomitchev, 2014/09/12 20:49:07]

I changed the code so that Show/Hid is only done from SetState or when we
enter/exit overview mode.

   UpdateLayout(true);
 }
 
 void SplitViewController::ReplaceWindow(aura::Window* window,
                                         aura::Window* replace_with) {
   CHECK(IsSplitViewModeActive());
   CHECK(replace_with);
   CHECK(window == left_window_ || window == right_window_);
   CHECK(replace_with != left_window_ && replace_with != right_window_);
 #if !defined(NDEBUG)
@@ skipping 10 matching lines @@
   UpdateLayout(false);
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   SetState(INACTIVE);
   UpdateLayout(false);
   left_window_ = right_window_ = NULL;
+  CHECK(divider_widget_);
+  divider_widget_.reset();
 }
 
-gfx::Rect SplitViewController::GetLeftTargetBounds() {
+const int kDragHandleWidth = 4;
+const int kDragHandleHeight = 80;
+const int kDragHandleInnerMargin = 2;
+const int kDividerWidth = kDragHandleWidth + 2 * kDragHandleInnerMargin;

[Jun Mukai, 2014/09/08 19:32:00]

These const values should be in the anonymous namespace, usually appearing at
the top of the file.

[mfomitchev, 2014/09/12 19:58:42]

Done.

+
+views::Widget* SplitViewController::CreateDividerWidget() {
+  views::View* divider_view = CreateDragHandleView(DragHandle::HORIZONTAL,
+                                                   this,
+                                                   kDragHandleWidth,
+                                                   kDragHandleHeight,
+                                                   kDragHandleInnerMargin);
+  views::Widget* widget = new views::Widget();
+  views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
+  params.parent = container_;
+  params.accept_events = true;
+  params.activatable = views::Widget::InitParams::ACTIVATABLE_YES;
+  params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  widget->Init(params);
+  widget->SetContentsView(divider_view);
+  const gfx::Size& size =
+      gfx::Size(kDividerWidth, container_->bounds().height());

[sadrul, 2014/09/12 04:30:36]

The minimized home-card allows swiping anywhere (i.e. not just the white-bar in
the middle). I think we would want the same behaviour for this divider widget
too? (i.e. the divider should have the full height of the screen, and allow
dragging from anywhere, not just the white part in the center)

[mfomitchev, 2014/09/12 20:49:07]

I was trying to minimize the height of the widget, because bigger widget means
we are  stealing more pixels from the content. Especially now with priority
window targeter installed. "Content not chrome" and all that...
It should be easy enough to change if needed.

+  widget->SetSize(size);

[Jun Mukai, 2014/09/08 19:32:00]

why not simply SetSize(gfx::Size(...))?

Also, use param.initial_bounds instead of SetSize.

[mfomitchev, 2014/09/12 19:58:42]

Done. There's no intial_bounds, I just used bounds.

+
+  return widget;
+}
+
+gfx::Rect SplitViewController::GetLeftAreaBounds() {
   gfx::Rect work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
-  return gfx::Rect(0, 0, container_->bounds().width() / 2, work_area.height());
+  return gfx::Rect(
+      0, 0, divider_position_ - kDividerWidth / 2, work_area.height());
 }
 
-gfx::Rect SplitViewController::GetRightTargetBounds() {
+gfx::Rect SplitViewController::GetRightAreaBounds() {
   gfx::Rect work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
   int container_width = container_->bounds().width();
-  return gfx::Rect(
-      container_width / 2, 0, container_width / 2, work_area.height());
+  return gfx::Rect(divider_position_ + kDividerWidth / 2,
+                   0,
+                   container_width - divider_position_ - kDividerWidth / 2,
+                   work_area.height());
 }
 
 void SplitViewController::SetState(SplitViewController::State state) {
   if (state_ == state)
     return;
 
   state_ = state;
   ScreenManager::Get()->SetRotationLocked(state_ != INACTIVE);
 }
 
 void SplitViewController::UpdateLayout(bool animate) {
   CHECK(left_window_);
   CHECK(right_window_);
+  CHECK(divider_widget_);
 
   // Splitview can be activated from SplitViewController::ActivateSplitMode or
   // SplitViewController::ScrollEnd. Additionally we don't want to rotate the
   // screen while engaging splitview (i.e. state_ == SCROLLING).
   if (state_ == INACTIVE && !animate) {
-    if (!wm::IsActiveWindow(left_window_))
+    aura::Window* active_window = window_list_provider_->GetWindowList().back();
+    if (active_window != left_window_) {
       left_window_->Hide();
-    if (!wm::IsActiveWindow(right_window_))
+      right_window_->SetBounds(gfx::Rect(container_->bounds()));
+    }
+    if (active_window != right_window_) {
+      left_window_->SetBounds(gfx::Rect(container_->bounds()));
       right_window_->Hide();
-    SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
+    }
+    SetWindowTransforms(
+        gfx::Transform(), gfx::Transform(), gfx::Transform(), false);
     return;
   }
 
   left_window_->Show();
   right_window_->Show();
+  // TODO(mfomitchev): This makes the widget become activated, which may be
+  // bad to do every time we layout? Keeping this for now for consistency, but
+  // should be revisited (if fine - pls remove the comment).
+  divider_widget_->Show();

[sadrul, 2014/09/12 04:30:36]

Consider ShowInactive(), but perhaps the widget shouldn't be activate-able?

[mfomitchev, 2014/09/12 20:49:07]

ShowInactive() explicitly changes the state to inactive if it was active. I
wanted this to just show the widget w/o changing its "active" state. If the
widget is non-activatable, will it still be able to receive events?
BTW, I have changed the code so that this is only done in SetState() and on
overview mode enter/exit, so it's less of an issue now.

+  gfx::Transform divider_transform;
+  divider_transform.Translate(divider_position_ - kDividerWidth / 2, 0);
   if (state_ == ACTIVE) {
+    int container_width = container_->GetBoundsInScreen().width();
+    divider_position_ = container_width / 2;
     if (animate) {
-      gfx::Transform left_transform = GetTargetTransformForBoundsAnimation(
-          left_window_->bounds(), GetLeftTargetBounds());
-      gfx::Transform right_transform = GetTargetTransformForBoundsAnimation(
-          right_window_->bounds(), GetRightTargetBounds());
-      SetWindowTransforms(left_transform, right_transform, true);
+      gfx::Transform left_transform =
+          GetTransformForBounds(left_window_->bounds(), GetLeftAreaBounds());
+      gfx::Transform right_transform =
+          GetTransformForBounds(right_window_->bounds(), GetRightAreaBounds());
+      SetWindowTransforms(
+          left_transform, right_transform, divider_transform, true);
     } else {
-      left_window_->SetBounds(GetLeftTargetBounds());
-      right_window_->SetBounds(GetRightTargetBounds());
-      SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
+      left_window_->SetBounds(GetLeftAreaBounds());
+      right_window_->SetBounds(GetRightAreaBounds());
+      SetWindowTransforms(
+          gfx::Transform(), gfx::Transform(), divider_transform, false);
     }
   } else {
     gfx::Transform left_transform;
-    left_transform.Translate(separator_position_ - container_->bounds().width(),
-                             0);
     gfx::Transform right_transform;
-    right_transform.Translate(separator_position_, 0);
-    SetWindowTransforms(left_transform, right_transform, animate);
+    gfx::Rect left_area_bounds = GetLeftAreaBounds();
+    gfx::Rect right_area_bounds = GetRightAreaBounds();
+    // If the width of the window is greater than the width of the area which it
+    // is supposed to occupy - translate the window. Otherwise scale the window
+    // up to fill the target area.
+    if (left_window_->bounds().width() >= left_area_bounds.width()) {
+      left_transform.Translate(divider_position_ - left_window_->bounds().x() -
+                                   left_window_->bounds().width(),
+                               0);
+    } else {
+      left_transform =
+          GetTransformForBounds(left_window_->bounds(), left_area_bounds);
+    }
+    if (right_window_->bounds().width() >= right_area_bounds.width()) {
+      right_transform.Translate(divider_position_ - right_window_->bounds().x(),
+                                0);
+    } else {
+      right_transform =
+          GetTransformForBounds(right_window_->bounds(), right_area_bounds);
+    }
+    SetWindowTransforms(
+        left_transform, right_transform, divider_transform, animate);
   }
   // Note: |left_window_| and |right_window_| may be NULL if calling
   // SetWindowTransforms():
   // - caused the in-progress animation to abort.
   // - started a zero duration animation.
 }
 
 void SplitViewController::SetWindowTransforms(
     const gfx::Transform& left_transform,
     const gfx::Transform& right_transform,
+    const gfx::Transform& divider_transform,
     bool animate) {
   if (animate) {
     ui::ScopedLayerAnimationSettings left_settings(
         left_window_->layer()->GetAnimator());
     left_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     left_window_->SetTransform(left_transform);
 
+    if (divider_widget_) {

[sadrul, 2014/09/12 04:30:36]

There's a CHECK in DeactivateSplitMode()/UpdateLayout() for divider_widget_. So
I guess we expect divider_widget_ to be non-null here too, and remove the if?

[mfomitchev, 2014/09/12 20:49:07]

Done.

+      ui::ScopedLayerAnimationSettings divider_settings(
+          divider_widget_->GetNativeWindow()->layer()->GetAnimator());
+      divider_settings.SetPreemptionStrategy(
+          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      divider_widget_->GetNativeWindow()->SetTransform(divider_transform);
+    }
+
     ui::ScopedLayerAnimationSettings right_settings(
         right_window_->layer()->GetAnimator());
     right_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     right_settings.AddObserver(new ui::ClosureAnimationObserver(
         base::Bind(&SplitViewController::OnAnimationCompleted,
                    weak_factory_.GetWeakPtr())));
     right_window_->SetTransform(right_transform);
   } else {
     left_window_->SetTransform(left_transform);
     right_window_->SetTransform(right_transform);
+    if (divider_widget_)

[sadrul, 2014/09/12 04:30:36]

ditto

[mfomitchev, 2014/09/12 20:49:07]

Done.

+      divider_widget_->GetNativeWindow()->SetTransform(divider_transform);
   }
 }
 
 void SplitViewController::OnAnimationCompleted() {
   // Animation can be cancelled when deactivated.
   if (left_window_ == NULL)
     return;
   UpdateLayout(false);
 
   if (state_ == INACTIVE) {
     left_window_ = NULL;
     right_window_ = NULL;
+    divider_widget_.reset();
   }
 }
 
 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();
-  separator_position_ =
+  divider_position_ =
       delta > 0 ? ((int)delta) + display_bounds.x() - container_bounds.x()
                 : display_bounds.right() - container_bounds.x() + delta;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BezelController::ScrollDelegate:
 
 void SplitViewController::ScrollBegin(BezelController::Bezel bezel,
                                       float delta) {
   if (!CanScroll())
@@ skipping 10 matching lines @@
     right_window_ = current_window;
     left_window_ = *(iter + 1);
   } else {
     left_window_ = current_window;
     right_window_ = *(iter + 1);
   }
 
   CHECK(left_window_);
   CHECK(right_window_);
 
+  CHECK(!divider_widget_);
+  divider_widget_.reset(CreateDividerWidget());
+  divider_widget_->Show();
+
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
 void SplitViewController::ScrollEnd() {
   if (state_ != SCROLLING)
     return;
 
   // 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;
   int container_width = container_->GetBoundsInScreen().width();
-  if (std::abs(container_width / 2 - separator_position_) <=
+  if (std::abs(container_width / 2 - divider_position_) <=
       kMaxDistanceFromMiddle) {
     SetState(ACTIVE);
-    separator_position_ = container_width / 2;
-  } else if (separator_position_ < container_width / 2) {
-    separator_position_ = 0;
+  } else if (divider_position_ < container_width / 2) {
+    divider_position_ = 0;
     SetState(INACTIVE);
     wm::ActivateWindow(right_window_);
   } else {
-    separator_position_ = container_width;
+    divider_position_ = container_width;
     SetState(INACTIVE);
     wm::ActivateWindow(left_window_);
   }
   UpdateLayout(true);
 }
 
 void SplitViewController::ScrollUpdate(float delta) {
   if (state_ != SCROLLING)
     return;
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in full screen.
   bool result = (!IsSplitViewModeActive() &&
                  window_list_provider_->GetWindowList().size() >= 2 &&
                  IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
                      GetDisplayNearestWindow(container_).rotation()));
   return result;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// ScrollHandle::ScrollDelegate:
+
+void SplitViewController::HandleScrollBegin(float delta) {
+  CHECK(state_ == ACTIVE);
+  state_ = SCROLLING;
+  divider_position_ = delta + divider_position_;
+  UpdateLayout(false);
+}
+
+void SplitViewController::HandleScrollEnd() {
+  ScrollEnd();
+}
+
+void SplitViewController::HandleScrollUpdate(float delta) {
+  if (state_ != SCROLLING)
+    return;
+  divider_position_ = delta + container_->GetBoundsInScreen().width() / 2;
+  UpdateLayout(false);
+}
+
+bool SplitViewController::HandleCanScroll() {
+  CHECK(IsLandscapeOrientation(gfx::Screen::GetNativeScreen()
+                                   ->GetDisplayNearestWindow(container_)
+                                   .rotation()));
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// WindowManagerObserver:
+
+void SplitViewController::OnOverviewModeEnter() {
+  if (divider_widget_)
+    divider_widget_->Hide();
+}
+
+void SplitViewController::OnOverviewModeExit() {
+  if (divider_widget_)
+    divider_widget_->Show();
+}
+
+void SplitViewController::OnActivityOrderHasChanged() {
+}
+
 }  // namespace athena