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_manager.h"
#include "athena/wm/window_list_provider_impl.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.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/activation_client.h"

namespace athena {

namespace {

const int kDragHandleWidth = 4;
const int kDragHandleHeight = 80;
const int kDragHandleMargin = 1;
const int kDividerWidth = kDragHandleWidth + 2 * kDragHandleMargin;

// Max distance from the scroll end position to the middle of the screen where
// we would go into the split view mode.
const float kMaxDistanceFromMiddle = 120.0f;

// The minimum x-velocity required for a fling to disengage split view mode
// when targeted to the drag handle.
const float kMinFlingVelocity = 800.0f;

enum WindowToActivate {
  // Do not activate either of |left_window_| or |right_window_|.
  WINDOW_NONE,
  // Activate |left_window_|.
  WINDOW_LEFT,
  // Activate |right_window_|.
  WINDOW_RIGHT
};

// Always returns the same target.
class StaticViewTargeterDelegate : public views::ViewTargeterDelegate {
 public:
  explicit StaticViewTargeterDelegate(views::View* target) : target_(target) {}

  ~StaticViewTargeterDelegate() override {}

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

  ~PriorityWindowTargeter() override { window_->RemoveObserver(this); }

 private:
  // aura::WindowTargeter:
  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:
  void OnWindowDestroying(aura::Window* window) override {
    DCHECK_EQ(window, window_);
    window_->RemoveObserver(this);
    window_ = nullptr;
  }

  // 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,
    WindowListProviderImpl* window_list_provider)
    : state_(INACTIVE),
      container_(container),
      window_list_provider_(window_list_provider),
      left_window_(nullptr),
      right_window_(nullptr),
      divider_position_(0),
      divider_scroll_start_position_(0),
      divider_widget_(nullptr),
      drag_handle_(nullptr),
      weak_factory_(this) {
  window_list_provider_->AddObserver(this);
}

SplitViewController::~SplitViewController() {
  window_list_provider_->RemoveObserver(this);
}

bool SplitViewController::CanActivateSplitViewMode() const {
  // TODO(mfomitchev): return false in full screen.
  return (!IsSplitViewModeActive() &&
              window_list_provider_->GetWindowList().size() >= 2 &&
              IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
                  GetDisplayNearestWindow(container_).rotation()));
}

bool SplitViewController::IsSplitViewModeActive() const {
  return state_ == ACTIVE;
}

void SplitViewController::ActivateSplitMode(aura::Window* left,
                                            aura::Window* right,
                                            aura::Window* to_activate) {
  const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
  aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
  if (state_ == ACTIVE) {
    if (!left && left_window_ != right)
      left = left_window_;
    if (!right && right_window_ != left)
      right = right_window_;
  }

  if (!left && iter != windows.rend()) {
    left = *iter;
    iter++;
    if (left == right && iter != windows.rend()) {
      left = *iter;
      iter++;
    }
  }

  if (!right && iter != windows.rend()) {
    right = *iter;
    iter++;
    if (right == left && iter != windows.rend()) {
      right = *iter;
      iter++;
    }
  }

  to_hide_.clear();
  if (left_window_ && left_window_ != left && left_window_ != right)
    to_hide_.push_back(left_window_);
  if (right_window_ && right_window_ != left && right_window_ != right)
    to_hide_.push_back(right_window_);

  left_window_ = left;
  right_window_ = right;

  divider_position_ = GetDefaultDividerPosition();
  SetState(ACTIVE);
  UpdateLayout(true);

  aura::client::ActivationClient* activation_client =
      aura::client::GetActivationClient(container_->GetRootWindow());
  aura::Window* active_window = activation_client->GetActiveWindow();
  if (to_activate) {
    CHECK(to_activate == left_window_ || to_activate == right_window_);
    wm::ActivateWindow(to_activate);
  } else if (active_window != left_window_ &&
             active_window != right_window_) {
    // A window which does not belong to an activity could be active.
    wm::ActivateWindow(left_window_);
  }
  active_window = activation_client->GetActiveWindow();

  if (active_window == left_window_)
    window_list_provider_->StackWindowBehindTo(right_window_, left_window_);
  else
    window_list_provider_->StackWindowBehindTo(left_window_, right_window_);
}

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_);
  DCHECK(window_list_provider_->IsValidWindow(replace_with));

  aura::Window* not_replaced = nullptr;
  if (window == left_window_) {
    left_window_ = replace_with;
    not_replaced = right_window_;
  } else {
    right_window_ = replace_with;
    not_replaced = left_window_;
  }
  UpdateLayout(false);

  wm::ActivateWindow(replace_with);
  window_list_provider_->StackWindowBehindTo(not_replaced, replace_with);

  window->SetTransform(gfx::Transform());
  window->Hide();
}

void SplitViewController::DeactivateSplitMode() {
  CHECK_EQ(ACTIVE, state_);
  SetState(INACTIVE);
  UpdateLayout(false);
  left_window_ = right_window_ = nullptr;
}

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_POPUP);
  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();
  return gfx::Rect(
      0, 0, divider_position_ - kDividerWidth / 2, work_area.height());
}

