Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(181)

Unified Diff: athena/wm/split_view_controller.cc

Issue 545393002: Adding split view divider widget. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fixing a NOTREACHED in the test Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « athena/wm/split_view_controller.h ('k') | athena/wm/window_manager_impl.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: athena/wm/split_view_controller.cc
diff --git a/athena/wm/split_view_controller.cc b/athena/wm/split_view_controller.cc
index 36ce6c230ddff40b9de3dfd9c1509125463b01b6..4fc0c519b45cb7b38cdd09c0f4f831b2967c9cc7 100644
--- a/athena/wm/split_view_controller.cc
+++ b/athena/wm/split_view_controller.cc
@@ -10,23 +10,128 @@
#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()),
@@ -49,7 +154,10 @@ SplitViewController::SplitViewController(
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) {
}
@@ -103,6 +211,7 @@ void SplitViewController::ActivateSplitMode(aura::Window* left,
if (right_window_ && right_window_ != left && right_window_ != right)
to_hide_.push_back(right_window_);
+ divider_position_ = GetDefaultDividerPosition();
SetState(ACTIVE);
right_window_ = right;
left_window_ = left;
@@ -134,41 +243,125 @@ void SplitViewController::DeactivateSplitMode() {
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_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, 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;
+ 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_))
+ 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();
- if (!wm::IsActiveWindow(right_window_))
+ 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(), false);
+ }
+ SetWindowTransforms(
+ gfx::Transform(), gfx::Transform(), gfx::Transform(), false);
return;
}
@@ -177,25 +370,46 @@ void SplitViewController::UpdateLayout(bool animate) {
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():
@@ -206,6 +420,7 @@ void SplitViewController::UpdateLayout(bool animate) {
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(
@@ -214,6 +429,12 @@ void SplitViewController::SetWindowTransforms(
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(
@@ -224,6 +445,7 @@ void SplitViewController::SetWindowTransforms(
right_window_->SetTransform(right_transform);
} else {
left_window_->SetTransform(left_transform);
+ divider_widget_->GetNativeWindow()->SetTransform(divider_transform);
right_window_->SetTransform(right_transform);
}
}
@@ -244,30 +466,24 @@ void SplitViewController::OnAnimationCompleted() {
}
}
-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);
const 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;
@@ -280,43 +496,90 @@ void SplitViewController::ScrollBegin(BezelController::Bezel bezel,
CHECK(left_window_);
CHECK(right_window_);
- UpdateSeparatorPositionFromScrollDelta(delta);
+ // Calculate divider_scroll_start_position_
+ 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() {
return CanActivateSplitViewMode();
}
+///////////////////////////////////////////////////////////////////////////////
+// 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() {
+ BezelScrollEnd();
+}
+
+void SplitViewController::HandleScrollUpdate(float delta) {
+ BezelScrollUpdate(delta);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// WindowManagerObserver:
+
+void SplitViewController::OnOverviewModeEnter() {
+ if (divider_widget_)
+ HideDivider();
+}
+
+void SplitViewController::OnOverviewModeExit() {
+ if (state_ != INACTIVE)
+ ShowDivider();
+}
+
+void SplitViewController::OnSplitViewModeEnter() {
+}
+
+void SplitViewController::OnSplitViewModeExit() {
+}
+
} // namespace athena
« no previous file with comments | « athena/wm/split_view_controller.h ('k') | athena/wm/window_manager_impl.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698