Full-screen Magnifier: Support warping the cursor on the edge

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/monitor.h"
 #include "ui/gfx/screen.h"
 
+#include "ui/compositor/layer_type.h"
+
 using std::vector;
 
 namespace aura {
 
 namespace {
 
 const ui::EventType kScrollBeginTypes[] = {
   ui::ET_MOUSE_ENTERED, ui::ET_MOUSE_PRESSED, ui::ET_MOUSE_DRAGGED,
   ui::ET_UNKNOWN };
 
@@ skipping 74 matching lines @@
       focused_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       capture_window_flags_(0),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
       should_hold_mouse_moves_(false),
+      force_hide_cursor_(false),
       compositor_lock_(NULL),
       draw_on_compositor_unlock_(false),
       draw_trace_count_(0) {
   SetName("RootWindow");
   should_hold_mouse_moves_ = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAuraDisableHoldMouseMoves);
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
@@ skipping 17 matching lines @@
   // An observer may have been added by an animation on the RootWindow.
   layer()->GetAnimator()->RemoveObserver(this);
 }
 
 void RootWindow::Init() {
   compositor()->SetScaleAndSize(GetDeviceScaleFactorFromMonitor(this),
                                 host_->GetBounds().size());
   Window::Init(ui::LAYER_NOT_DRAWN);
   last_mouse_location_ =
       ui::ConvertPointToDIP(layer(), host_->QueryMouseLocation());
-  compositor()->SetRootLayer(layer());
+
+  magnification_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
+  magnification_layer_->SetVisible(false);
+  magnification_layer_->SetFillsBoundsOpaquely(true);
+  magnification_layer_->Add(layer());
+  magnification_layer_->SetVisible(true);
+
+  compositor()->SetRootLayer(magnification_layer_.get());
+
   SetBounds(
       ui::ConvertRectToDIP(layer(), gfx::Rect(host_->GetBounds().size())));
   Show();
   host_->SetRootWindow(this);
 }
 
 void RootWindow::ShowRootWindow() {
   host_->Show();
 }
 
@@ skipping 26 matching lines @@
 }
 
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
   // A lot of code seems to depend on NULL cursors actually showing an arrow,
   // so just pass everything along to the host.
   host_->SetCursor(cursor);
 }
 
 void RootWindow::ShowCursor(bool show) {
+  if (force_hide_cursor_ && show)
+    show = false;
+
   cursor_shown_ = show;
   host_->ShowCursor(show);
 }
 
 void RootWindow::MoveCursorTo(const gfx::Point& location_in_dip) {
   host_->MoveCursorTo(ui::ConvertPointToPixel(layer(), location_in_dip));
 }
 
 bool RootWindow::ConfineCursorToWindow() {
   // We would like to be able to confine the cursor to that window. However,
@@ skipping 78 matching lines @@
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
     ScrollEvent translated_event(*event, this, target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
 bool RootWindow::DispatchTouchEvent(TouchEvent* event) {
   DispatchHeldMouseMove();
+
+  // Touch event should be transformed by magnifition transform matrix.
+  event->UpdateForRootTransform(magnification_layer()->transform());

[sky, 2012/05/16 15:40:48]

Why wouldn't it effect mouse or gesture events?

[yoshiki, 2012/05/17 17:19:32]

This CL magnifies the screen with |magnification_layer_|. This is because we
don't want to change the position/speed of the mouse cursor, to keep the UX of
mouse movement, even after the screen is magnified.

Once the screen is magnified by |magnification_layer_|, the hardware cursor by
the host indicated the wrong position because mouse events is not transformed.
But this is not the problem, because we hide the hardware cursor and draw a
software cursor instead. And scroll events are same.

However, touch events should be transformed by |magnification_layer_| because it
should not be misaligned. But we don't need to transform gesture events because
the events are fired from touch events and they are already transformed.

And the host size should not be transformed in OnHostResized(), because the
desktop size/shape should not be affected by magnification scale. We don't want
to make the logical desktop size smaller even after zoomed.

On 2012/05/16 15:40:48, sky wrote:

+
   if (ui::IsDIPEnabled()) {
     float scale = ui::GetDeviceScaleFactor(layer());
     ui::Transform transform = layer()->transform();
     transform.ConcatScale(scale, scale);
     event->UpdateForRootTransform(transform);
   } else {
     event->UpdateForRootTransform(layer()->transform());
   }
   bool handled = false;
 
@@ skipping 709 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura