Magnifier: Support wrapping the cursor between extended monitors

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/display/display_controller.h"
+#include "ash/display/screen_position_controller.h"
 #include "ash/shell.h"
+#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/shared/compound_event_filter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/gfx/point3.h"
 #include "ui/gfx/screen.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"
 
 namespace {
 
 const float kMaxMagnifiedScale = 4.0f;
 const float kMaxMagnifiedScaleThreshold = 4.0f;
 const float kMinMagnifiedScaleThreshold = 1.1f;
 const float kNonMagnifiedScale = 1.0f;
 
 const float kInitialMagnifiedScale = 2.0f;
 
+// Convets position from screen coordinate to root_window coordinate.
+void ConvertsCoordinateFromScreenToRoot(aura::RootWindow* root_window,
+                                        gfx::Point* point) {
+  aura::client::ScreenPositionClient* screen_position_client =
+      aura::client::GetScreenPositionClient(root_window);
+  screen_position_client->ConvertPointFromScreen(root_window, point);
+}
+
 }  // namespace
 
 namespace ash {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl:
 
 class MagnificationControllerImpl : virtual public MagnificationController,
                                     public aura::EventFilter,
@@ skipping 32 matching lines @@
                                     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);
 
+  // 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 rect of the magnification window.
   gfx::Rect 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);
@@ skipping 62 matching lines @@
 
   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();
   if (x > max_x)
     x = max_x;
   if (y > max_y)
     y = max_y;
 
-  // Ignores 1 px diffirence because it may be error on calculation.
-  if (std::abs(origin_.x() - x) <= 1 &&
-      std::abs(origin_.y() - y) <= 1 &&
-      scale == scale_)
+  // Does noting if both the origin and the scale are not changed.

[Zachary Kuznia, 2012/08/06 06:07:57]

nit:  s/noting/nothing/

+  if (origin_.x() == x  &&
+      origin_.y() == y &&
+      scale == scale_) {
     return false;
+  }
 
   origin_.set_x(x);
   origin_.set_y(y);
   scale_ = scale;
 
   // Creates transform matrix.
   ui::Transform transform;
   // Flips the signs intentionally to convert them from the position of the
   // magnification window.
   transform.ConcatTranslate(-origin_.x(), -origin_.y());
@@ skipping 147 matching lines @@
   // |kMinMagnifiedScaleThreshold|;
   if (*scale > kMaxMagnifiedScaleThreshold)
     *scale = kMaxMagnifiedScale;
 }
 
 void MagnificationControllerImpl::OnImplicitAnimationsCompleted() {
   root_window_->ShowCursor(true);
   is_on_zooming_ = false;
 }
 
+void MagnificationControllerImpl::SwitchTargetRootWindow(
+    aura::RootWindow* new_root_window) {
+  float scale = GetScale();
+
+  SetScale(1.0f, true);
+  root_window_ = new_root_window;
+  SetScale(scale, true);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: MagnificationController implementation
 
 void MagnificationControllerImpl::SetScale(float scale, bool animate) {
   if (!is_enabled_)
     return;
 
   ValidateScale(&scale);
 
   // Try not to change the point which the mouse cursor indicates to.
-  const gfx::Rect window_rect = GetWindowRectDIP(scale);
-  const gfx::Point mouse = gfx::Screen::GetCursorScreenPoint();
-  const gfx::Point origin = gfx::Point(mouse.x() * (1.0f - 1.0f / scale),
-                                       mouse.y() * (1.0f - 1.0f / scale));
+  gfx::Point mouse_in_root = gfx::Screen::GetCursorScreenPoint();
+  if (DisplayController::IsExtendedDesktopEnabled())
+    ConvertsCoordinateFromScreenToRoot(root_window_, &mouse_in_root);
+
+  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);
 }
 
 void MagnificationControllerImpl::MoveWindow(int x, int y, bool animate) {
   if (!is_enabled_)
     return;
 
   Redraw(gfx::Point(x, y), scale_, animate);
 }
 
@@ skipping 36 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: aura::EventFilter implementation
 
 bool MagnificationControllerImpl::PreHandleKeyEvent(aura::Window* target,
                                                     aura::KeyEvent* event) {
   return false;
 }
 
 bool MagnificationControllerImpl::PreHandleMouseEvent(aura::Window* target,
                                                       aura::MouseEvent* event) {
-  if (IsMagnified() && event->type() == ui::ET_MOUSE_MOVED)
-    OnMouseMove(event->root_location());
+  if (IsMagnified() && event->type() == ui::ET_MOUSE_MOVED) {
+    aura::RootWindow* current_root = target->GetRootWindow();
+    gfx::Rect root_bounds = current_root->bounds();
+
+    if (root_bounds.Contains(event->root_location())) {
+      if (current_root != root_window_)
+        SwitchTargetRootWindow(current_root);
+
+      OnMouseMove(event->root_location());
+    }
+  }
+
   return false;
 }
 
 ui::TouchStatus MagnificationControllerImpl::PreHandleTouchEvent(
     aura::Window* target,
     aura::TouchEvent* event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 ui::GestureStatus MagnificationControllerImpl::PreHandleGestureEvent(
     aura::Window* target,
     aura::GestureEvent* event) {
   return ui::GESTURE_STATUS_UNKNOWN;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace internal
 }  // namespace ash