Full Screen Magnifier:

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/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_handler.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"
+#include "ui/gfx/point_conversions.h"
+#include "ui/gfx/point_f.h"
+#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/corewm/compound_event_filter.h"
 
 namespace {
 
 const float kMaxMagnifiedScale = 4.0f;
 const float kMaxMagnifiedScaleThreshold = 4.0f;
 const float kMinMagnifiedScaleThreshold = 1.1f;
 const float kNonMagnifiedScale = 1.0f;
 
@@ skipping 14 matching lines @@
  public:
   MagnificationControllerImpl();
   virtual ~MagnificationControllerImpl();
 
   // MagnificationController overrides:
   virtual void SetEnabled(bool enabled) 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 origin_; }
+  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;
 
  private:
   // ui::ImplicitAnimationObserver overrides:
   virtual void OnImplicitAnimationsCompleted() 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::Point& position, float scale, bool animate);
-  bool RedrawDIP(const gfx::Point& position, float scale, bool animate);
+  bool Redraw(const gfx::PointF& position, float scale, bool animate);
+  bool RedrawDIP(const gfx::PointF& position, float scale, bool animate);
 
   // 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 MoveCursorToAfterAnimation(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|.
   //  - Switch the target window from current window to |new_root_window|.
   void SwitchTargetRootWindow(aura::RootWindow* new_root_window);
 
   // Returns if the magnification scale is 1.0 or not (larger then 1.0).
   bool IsMagnified() const;
 
   // Returns the default scale which depends on the login status.
   float GetDefaultZoomScale() const {
     user::LoginStatus login = Shell::GetInstance()->tray_delegate() ?
         Shell::GetInstance()->tray_delegate()->GetUserLoginStatus() :
         user::LOGGED_IN_NONE;
 
     // On login screen, don't magnify the screen by default.
     if (login == user::LOGGED_IN_NONE)
       return kNonMagnifiedScale;
 
     return kInitialMagnifiedScale;
   }
 
   // Returns the rect of the magnification window.
-  gfx::Rect GetWindowRectDIP(float scale) const;
+  gfx::RectF GetWindowRectDIP(float scale) const;
   // Returns the size of the root window.
   gfx::Size GetHostSizeDIP() const;
 
   // Correct the givin scale value if nessesary.
   void ValidateScale(float* scale);
 
   // ui::EventHandler overrides:
   virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   aura::RootWindow* root_window_;
 
   // True if the magnified window is in motion of zooming or un-zooming effect.
   // Otherwise, false.
   bool is_on_zooming_;
 
   bool is_enabled_;
 
+  // True if the cursor needs to move the given position after the animation
+  // will be finished. When using this, set |position_after_animation_| as well.
+  bool move_cursor_after_animation_;
+  // Stores the position of cursor to be moved after animation.
+  gfx::Point position_after_animation_;
+
   // Current scale, origin (left-top) position of the magnification window.
   float scale_;
-  gfx::Point origin_;
+  gfx::PointF origin_;
 
   DISALLOW_COPY_AND_ASSIGN(MagnificationControllerImpl);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl:
 
 MagnificationControllerImpl::MagnificationControllerImpl()
     : root_window_(ash::Shell::GetPrimaryRootWindow()),
       is_on_zooming_(false),
       is_enabled_(false),
