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_delegate.h"
+#include "ui/aura/window_targeter.h"
+#include "ui/base/cursor/cursor.h"
+#include "ui/base/hit_test.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"
+#include "ui/wm/public/window_types.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;
+
+// TODO(mfomitchev): Should this be moved to ui/views?

[sadrul, 2014/09/16 17:11:37]

No. This should be removed when crbug.com/414339 is fixed.

[mfomitchev, 2014/09/16 19:48:10]

Acknowledged.

+
+// 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);
+};
+
+// TODO(mfomitchev): This is a copy of EmptyWindowDelegate in

[sadrul, 2014/09/16 17:11:37]

You no longer need EmptyWindowDelegate. Remove.

[mfomitchev, 2014/09/16 19:48:10]

Done.

+// ash/root_window_controller.cc. Should we move this somewhere we can reuse in
+// both ash and athena? It looks like mojo::DummyDelegate could use this as
+// well.
+// Perhaps we could have ui/aura/empty_window_delegate.h or
+// aura::CreateEmptyWIndowDelegate() in ui/aura/window_delegate.h
+
+// A window delegate which does nothing. Used to create a window that
+// is a event target, but do nothing.
+class EmptyWindowDelegate : public aura::WindowDelegate {
+ public:
+  EmptyWindowDelegate() {}
+  virtual ~EmptyWindowDelegate() {}
+
+  // aura::WindowDelegate overrides:
+  virtual gfx::Size GetMinimumSize() const OVERRIDE {
+    return gfx::Size();
+  }
+  virtual gfx::Size GetMaximumSize() const OVERRIDE {
+    return gfx::Size();
+  }
+  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
+                               const gfx::Rect& new_bounds) OVERRIDE {}
+  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
+    return gfx::kNullCursor;
+  }
+  virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
+    return HTNOWHERE;
+  }
+  virtual bool ShouldDescendIntoChildForEventHandling(
+      aura::Window* child,
+      const gfx::Point& location) OVERRIDE {
+    return false;
+  }
+  virtual bool CanFocus() OVERRIDE {
+    return false;
+  }
+  virtual void OnCaptureLost() OVERRIDE {}
+  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {}
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {}
+  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+    delete this;
+  }
+  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {}
+  virtual bool HasHitTestMask() const OVERRIDE {
+    return false;
+  }
+  virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EmptyWindowDelegate);
+};
+
+// 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:
+  bool ShouldProcessEvent(ui::EventType event_type) {

[sadrul, 2014/09/16 17:11:36]

This is never used.

[mfomitchev, 2014/09/16 19:48:10]

Done.

+    return event_type == ui::ET_TOUCH_PRESSED;
+  }
+
+  // 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());
+
+    // Determine the bounds of the view in root window's coordinates.
+    gfx::Size view_size = priority_view_->size();
+    gfx::Point view_origin;
+    // Convert to widget's coords
+    views::View::ConvertPointToWidget(priority_view_, &view_origin);
+    // Convert to root window's coordinates
+    gfx::Rect window_bounds = window_->GetBoundsInRootWindow();
+    gfx::Point view_origin_in_root =
+        view_origin + gfx::Vector2d(window_bounds.x(), window_bounds.y());
+    gfx::Rect view_bounds_in_root = gfx::Rect(view_origin_in_root, view_size);

[sadrul, 2014/09/16 17:11:36]

Can you just use View::GetBoundsInScreen() instead?

[mfomitchev, 2014/09/16 19:48:10]

Done.

+
+    // 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_in_root;
+    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().x(),
+                                 event->root_location().y())) {

[sadrul, 2014/09/16 17:11:36]

Just .Contains(event->root_location())

[mfomitchev, 2014/09/16 19:48:10]

Done.

+      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_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++;
     }
   }
 
+  int container_width = container_->GetBoundsInScreen().width();
+  divider_position_ = container_width / 2;

[pkotwicz, 2014/09/16 20:02:47]

You should add a new method GetDefaultDividerPosition(). You compute this value
often enough that I think that it is worth it

[mfomitchev, 2014/09/22 21:11:00]

Done.

   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() {
-  gfx::Rect work_area =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
-  return gfx::Rect(0, 0, container_->bounds().width() / 2, work_area.height());
+void SplitViewController::InitializeDivider() {
+  CHECK(!divider_widget_);
+  CHECK(!drag_handle_);
+
+  drag_handle_ = CreateDragHandleView(DragHandle::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);

[pkotwicz, 2014/09/16 20:02:47]

The widget should be of views::Widget::InitParams::TYPE_POPUP

Widgets of TYPE_POPUP are not activatable by default. (So you won't need to
specify params.activatable)

[mfomitchev, 2014/09/22 21:11:00]

CONTROL is also not activatable by default. I have removed the explicit setting
of activatable to ACTIVATABLE_NO. It's not a popup, so I'd rather keep it
control unless there's a reason not to.

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

It does not matter in this case. Generally TYPE_CONTROL is used for
views::Widgets which have a views::Widget parent

For TYPE_CONTROL windows Widget::is_top_level() returns false and for TYPE_POPUP
windows Widget::is_top_level() returns true. This matters if the window can take
focus. See Widget::GetFocusManager()

Popup windows (e.g. JS alerts) use TYPE_WINDOW

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

Ok, changed to TYPE_POPUP

+  params.parent = container_;
+  params.accept_events = true;

[pkotwicz, 2014/09/16 20:02:47]

No need to specify as params.accept_events == true is the default

[mfomitchev, 2014/09/22 21:11:00]

Done.

+  params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
+  params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;

[sadrul, 2014/09/16 17:11:37]

Do we need the widget to be translucent?

[mfomitchev, 2014/09/16 19:48:10]

Done.

+  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());
+  views::ViewTargeter* targeter = new views::RootViewTargeter(
+      new StaticViewTargeterDelegate(drag_handle_),

[sadrul, 2014/09/16 17:11:37]

I think this StaticViewTargeterDelegate() is leaking?

[mfomitchev, 2014/09/16 19:48:10]

Done.

+      root_view);
+  divider_widget_->GetRootView()->SetEventTargeter(
+      scoped_ptr<views::ViewTargeter>(targeter));
 }
 
