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/scoped_window_targeter.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_targeter.h"
 #include "ui/compositor/closure_animation_observer.h"
-#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/layer.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/views/background.h"
+#include "ui/views/layout/box_layout.h"
+#include "ui/views/widget/root_view.h"
+#include "ui/views/widget/root_view_targeter.h"
+#include "ui/views/widget/widget.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) {
+const int kDragHandleWidth = 4;
+const int kDragHandleHeight = 80;
+const int kDragHandleMargin = 1;
+const int kDividerWidth = kDragHandleWidth + 2 * kDragHandleMargin;
+
+// Always returns the same target.
+class StaticViewTargeterDelegate : public views::ViewTargeterDelegate {
+ public:
+  explicit StaticViewTargeterDelegate(views::View* target) : target_(target) {}
+
+  virtual ~StaticViewTargeterDelegate() {}
+
+ private:
+  // views::ViewTargeterDelegate:
+  virtual views::View* TargetForRect(views::View* root,
+                                     const gfx::Rect& rect) OVERRIDE {
+    return target_;
+  }
+
+  // Not owned.
+  views::View* target_;
+
+  DISALLOW_COPY_AND_ASSIGN(StaticViewTargeterDelegate);
+};
+
+// Expands the effective target area of the window of the widget containing the
+// specified view. If the view is large enough to begin with, there should be
+// no change from the default targeting behavior.
+class PriorityWindowTargeter : public aura::WindowTargeter,
+                               public aura::WindowObserver {
+ public:
+  explicit PriorityWindowTargeter(views::View* priority_view)
+      : priority_view_(priority_view) {
+    CHECK(priority_view->GetWidget());
+    window_ = priority_view->GetWidget()->GetNativeWindow();
+    CHECK(window_);
+    window_->AddObserver(this);
+  }
+
+  virtual ~PriorityWindowTargeter() {
+    window_->RemoveObserver(this);
+  }
+
+ private:
+  // aura::WindowTargeter:
+  virtual ui::EventTarget* FindTargetForLocatedEvent(
+      ui::EventTarget* root,
+      ui::LocatedEvent* event) OVERRIDE {
+    if (!window_ || (event->type() != ui::ET_TOUCH_PRESSED))
+      return WindowTargeter::FindTargetForLocatedEvent(root, event);
+    CHECK_EQ(window_, priority_view_->GetWidget()->GetNativeWindow());
+
+    // Bounds of the view in root window's coordinates.
+    gfx::Rect view_bounds = priority_view_->GetBoundsInScreen();
+    // If there is a transform on the window's layer - apply it.
+    gfx::Transform window_transform = window_->layer()->transform();
+    gfx::RectF transformed_bounds_f = view_bounds;
+    window_transform.TransformRect(&transformed_bounds_f);
+    gfx::Rect transformed_bounds = gfx::Rect(transformed_bounds_f.x(),
+                                             transformed_bounds_f.y(),
+                                             transformed_bounds_f.width(),
+                                             transformed_bounds_f.height());
+    // Now expand the bounds to be at least
+    // kMinTouchDimension x kMinTouchDimension and target the event to the
+    // window if it falls within the expanded bounds
+    gfx::Point center = transformed_bounds.CenterPoint();
+    gfx::Rect extension_rect = gfx::Rect(
+        center.x() - kMinTouchDimension / 2,
+        center.y() - kMinTouchDimension / 2,
+        kMinTouchDimension,
+        kMinTouchDimension);
+    gfx::Rect extended_bounds =
+        gfx::UnionRects(transformed_bounds, extension_rect);
+    if (extended_bounds.Contains(event->root_location())) {
+      root->ConvertEventToTarget(window_, event);
+      return window_;
+    }
+
+    return WindowTargeter::FindTargetForLocatedEvent(root, event);
+  }
+
+  // aura::WindowObserver:
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+    DCHECK_EQ(window, window_);
+    window_->RemoveObserver(this);
+    window_ = NULL;
+  }
+
+  // Minimum dimension of a target to be comfortably touchable.
+  // The effective touch target area of |priority_window_| gets expanded so
+  // that it's width and height is ayt least |kMinTouchDimension|.
+  int const kMinTouchDimension = 26;
+
+  aura::Window* window_;
+  views::View* priority_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(PriorityWindowTargeter);
+};
+
+// 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),
+      divider_scroll_start_position_(0),
+      divider_widget_(NULL),
+      drag_handle_(NULL),
       weak_factory_(this) {
 }
 
 SplitViewController::~SplitViewController() {
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
   return state_ == ACTIVE;
 }
 