+      move_cursor_after_animation_(false),
       scale_(std::numeric_limits<double>::min()) {
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 MagnificationControllerImpl::~MagnificationControllerImpl() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void MagnificationControllerImpl::RedrawKeepingMousePosition(
     float scale, bool animate) {
   gfx::Point mouse_in_root = root_window_->GetLastMouseLocationInRoot();
-  const gfx::Point origin =
-      gfx::Point(mouse_in_root.x() * (1.0f - 1.0f / scale),
-                 mouse_in_root.y() * (1.0f - 1.0f / scale));
-  Redraw(origin, scale, animate);
+
+  // mouse_in_root is invalid value when the cursor is hidden.
+  if (!root_window_->bounds().Contains(mouse_in_root))
+    return;
+
+  const gfx::PointF origin =
+      gfx::PointF(mouse_in_root.x() -
+                      (scale_ / scale) * (mouse_in_root.x() - origin_.x()),
+                  mouse_in_root.y() -
+                      (scale_ / scale) * (mouse_in_root.y() - origin_.y()));
+  bool changed = Redraw(origin, scale, animate);
+  if (changed && origin_ != origin)
+    MoveCursorToAfterAnimation(mouse_in_root);
 }
 
-bool MagnificationControllerImpl::Redraw(const gfx::Point& position,
+bool MagnificationControllerImpl::Redraw(const gfx::PointF& position,
                                          float scale,
                                          bool animate) {
-  const gfx::Point position_in_dip =
+  const gfx::PointF position_in_dip =
       ui::ConvertPointToDIP(root_window_->layer(), position);
   return RedrawDIP(position_in_dip, scale, animate);
 }
 
-bool MagnificationControllerImpl::RedrawDIP(const gfx::Point& position_in_dip,
+bool MagnificationControllerImpl::RedrawDIP(const gfx::PointF& position_in_dip,
                                             float scale,
                                             bool animate) {
-  int x = position_in_dip.x();
-  int y = position_in_dip.y();
+  float x = position_in_dip.x();
+  float y = position_in_dip.y();
 
   ValidateScale(&scale);
 
   if (x < 0)
     x = 0;
   if (y < 0)
     y = 0;
 
   const gfx::Size host_size_in_dip = GetHostSizeDIP();
-  const gfx::Size window_size_in_dip = GetWindowRectDIP(scale).size();
-  int max_x = host_size_in_dip.width() - window_size_in_dip.width();
-  int max_y = host_size_in_dip.height() - window_size_in_dip.height();
+  const gfx::SizeF window_size_in_dip = GetWindowRectDIP(scale).size();
+  float max_x = host_size_in_dip.width() - window_size_in_dip.width();
+  float max_y = host_size_in_dip.height() - window_size_in_dip.height();
   if (x > max_x)
     x = max_x;
   if (y > max_y)
     y = max_y;
 
   // Does nothing if both the origin and the scale are not changed.
   if (origin_.x() == x  &&
       origin_.y() == y &&
       scale == scale_) {
     return false;
@@ skipping 32 matching lines @@
       ui::ConvertRectToDIP(root_window_->layer(), target_rect);
   EnsureRectIsVisibleDIP(target_rect_in_dip, scale, animate);
 }
 
 void MagnificationControllerImpl::EnsureRectIsVisibleDIP(
     const gfx::Rect& target_rect,
     float scale,
     bool animate) {
   ValidateScale(&scale);
 
-  const gfx::Rect window_rect = GetWindowRectDIP(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())
@@ skipping 20 matching lines @@
                                animate);
 }
 
 void MagnificationControllerImpl::OnMouseMove(const gfx::Point& location) {
   gfx::Point mouse(location);
 
   int x = origin_.x();
   int y = origin_.y();
   bool start_zoom = false;
 
-  const gfx::Rect window_rect = GetWindowRectDIP(scale_);
+  const gfx::Rect window_rect = gfx::ToEnclosingRect(GetWindowRectDIP(scale_));
   const int left = window_rect.x();
   const int right = window_rect.right();
   const int width_margin = static_cast<int>(0.1f * window_rect.width());
   const int width_offset = static_cast<int>(0.5f * window_rect.width());
 
   if (mouse.x() < left + width_margin) {
     x -= width_offset;
     start_zoom = true;
   } else if (right - width_margin < mouse.x()) {
     x += width_offset;
@@ skipping 16 matching lines @@
 
   if (start_zoom && !is_on_zooming_) {
     bool ret = RedrawDIP(gfx::Point(x, y), scale_, true);
 
     if (ret) {
       is_on_zooming_ = true;
 
       int x_diff = origin_.x() - window_rect.x();
       int y_diff = origin_.y() - window_rect.y();
       // If the magnified region is moved, hides the mouse cursor and moves it.
-      if (x_diff != 0 || y_diff != 0) {
-        aura::client::CursorClient* cursor_client =
-            aura::client::GetCursorClient(root_window_);
-        if (cursor_client)
-          cursor_client->ShowCursor(false);
-        mouse.set_x(mouse.x() - (origin_.x() - window_rect.x()));
-        mouse.set_y(mouse.y() - (origin_.y() - window_rect.y()));
-        root_window_->MoveCursorTo(mouse);
-      }
+      if (x_diff != 0 || y_diff != 0)
+        MoveCursorToAfterAnimation(mouse);
     }
   }
 }
 
+void MagnificationControllerImpl::MoveCursorToAfterAnimation(
+    const gfx::Point& location) {
+  aura::client::CursorClient* cursor_client =
+      aura::client::GetCursorClient(root_window_);
+  if (cursor_client)
+    cursor_client->ShowCursor(false);
+  move_cursor_after_animation_ = true;
+  position_after_animation_ = location;
+}
+
 gfx::Size MagnificationControllerImpl::GetHostSizeDIP() const {
   return ui::ConvertSizeToDIP(root_window_->layer(),
                               root_window_->GetHostSize());
 }
 
-gfx::Rect MagnificationControllerImpl::GetWindowRectDIP(float scale) const {
+gfx::RectF MagnificationControllerImpl::GetWindowRectDIP(float scale) const {
   const gfx::Size size_in_dip =
       ui::ConvertSizeToDIP(root_window_->layer(),
                            root_window_->GetHostSize());
-  const int width = size_in_dip.width() / scale;
-  const int height = size_in_dip.height() / scale;
+  const float width = size_in_dip.width() / scale;
+  const float height = size_in_dip.height() / scale;
 
-  return gfx::Rect(origin_.x(), origin_.y(), width, height);
+  return gfx::RectF(origin_.x(), origin_.y(), width, height);
 }
 
 bool MagnificationControllerImpl::IsMagnified() const {
   return scale_ >= kMinMagnifiedScaleThreshold;
 }
 
 void MagnificationControllerImpl::ValidateScale(float* scale) {
   // Adjust the scale to just |kNonMagnifiedScale| if scale is smaller than
   // |kMinMagnifiedScaleThreshold|;
   if (*scale < kMinMagnifiedScaleThreshold)
     *scale = kNonMagnifiedScale;
 
   // Adjust the scale to just |kMinMagnifiedScale| if scale is bigger than
   // |kMinMagnifiedScaleThreshold|;
   if (*scale > kMaxMagnifiedScaleThreshold)
     *scale = kMaxMagnifiedScale;
 
   DCHECK(kNonMagnifiedScale <= *scale && *scale <= kMaxMagnifiedScale);
 }
 
 void MagnificationControllerImpl::OnImplicitAnimationsCompleted() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
+  if (move_cursor_after_animation_) {
+    root_window_->MoveCursorTo(position_after_animation_);
+    move_cursor_after_animation_ = false;
+  }
+  gfx::Point mouse_in_root = root_window_->GetLastMouseLocationInRoot();
   if (cursor_client)
     cursor_client->ShowCursor(true);
   is_on_zooming_ = false;
 }
 
 void MagnificationControllerImpl::SwitchTargetRootWindow(
     aura::RootWindow* new_root_window) {
   if (new_root_window == root_window_)
     return;
 
@@ skipping 122 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace internal
 }  // namespace ash