-gfx::Rect SplitViewController::GetRightTargetBounds() {
-  gfx::Rect work_area =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
+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() {

[pkotwicz, 2014/09/16 20:02:47]

We have to use the work area height. Otherwise, the window ends below the
minimized home card.
(Try http://x20web.corp.google.com/~pkotwicz/unimportant/bottom.html)

[mfomitchev, 2014/09/22 21:11:00]

Done.

+  int container_height = container_->bounds().height();
+  return gfx::Rect(
+      0, 0, divider_position_ - kDividerWidth / 2, container_height);
+}
+
+gfx::Rect SplitViewController::GetRightAreaBounds() {
   int container_width = container_->bounds().width();
-  return gfx::Rect(
-      container_width / 2, 0, container_width / 2, work_area.height());
+  int container_height = container_->bounds().height();
+  return gfx::Rect(divider_position_ + kDividerWidth / 2,
+                   0,
+                   container_width - divider_position_ - kDividerWidth / 2,
+                   container_height);
 }
 
 void SplitViewController::SetState(SplitViewController::State state) {
   if (state_ == state)
     return;
 
+  if (divider_widget_ == NULL)
+    InitializeDivider();

[pkotwicz, 2014/09/16 20:02:47]

Would it make sense to move InitializeDivider() into ShowDivider()?

[mfomitchev, 2014/09/22 21:11:00]

Well, it would work, but I don't know if one is better than the other. A bunch
of methods need the divider to be non-null, e.g. HideDivider().
Ideally I'd like to put InitializeDivider into the constructor, but that doesn't
work.
I could create GetDividerWidget() but seems like a bit of an overkill.

+
   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* active_window = window_list_provider_->GetWindowList().back();

[pkotwicz, 2014/09/16 20:02:48]

Nit: |active_window| -> |topmost_window|

[mfomitchev, 2014/09/22 21:11:00]

Done.

+    if (active_window != left_window_) {
       left_window_->Hide();
-    if (!wm::IsActiveWindow(right_window_))
+      right_window_->SetBounds(gfx::Rect(container_->bounds()));

[pkotwicz, 2014/09/16 20:02:48]

You probably meant: container_->bounds().size()

[mfomitchev, 2014/09/22 21:10:59]

Done. Good catch!

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

[pkotwicz, 2014/09/16 20:02:48]

Optional: It might be clearer if you first computed the desired window bounds
and then always called GetTransformForBounds().

[mfomitchev, 2014/09/22 21:11:00]

It's a bit more complicated than that though - I only do GetTransformForBounds
when I need to scale up. Otherwise I simply translate the window
(GetTransformForBounds would scale the window down, which I don't want).

-    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);
     right_window_->SetTransform(right_transform);
+    divider_widget_->GetNativeWindow()->SetTransform(divider_transform);

[pkotwicz, 2014/09/16 20:02:47]

Nit: Set the transforms on the windows in the same order in the animate and the
non-animate case e.g. |left_window_|, then |divider_widget_|, then
|right_window_|

[mfomitchev, 2014/09/22 21:11:00]

Done.

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

[pkotwicz, 2014/09/16 20:02:48]

Can we use |container_|->bounds() instead of |display_bounds|.

[mfomitchev, 2014/09/22 21:11:00]

|delta| is relative to the bezel, while divider_position_ is relative to the
container bounds. If we don't have display_bounds, how will we get the display
width (or display_bounds.right())?

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

From reading ShelfBezelEventFilter::OnGestureEvent() it looks like the bezel
does not contribute to the size of the screen. Maybe its different on Athena or
I am not reading the code correctly

[pkotwicz, 2014/09/23 14:34:09]

Leaving as is probably OK. The new code has the same behavior as the old code. I
should not be asking about potential suboptimalities which are not related to
the current CL

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

This was meant to support the case for when container doesn't start at the edge
of the screen. See discussion here:
https://codereview.chromium.org/420603011/diff/1/athena/wm/bezel_controller.c...
I don't mind discussing this further, but it obviously shouldn't block landing
of this CL :)

-  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())
     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);
   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) {
+    divider_position_ = container_width / 2;
     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);

[pkotwicz, 2014/09/16 20:02:48]

Should the divider hide at the end of the animation? I am ok if you do this as
part of another CL. I have filed crbug.com/414877 w.r.t to the divider animation
when entering split screen from overview mode

[mfomitchev, 2014/09/22 21:10:59]

Agreed, it would be good to fade it out or something like that.

     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_;

[pkotwicz, 2014/09/16 20:02:47]

Optional: It might be useful to cache |divider_start_position_|. That would
allow HandleScrollUpdate() and ScrollUpdate() to use more similar code.

[mfomitchev, 2014/09/22 21:11:00]

Done.

+  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_)
+    HideDivider();
+}
+
+void SplitViewController::OnOverviewModeExit() {
+  if (state_ != INACTIVE)
+    ShowDivider();
+}
+
+void SplitViewController::OnSplitViewModeEnter() {
+}
+
+void SplitViewController::OnSplitViewModeExit() {
+}
+
 }  // namespace athena