@@ skipping 24 matching lines @@
 
   if (!right && iter != windows.rend()) {
     right = *iter;
     iter++;
     if (right == left && iter != windows.rend()) {
       right = *iter;
       iter++;
     }
   }
 
+  divider_position_ = GetDefaultDividerPosition();
   SetState(ACTIVE);
   right_window_ = right;
   left_window_ = left;
   UpdateLayout(true);
 }
 
 void SplitViewController::ReplaceWindow(aura::Window* window,
                                         aura::Window* replace_with) {
   CHECK(IsSplitViewModeActive());
   CHECK(replace_with);
@@ skipping 15 matching lines @@
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   SetState(INACTIVE);
   UpdateLayout(false);
   left_window_ = right_window_ = NULL;
 }
 
-gfx::Rect SplitViewController::GetLeftTargetBounds() {
+void SplitViewController::InitializeDivider() {
+  CHECK(!divider_widget_);
+  CHECK(!drag_handle_);
+
+  drag_handle_ = CreateDragHandleView(DRAG_HANDLE_HORIZONTAL,
+                                     this,
+                                     kDragHandleWidth,
+                                     kDragHandleHeight);
+  views::View* content_view = new views::View;
+  content_view->set_background(
+      views::Background::CreateSolidBackground(SK_ColorBLACK));
+  views::BoxLayout* layout =
+      new views::BoxLayout(views::BoxLayout::kHorizontal,
+                           kDragHandleMargin,
+                           kDragHandleMargin,
+                           0);
+  layout->set_main_axis_alignment(views::BoxLayout::MAIN_AXIS_ALIGNMENT_CENTER);
+  layout->set_cross_axis_alignment(
+      views::BoxLayout::CROSS_AXIS_ALIGNMENT_CENTER);
+  content_view->SetLayoutManager(layout);
+  content_view->AddChildView(drag_handle_);
+
+  divider_widget_ = new views::Widget();
+  views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
+  params.parent = container_;
+  params.bounds = gfx::Rect(-kDividerWidth / 2,
+                            0,
+                            kDividerWidth,
+                            container_->bounds().height());
+  divider_widget_->Init(params);
+  divider_widget_->SetContentsView(content_view);
+
+  // Install a static view targeter on the root view which always targets
+  // divider_view.
+  // TODO(mfomitchev,tdanderson): This should not be needed:
+  // 1. crbug.com/414339 - divider_view is the only view and it completely
+  //    overlaps the root view.
+  // 2. The logic in ViewTargeterDelegate::TargetForRect could be improved to
+  //    work better for views that are narrow in one dimension and long in
+  //    another dimension.
+  views::internal::RootView* root_view =
+      static_cast<views::internal::RootView*>(divider_widget_->GetRootView());
+  view_targeter_delegate_.reset(new StaticViewTargeterDelegate(drag_handle_));
+  views::ViewTargeter* targeter =
+      new views::RootViewTargeter(view_targeter_delegate_.get(), root_view);
+  divider_widget_->GetRootView()->SetEventTargeter(
+      scoped_ptr<views::ViewTargeter>(targeter));
+}
+
+void SplitViewController::HideDivider() {
+  divider_widget_->Hide();
+  window_targeter_.reset();
+}
+
+void SplitViewController::ShowDivider() {
+  divider_widget_->Show();
+  if (!window_targeter_) {
+    scoped_ptr<ui::EventTargeter> window_targeter =
+        scoped_ptr<ui::EventTargeter>(new PriorityWindowTargeter(drag_handle_));
+    window_targeter_.reset(
+        new aura::ScopedWindowTargeter(container_, window_targeter.Pass()));
+  }
+}
+
+gfx::Rect SplitViewController::GetLeftAreaBounds() {
   gfx::Rect work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();

[pkotwicz, 2014/09/23 05:13:40]

Shouldn't this use |divider_position_| ?

How about this:

int width = 0;
int x = 0;
if (divider_position_ <= GetDefaultDividerPosition()) {
  width = GetDefaultDividerPosition() - kDividerWidth / 2;
  x = divider_position_ - kDividerWidth / 2 - width;
} else {
  width = divider_position_ - kDividerWidth / 2;
}
int height =
gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().height();

return gfx::Rect(x, 0, width, height);

[mfomitchev, 2014/09/23 15:46:02]

Oops, I totally messed this up by copy/pasting old code, thanks for catching!

The if() here wouldn't do too much good though - we'd still need the if in
UpdateLayout() because the window width can be half the screen width or full
screen width (depending on whether the window was in split mode) and our logic
for scale vs. translate depends on whether the target area width is greater than
the window width. We could pass the window into this method, but that would
complicate explaining what this method does, and I am not sure it would be
better than what we have now. The way it is now the method is very
straightforward - the bounds of the screen area to the left of the divider, and
I like that.

[pkotwicz, 2014/09/23 19:44:46]

I understand now, thanks!

   return gfx::Rect(0, 0, container_->bounds().width() / 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());
 }
 
 void SplitViewController::SetState(SplitViewController::State state) {
   if (state_ == state)
     return;
 
+  if (divider_widget_ == NULL)
+    InitializeDivider();
+
   state_ = state;
+
   ScreenManager::Get()->SetRotationLocked(state_ != INACTIVE);
+  if (state == INACTIVE)
+    HideDivider();
+  else
+    ShowDivider();
 }
 
 void SplitViewController::UpdateLayout(bool animate) {
   CHECK(left_window_);
   CHECK(right_window_);
-
   // 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* top_window = window_list_provider_->GetWindowList().back();
+    if (top_window != left_window_) {
       left_window_->Hide();
-    if (!wm::IsActiveWindow(right_window_))
+      right_window_->SetBounds(gfx::Rect(container_->bounds().size()));

[pkotwicz, 2014/09/23 19:44:46]

This is wrong. It needs to into account the work area height. I don't mind if
you fix this in a hacky way for now.

I will fix this in a better way in combination with properly sending
OnSplitViewModeEnter() when entering split view via the bezel

[mfomitchev, 2014/09/23 21:02:09]

Ok, updated.
I wish all activity windows were inside a container which had it's bounds set to
the work area bounds. Do you know why that is not done? It seems pretty hacky
the way we just use work area now. 

+    }
+    if (top_window != right_window_) {
+      left_window_->SetBounds(gfx::Rect(container_->bounds().size()));

[pkotwicz, 2014/09/23 19:44:46]

Ditto

[mfomitchev, 2014/09/23 21:02:09]

Done.

       right_window_->Hide();
-    SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
+    }
+    SetWindowTransforms(
+        gfx::Transform(), gfx::Transform(), gfx::Transform(), false);
     return;
   }
 
   left_window_->Show();
   right_window_->Show();
   window_list_provider_->MoveToFront(right_window_);
   window_list_provider_->MoveToFront(left_window_);
 
+  gfx::Transform divider_transform;
+  divider_transform.Translate(divider_position_, 0);
   if (state_ == ACTIVE) {
     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(
+          left_area_bounds.right() - left_window_->bounds().right(), 0);
+    } else {
+      left_transform =
+          GetTransformForBounds(left_window_->bounds(), left_area_bounds);
+    }
+    if (right_window_->bounds().width() >= right_area_bounds.width()) {
+      right_transform.Translate(
+          right_area_bounds.x() - 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);
 
+    ui::ScopedLayerAnimationSettings divider_widget_settings(
+        divider_widget_->GetNativeWindow()->layer()->GetAnimator());
+    divider_widget_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);
+    divider_widget_->GetNativeWindow()->SetTransform(divider_transform);
     right_window_->SetTransform(right_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;
   }
 }
 
