Disable screen rotation when splitview is engaged and only allow splitview in landscape.

athena/wm/split_view_controller.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "athena/wm/split_view_controller.h"
 
 #include <cmath>
 
+#include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "base/bind.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/window_util.h"
 
 namespace athena {
 
 namespace {
 
 // Returns a target transform which is suitable for animating a windows's
 // bounds.
 gfx::Transform GetTargetTransformForBoundsAnimation(const gfx::Rect& from,
                                                     const gfx::Rect& to) {
   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),
@@ skipping 35 matching lines @@
 
   if (!right && iter != windows.rend()) {
     right = *iter;
     iter++;
     if (right == left && iter != windows.rend()) {
       right = *iter;
       iter++;
     }
   }
 
-  state_ = ACTIVE;
+  SetState(ACTIVE);
   if (right_window_ != right) {
     right_window_ = right;
     container_->StackChildAtTop(right_window_);
   }
   if (left_window_ != left) {
     left_window_ = left;
     container_->StackChildAtTop(left_window_);
   }
   UpdateLayout(true);
 }
@@ skipping 15 matching lines @@
   else
     right_window_ = replace_with;
   wm::ActivateWindow(replace_with);
   UpdateLayout(false);
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
-  state_ = INACTIVE;
+  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());
 }
 
 gfx::Rect SplitViewController::GetRightTargetBounds() {
   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;
+
+  state_ = state;
+  ScreenManager::Get()->SetRotationLocked(state_ != INACTIVE);
+}
+
 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_))
       left_window_->Hide();
     if (!wm::IsActiveWindow(right_window_))
       right_window_->Hide();
     SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
     return;
   }
 
   left_window_->Show();
@@ skipping 71 matching lines @@
                 : display_bounds.right() - container_bounds.x() + delta;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BezelController::ScrollDelegate:
 
 void SplitViewController::ScrollBegin(BezelController::Bezel bezel,
                                       float delta) {
   if (!CanScroll())
     return;
-  state_ = SCROLLING;
+  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);
@@ skipping 12 matching lines @@
 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_) <=
       kMaxDistanceFromMiddle) {
-    state_ = ACTIVE;
+    SetState(ACTIVE);
     separator_position_ = container_width / 2;
   } else if (separator_position_ < container_width / 2) {
     separator_position_ = 0;
-    state_ = INACTIVE;
+    SetState(INACTIVE);
     wm::ActivateWindow(right_window_);
   } else {
     separator_position_ = container_width;
-    state_ = INACTIVE;
+    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 vertical orientation, in full screen.
+  // TODO(mfomitchev): return false in full screen.
   bool result = (!IsSplitViewModeActive() &&
-                 window_list_provider_->GetWindowList().size() >= 2);
+                 window_list_provider_->GetWindowList().size() >= 2 &&
+                 IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
+                     GetDisplayNearestWindow(container_).rotation()));
   return result;
 }
 
 }  // namespace athena