Add key based scrolling on magnified screen for kiosk mode.

ash/magnifier/magnification_controller.cc

 // Copyright (c) 2012 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 "ash/magnifier/magnification_controller.h"
 
+#include "ash/accelerators/accelerator_controller.h"
 #include "ash/accessibility_delegate.h"
+#include "ash/ash_switches.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray_delegate.h"
+#include "base/command_line.h"
 #include "base/synchronization/waitable_event.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_transformer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
@@ skipping 13 matching lines @@
 const float kMinMagnifiedScaleThreshold = 1.1f;
 const float kNonMagnifiedScale = 1.0f;
 
 const float kInitialMagnifiedScale = 2.0f;
 const float kScrollScaleChangeFactor = 0.05f;
 
 // Threadshold of panning. If the cursor moves to within pixels (in DIP) of
 // |kPanningMergin| from the edge, the view-port moves.
 const int kPanningMergin = 100;
 
+bool magnifier_accelerator_enabled = false;
+
 void MoveCursorTo(aura::RootWindow* root_window,
                   const gfx::Point& root_location) {
   gfx::Point3F host_location_3f(root_location);
   root_window->host()->GetRootTransform().TransformPoint(&host_location_3f);
   root_window->MoveCursorToHostLocation(
       gfx::ToCeiledPoint(host_location_3f.AsPointF()));
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
   // MagnificationController overrides:
   virtual void SetEnabled(bool enabled) OVERRIDE;
   virtual bool IsEnabled() const OVERRIDE;
   virtual void SetScale(float scale, bool animate) OVERRIDE;
   virtual float GetScale() const OVERRIDE { return scale_; }
   virtual void MoveWindow(int x, int y, bool animate) OVERRIDE;
   virtual void MoveWindow(const gfx::Point& point, bool animate) OVERRIDE;
   virtual gfx::Point GetWindowPosition() const OVERRIDE {
     return gfx::ToFlooredPoint(origin_);
   }
-  virtual void EnsureRectIsVisible(const gfx::Rect& rect,
-                                   bool animate) OVERRIDE;
-  virtual void EnsurePointIsVisible(const gfx::Point& point,
-                                    bool animate) OVERRIDE;
+  virtual void SetScrollDirection(ScrollDirection direction) OVERRIDE;
+
   // For test
   virtual gfx::Point GetPointOfInterestForTesting() OVERRIDE {
     return point_of_interest_;
   }
 
  private:
   // ui::ImplicitAnimationObserver overrides:
   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // aura::WindowObserver overrides:
   virtual void OnWindowDestroying(aura::Window* root_window) OVERRIDE;
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE;
 
   // Redraws the magnification window with the given origin position and the
   // given scale. Returns true if the window is changed; otherwise, false.
   // These methods should be called internally just after the scale and/or
   // the position are changed to redraw the window.
   bool Redraw(const gfx::PointF& position, float scale, bool animate);
   bool RedrawDIP(const gfx::PointF& position, float scale, bool animate);
 
+  // 1) If the screen is scrolling (i.e. animating) and should scroll further,
+  // it does nothing.
+  // 2) If the screen is scrolling (i.e. animating) and the direction is NONE,
+  // it stops the scrolling animation.
+  // 3) If the direction is set to value other than NONE, it starts the
+  // scrolling/ animation towards that direction.
+  void StartOrStopScrollIfNecessary();
+
   // Redraw with the given zoom scale keeping the mouse cursor location. In
   // other words, zoom (or unzoom) centering around the cursor.
   void RedrawKeepingMousePosition(float scale, bool animate);
 
-  // Ensures that the given point, rect or last mouse location is inside
-  // magnification window. If not, the controller moves the window to contain
-  // the given point/rect.
-  void EnsureRectIsVisibleWithScale(const gfx::Rect& target_rect,
-                                    float scale,
-                                    bool animate);
-  void EnsureRectIsVisibleDIP(const gfx::Rect& target_rect_in_dip,
-                              float scale,
-                              bool animate);
-  void EnsurePointIsVisibleWithScale(const gfx::Point& point,
-                                     float scale,
-                                     bool animate);
   void OnMouseMove(const gfx::Point& location);
 
   // Move the mouse cursot to the given point. Actual move will be done when
   // the animation is completed. This should be called after animation is
   // started.
   void AfterAnimationMoveCursorTo(const gfx::Point& location);
 
   // Switch Magnified RootWindow to |new_root_window|. This does following:
   //  - Unzoom the current root_window.
   //  - Zoom the given new root_window |new_root_window|.
@@ skipping 33 matching lines @@
   gfx::Point position_after_animation_;
 
   // Stores the last mouse cursor (or last touched) location. This value is
   // used on zooming to keep this location visible.
   gfx::Point point_of_interest_;
 
   // Current scale, origin (left-top) position of the magnification window.
   float scale_;
   gfx::PointF origin_;
 
+  ScrollDirection scroll_direction_;
+
   DISALLOW_COPY_AND_ASSIGN(MagnificationControllerImpl);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl:
 
 MagnificationControllerImpl::MagnificationControllerImpl()
-    : root_window_(ash::Shell::GetPrimaryRootWindow()),
+    : root_window_(Shell::GetPrimaryRootWindow()),
       is_on_animation_(false),
       is_enabled_(false),
       move_cursor_after_animation_(false),
-      scale_(kNonMagnifiedScale) {
+      scale_(kNonMagnifiedScale),
+      scroll_direction_(SCROLL_NONE) {
   Shell::GetInstance()->AddPreTargetHandler(this);
   root_window_->AddObserver(this);
   point_of_interest_ = root_window_->bounds().CenterPoint();
 }
 
 MagnificationControllerImpl::~MagnificationControllerImpl() {
   root_window_->RemoveObserver(this);
 
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
@@ skipping 81 matching lines @@
       internal::CreateRootWindowTransformerForDisplay(root_window_, display));
   root_window_->GetDispatcher()->host()->SetRootWindowTransformer(
       transformer.Pass());
 
   if (animate)
     is_on_animation_ = true;
 
   return true;
 }
 
-void MagnificationControllerImpl::EnsureRectIsVisibleWithScale(
-    const gfx::Rect& target_rect,
-    float scale,
-    bool animate) {
-  const gfx::Rect target_rect_in_dip =
-      ui::ConvertRectToDIP(root_window_->layer(), target_rect);
-  EnsureRectIsVisibleDIP(target_rect_in_dip, scale, animate);
-}
+void MagnificationControllerImpl::StartOrStopScrollIfNecessary() {
+  // This value controls the scrolling speed.
+  const int kMoveOffset = 40;
+  if (is_on_animation_) {
+    if (scroll_direction_ == SCROLL_NONE)
+      root_window_->layer()->GetAnimator()->StopAnimating();
+    return;
+  }
 
-void MagnificationControllerImpl::EnsureRectIsVisibleDIP(
-    const gfx::Rect& target_rect,
-    float scale,
-    bool animate) {
-  ValidateScale(&scale);
-
-  const gfx::Rect window_rect = gfx::ToEnclosingRect(GetWindowRectDIP(scale));
-  if (scale == scale_ && window_rect.Contains(target_rect))
-    return;
-
-  // TODO(yoshiki): Un-zoom and change the scale if the magnification window
-  // can't contain the whole given rect.
-
-  gfx::Rect rect = window_rect;
-  if (target_rect.width() > rect.width())
-    rect.set_x(target_rect.CenterPoint().x() - rect.x() / 2);
-  else if (target_rect.right() < rect.x())
-    rect.set_x(target_rect.right());
-  else if (rect.right() < target_rect.x())
-    rect.set_x(target_rect.x() - rect.width());
-
-  if (rect.height() > window_rect.height())
-    rect.set_y(target_rect.CenterPoint().y() - rect.y() / 2);
-  else if (target_rect.bottom() < rect.y())
-    rect.set_y(target_rect.bottom());
-  else if (rect.bottom() < target_rect.y())
-    rect.set_y(target_rect.y() - rect.height());
-
-  RedrawDIP(rect.origin(), scale, animate);
-}
-
-void MagnificationControllerImpl::EnsurePointIsVisibleWithScale(
-    const gfx::Point& point,
-    float scale,
-    bool animate) {
-  EnsureRectIsVisibleWithScale(gfx::Rect(point, gfx::Size(0, 0)),
-                               scale,
-                               animate);
+  gfx::PointF new_origin = origin_;
+  switch (scroll_direction_) {
+    case SCROLL_NONE:
+      // No need to take action.
+      return;
+    case SCROLL_LEFT:
+      new_origin.Offset(-kMoveOffset, 0);
+      break;
+    case SCROLL_RIGHT:
+      new_origin.Offset(kMoveOffset, 0);
+      break;
+    case SCROLL_UP:
+      new_origin.Offset(0, -kMoveOffset);
+      break;
+    case SCROLL_DOWN:
+      new_origin.Offset(0, kMoveOffset);
+      break;
+  }
+  RedrawDIP(new_origin, scale_, true);
 }
 
 void MagnificationControllerImpl::OnMouseMove(const gfx::Point& location) {
   DCHECK(root_window_);
 
   gfx::Point mouse(location);
 
   int x = origin_.x();
   int y = origin_.y();
   bool start_zoom = false;
@@ skipping 99 matching lines @@
     MoveCursorTo(root_window_->GetDispatcher(), position_after_animation_);
     move_cursor_after_animation_ = false;
 
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root_window_);
     if (cursor_client)
       cursor_client->EnableMouseEvents();
   }
 
   is_on_animation_ = false;
+
+  StartOrStopScrollIfNecessary();
 }
 
 void MagnificationControllerImpl::OnWindowDestroying(
     aura::Window* root_window) {
   if (root_window == root_window_) {
     // There must be at least one root window because this controller is
     // destroyed before the root windows get destroyed.
     DCHECK(root_window);
 
     aura::Window* target_root_window = Shell::GetTargetRootWindow();
@@ skipping 36 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: MagnificationController implementation
 
 void MagnificationControllerImpl::SetScale(float scale, bool animate) {
   if (!is_enabled_)
     return;
 
   ValidateScale(&scale);
-  ash::Shell::GetInstance()->accessibility_delegate()->
+  Shell::GetInstance()->accessibility_delegate()->
       SaveScreenMagnifierScale(scale);
   RedrawKeepingMousePosition(scale, animate);
 }
 
 void MagnificationControllerImpl::MoveWindow(int x, int y, bool animate) {
   if (!is_enabled_)
     return;
 
   Redraw(gfx::Point(x, y), scale_, animate);
 }
 
 void MagnificationControllerImpl::MoveWindow(const gfx::Point& point,
                                              bool animate) {
   if (!is_enabled_)
     return;
 
   Redraw(point, scale_, animate);
 }
 
-void MagnificationControllerImpl::EnsureRectIsVisible(
-    const gfx::Rect& target_rect,
-    bool animate) {
-  if (!is_enabled_)
-    return;
-
-  EnsureRectIsVisibleWithScale(target_rect, scale_, animate);
-}
-
-void MagnificationControllerImpl::EnsurePointIsVisible(
-    const gfx::Point& point,
-    bool animate) {
-  if (!is_enabled_)
-    return;
-
-  EnsurePointIsVisibleWithScale(point, scale_, animate);
+void MagnificationControllerImpl::SetScrollDirection(
+    ScrollDirection direction) {
+  scroll_direction_ = direction;
+  StartOrStopScrollIfNecessary();
 }
 
 void MagnificationControllerImpl::SetEnabled(bool enabled) {
+  Shell* shell = Shell::GetInstance();
   if (enabled) {
     float scale =
-        ash::Shell::GetInstance()->accessibility_delegate()->
+        Shell::GetInstance()->accessibility_delegate()->
         GetSavedScreenMagnifierScale();
     if (scale <= 0.0f)
       scale = kInitialMagnifiedScale;
     ValidateScale(&scale);
 
     // Do nothing, if already enabled with same scale.
     if (is_enabled_ && scale == scale_)
       return;
 
     is_enabled_ = enabled;
     RedrawKeepingMousePosition(scale, true);
-    ash::Shell::GetInstance()->accessibility_delegate()->
-        SaveScreenMagnifierScale(scale);
+    shell->accessibility_delegate()->SaveScreenMagnifierScale(scale);
+    if (IsMagnifierAcceleratorsEnabled())
+      shell->accelerator_controller()->InstallMagnifierAccelerators();
   } else {
     // Do nothing, if already disabled.
     if (!is_enabled_)
       return;
 
     RedrawKeepingMousePosition(kNonMagnifiedScale, true);
     is_enabled_ = enabled;
+    if (IsMagnifierAcceleratorsEnabled())
+      shell->accelerator_controller()->UninstallMagnifierAccelerators();
   }
 }
 
 bool MagnificationControllerImpl::IsEnabled() const {
   return is_enabled_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: aura::EventFilter implementation
 
@@ skipping 46 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
+// static
+bool MagnificationController::IsMagnifierAcceleratorsEnabled() {
+  return magnifier_accelerator_enabled ||
+      CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAshEnableMagnifierAccelerators);
+}
+
+// static
+void MagnificationController::SetMagnifierAcceleratorsEnabled(
+    bool enabled) {
+  magnifier_accelerator_enabled = enabled;
+}
+
 }  // namespace ash