-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_ =
-      delta > 0 ? ((int)delta) + display_bounds.x() - container_bounds.x()
-                : display_bounds.right() - container_bounds.x() + delta;
+int SplitViewController::GetDefaultDividerPosition() {
+  return container_->GetBoundsInScreen().width() / 2;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BezelController::ScrollDelegate:
 
-void SplitViewController::ScrollBegin(BezelController::Bezel bezel,
-                                      float delta) {
-  if (!CanScroll())
+void SplitViewController::BezelScrollBegin(BezelController::Bezel bezel,
+                                           float delta) {
+  if (!BezelCanScroll())
     return;
+
   SetState(SCROLLING);
 
   aura::Window::Windows windows = window_list_provider_->GetWindowList();
   CHECK(windows.size() >= 2);
   aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
   aura::Window* current_window = *(iter);
-  CHECK(wm::IsActiveWindow(current_window));
 
   if (delta > 0) {
     right_window_ = current_window;
     left_window_ = *(iter + 1);
   } else {
     left_window_ = current_window;
     right_window_ = *(iter + 1);
   }
 
   CHECK(left_window_);
   CHECK(right_window_);
 
-  UpdateSeparatorPositionFromScrollDelta(delta);
+  // Calculate divider_scroll_start_position_

[pkotwicz, 2014/09/23 19:44:46]

Nit: "|" around variable name and period at the end of the sentence

[mfomitchev, 2014/09/23 21:02:09]

Done.

+  gfx::Screen* screen = gfx::Screen::GetScreenFor(container_);
+  const gfx::Rect& display_bounds =
+      screen->GetDisplayNearestWindow(container_).bounds();
+  gfx::Rect container_bounds = container_->GetBoundsInScreen();
+  divider_scroll_start_position_ =
+      delta > 0 ? display_bounds.x() - container_bounds.x()
+                : display_bounds.right() - container_bounds.x();
+
+  divider_position_ = divider_scroll_start_position_ + delta;
   UpdateLayout(false);
 }
 
-void SplitViewController::ScrollEnd() {
+void SplitViewController::BezelScrollEnd() {
   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_) <=
+  const int default_divider_position = GetDefaultDividerPosition();
+  if (std::abs(default_divider_position - divider_position_) <=
       kMaxDistanceFromMiddle) {
+    divider_position_ = default_divider_position;
     SetState(ACTIVE);
-    separator_position_ = container_width / 2;
-  } else if (separator_position_ < container_width / 2) {
-    separator_position_ = 0;
+  } else if (divider_position_ < default_divider_position) {
+    divider_position_ = 0;
     SetState(INACTIVE);
     wm::ActivateWindow(right_window_);
   } else {
-    separator_position_ = container_width;
+    divider_position_ = container_->GetBoundsInScreen().width();
     SetState(INACTIVE);
     wm::ActivateWindow(left_window_);
   }
   UpdateLayout(true);
 }
 
-void SplitViewController::ScrollUpdate(float delta) {
+void SplitViewController::BezelScrollUpdate(float delta) {
   if (state_ != SCROLLING)
     return;
-  UpdateSeparatorPositionFromScrollDelta(delta);
+  divider_position_ = divider_scroll_start_position_ + delta;
   UpdateLayout(false);
 }
 
-bool SplitViewController::CanScroll() {
+bool SplitViewController::BezelCanScroll() {
   // 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_scroll_start_position_ = GetDefaultDividerPosition();
+  divider_position_ = divider_scroll_start_position_ + delta;
+  UpdateLayout(false);
+}
+
+void SplitViewController::HandleScrollEnd() {
+  BezelScrollEnd();
+}
+
+void SplitViewController::HandleScrollUpdate(float delta) {
+  BezelScrollUpdate(delta);
+}
+
+bool SplitViewController::HandleCanScroll() {
+  CHECK(IsLandscapeOrientation(gfx::Screen::GetNativeScreen()
+                                   ->GetDisplayNearestWindow(container_)
+                                   .rotation()));
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// WindowManagerObserver:
+
+void SplitViewController::OnOverviewModeEnter() {
+  if (divider_widget_)
+    HideDivider();
+}
+
+void SplitViewController::OnOverviewModeExit() {
+  if (state_ != INACTIVE)
+    ShowDivider();
+}
+
+void SplitViewController::OnSplitViewModeEnter() {
+}
+
+void SplitViewController::OnSplitViewModeExit() {
+}
+
 }  // namespace athena