gfx::Rect SplitViewController::GetRightAreaBounds() {
  gfx::Rect work_area =
      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
  int container_width = container_->bounds().width();
  return gfx::Rect(divider_position_ + kDividerWidth / 2,
                   0,
                   container_width - divider_position_ - kDividerWidth / 2,
                   work_area.height());
}

void SplitViewController::OnWindowAddedToList(aura::Window* added_window) {
}

void SplitViewController::OnWindowRemovedFromList(aura::Window* removed_window,
                                                  int index) {
  if (!IsSplitViewModeActive() ||
      (removed_window != left_window_ && removed_window != right_window_)) {
    return;
  }

  DCHECK(!window_list_provider_->IsWindowInList(removed_window));

  const aura::Window::Windows windows = window_list_provider_->GetWindowList();
  CHECK_GE(static_cast<int>(windows.size()), 1);
  DCHECK_GE(index, static_cast<int>(windows.size() - 1));
  DCHECK_LE(index, static_cast<int>(windows.size()));

  if (windows.size() == 1) {
    DeactivateSplitMode();
    return;
  }

  aura::Window* next_window = *(windows.rbegin() + 1);
  if (removed_window == left_window_) {
    CHECK(right_window_ == windows.back());
    left_window_ = next_window;
  } else {
    CHECK(left_window_ == windows.back());
    CHECK(removed_window == right_window_);
    right_window_ = next_window;
  }
  UpdateLayout(false);
}

void SplitViewController::SetState(SplitViewController::State state) {
  if (state_ == state)
    return;

  if (divider_widget_ == nullptr)
    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) {
    gfx::Rect work_area =
        gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
    aura::Window* top_window = window_list_provider_->GetWindowList().back();
    if (top_window != left_window_) {
      // TODO(mfomitchev): Use to_hide_ instead
      left_window_->Hide();
      right_window_->SetBounds(gfx::Rect(work_area.size()));
    }
    if (top_window != right_window_) {
      left_window_->SetBounds(gfx::Rect(work_area.size()));
      // TODO(mfomitchev): Use to_hide_ instead
      right_window_->Hide();
    }
    SetWindowTransforms(
        gfx::Transform(), gfx::Transform(), gfx::Transform(), false);
    return;
  }

  left_window_->Show();
  right_window_->Show();

  gfx::Transform divider_transform;
  divider_transform.Translate(divider_position_, 0);
  if (state_ == ACTIVE) {
    if (animate) {
      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(GetLeftAreaBounds());
      right_window_->SetBounds(GetRightAreaBounds());
      SetWindowTransforms(
          gfx::Transform(), gfx::Transform(), divider_transform, false);
    }
  } else {
    gfx::Transform left_transform;
    gfx::Transform right_transform;
    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 nullptr 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_ == nullptr)
    return;
  UpdateLayout(false);

  for (size_t i = 0; i < to_hide_.size(); ++i)
    to_hide_[i]->Hide();
  to_hide_.clear();

  if (state_ == INACTIVE) {
    left_window_ = nullptr;
    right_window_ = nullptr;
  }
}

int SplitViewController::GetDefaultDividerPosition() {
  return container_->GetBoundsInScreen().width() / 2;
}

float SplitViewController::GetMaxDistanceFromMiddleForTest() const {
  return kMaxDistanceFromMiddle;
}

float SplitViewController::GetMinFlingVelocityForTest() const {
  return kMinFlingVelocity;
}

///////////////////////////////////////////////////////////////////////////////
// DragHandleScrollDelegate:

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(float velocity) {
  if (state_ != SCROLLING)
    return;

  int delta = GetDefaultDividerPosition() - divider_position_;
  WindowToActivate window = WINDOW_NONE;
  if (std::abs(velocity) > kMinFlingVelocity)
    window = velocity > 0 ? WINDOW_LEFT : WINDOW_RIGHT;
  else if (std::abs(delta) > kMaxDistanceFromMiddle)
    window = delta > 0 ? WINDOW_RIGHT : WINDOW_LEFT;

  switch (window) {
    case WINDOW_NONE:
      divider_position_ = GetDefaultDividerPosition();
      SetState(ACTIVE);
      break;
    case WINDOW_LEFT:
      divider_position_ = container_->GetBoundsInScreen().width();
      SetState(INACTIVE);
      wm::ActivateWindow(left_window_);
      break;
    case WINDOW_RIGHT:
      divider_position_ = 0;
      SetState(INACTIVE);
      wm::ActivateWindow(right_window_);
      break;
  }

  UpdateLayout(true);
}

void SplitViewController::HandleScrollUpdate(float delta) {
  if (state_ != SCROLLING)
    return;
  divider_position_ = divider_scroll_start_position_ + delta;
  UpdateLayout(false);
}

///////////////////////////////////////////////////////////////////////////////
// WindowManagerObserver:

void SplitViewController::OnOverviewModeEnter() {
  if (divider_widget_)
    HideDivider();
}

void SplitViewController::OnOverviewModeExit() {
  if (state_ != INACTIVE)
    ShowDivider();
}

void SplitViewController::OnSplitViewModeEnter() {
}

void SplitViewController::OnSplitViewModeExit() {
}

}  // namespace athena