Rotate screen in response to accelerator or device orientation sensors.

athena/screen/screen_manager_impl.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/screen/public/screen_manager.h"
 
 #include "athena/common/container_priorities.h"
 #include "athena/common/fill_layout_manager.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/background_controller.h"
@@ skipping 18 matching lines @@
                                  NULL);
 
 ScreenManager* instance = NULL;
 
 bool GrabsInput(aura::Window* container) {
   ScreenManager::ContainerParams* params =
       container->GetProperty(kContainerParamsKey);
   return params && params->grab_inputs;
 }
 
+bool IsRotationPortrait(gfx::Display::Rotation rotation) {
+  return rotation == gfx::Display::ROTATE_90 ||
+         rotation == gfx::Display::ROTATE_270;
+}
+
 // Returns the container which contains |window|.
 aura::Window* GetContainer(aura::Window* window) {
   // No containers for NULL or the root window itself.
   if (!window || !window->parent())
     return NULL;
   if (window->parent()->IsRootWindow())
     return window;
   return GetContainer(window->parent());
 }
 
@@ skipping 143 matching lines @@
 
   void Init();
 
  private:
   // ScreenManager:
   virtual aura::Window* CreateDefaultContainer(
       const ContainerParams& params) OVERRIDE;
   virtual aura::Window* CreateContainer(const ContainerParams& params) OVERRIDE;
   virtual aura::Window* GetContext() OVERRIDE { return root_window_; }
   virtual void SetBackgroundImage(const gfx::ImageSkia& image) OVERRIDE;
+  virtual gfx::Display::Rotation GetRotation() OVERRIDE;
+  virtual void SetRotation(gfx::Display::Rotation rotation) OVERRIDE;
 
   aura::Window* root_window_;
   aura::Window* background_window_;
+  gfx::Display::Rotation rotation_;
 
   scoped_ptr<BackgroundController> background_controller_;
   scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
   scoped_ptr<AcceleratorHandler> accelerator_handler_;
   scoped_ptr< ::wm::ScopedCaptureClient> capture_client_;
   scoped_ptr<aura::client::ScreenPositionClient> screen_position_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenManagerImpl);
 };
 
 ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
-    : root_window_(root_window) {
+    : root_window_(root_window),
+      rotation_(gfx::Display::ROTATE_0) {
   DCHECK(root_window_);
   DCHECK(!instance);
   instance = this;
 }
 
 ScreenManagerImpl::~ScreenManagerImpl() {
   aura::client::SetScreenPositionClient(root_window_, NULL);
   aura::client::SetWindowTreeClient(root_window_, NULL);
   instance = NULL;
 }
@@ skipping 88 matching lines @@
     root_window_->StackChildBelow(container, *iter);
 
   container->Show();
   return container;
 }
 
 void ScreenManagerImpl::SetBackgroundImage(const gfx::ImageSkia& image) {
   background_controller_->SetImage(image);
 }
 
+gfx::Display::Rotation ScreenManagerImpl::GetRotation() {
+  return rotation_;
+}
+
+void ScreenManagerImpl::SetRotation(gfx::Display::Rotation rotation) {
+  if (rotation == rotation_)
+    return;
+
+  gfx::Rect bounds(root_window_->bounds());
+  if (IsRotationPortrait(rotation) != IsRotationPortrait(rotation_)) {
+    bounds.set_size(gfx::Size(bounds.height(), bounds.width()));
+  }
+
+  rotation_ = rotation;
+  root_window_->SetBounds(bounds);
+  gfx::Transform transform;
+  switch (rotation) {
+    case gfx::Display::ROTATE_90:
+      transform.Translate(bounds.height(), 0);
+      transform.RotateAboutZAxis(90);
+      break;
+    case gfx::Display::ROTATE_180:
+      transform.Translate(bounds.width(), bounds.height());
+      transform.RotateAboutZAxis(180);
+      break;
+    case gfx::Display::ROTATE_270:
+      transform.Translate(0, bounds.width());
+      transform.RotateAboutZAxis(270);
+      break;
+    case gfx::Display::ROTATE_0:
+    default:
+      break;
+  }
+  root_window_->layer()->SetTransform(transform);

[oshima, 2014/08/01 17:15:11]

Note: this won't update gfx::Display objects. A code that relies on may
misbehave.

[flackr, 2014/08/06 14:13:51]

Noted.

+}
+
 }  // namespace
 
 ScreenManager::ContainerParams::ContainerParams(const std::string& n,
                                                 int priority)
     : name(n),
       can_activate_children(false),
       grab_inputs(false),
       z_order_priority(priority) {
 }
 
@@ skipping 16 matching lines @@
   delete instance;
   DCHECK(!instance);
 }
 
 // static
 wm::FocusRules* ScreenManager::CreateFocusRules() {
   return new AthenaFocusRules();
 }
 
 }  // namespace athena