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 {
 
 // These are the mouse events generated when a gesture goes unprocessed.
 const ui::EventType kScrollBeginTypes[] = {
   ui::ET_MOUSE_PRESSED, ui::ET_MOUSE_DRAGGED, ui::ET_UNKNOWN };
 
@@ skipping 76 matching lines @@
       mouse_moved_handler_(NULL),
       focused_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       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));

[piman, 2012/05/18 03:09:49]

Does this need to be LAYER_TEXTURED? Since it has no delegate, nothing is going
to paint the texture.
Also, since the rest of the layer tree is going to be drawn on top, this is just
going to draw black, just to be replaced by something else. Culling can help,
but we should just avoid doing this in the first place.

+  magnification_layer_->SetVisible(false);
+  magnification_layer_->SetFillsBoundsOpaquely(true);
+  magnification_layer_->Add(layer());
+  magnification_layer_->SetVisible(true);

[piman, 2012/05/18 03:09:49]

Is this layer needed at all? If it's just there to add a transform, can't we
just bake it into the root layer?

+
+  compositor()->SetRootLayer(magnification_layer_.get());
+
   SetBounds(
       ui::ConvertRectToDIP(layer(), gfx::Rect(host_->GetBounds().size())));
   Show();
   host_->SetRootWindow(this);
 }
 
 void RootWindow::ShowRootWindow() {
   host_->Show();
 }
 
@@ skipping 25 matching lines @@
   return host_->GetBounds().origin();
 }
 
 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::SetForceHideCursor(bool hide) {
+  force_hide_cursor_ = hide;
+  ShowCursor(!hide);

[piman, 2012/05/18 03:09:49]

This makes SetForceHideCursor and ShowCursor non-orthogonal which is a little
surprising.
If I do ShowCursor(false); SetForceHideCursor(false); then the cursor will be
shown.

How about we keep 2 states, (like we already have), force_hide_cursor_ (set by
SetForceHideCursor) and cursor_shown_ (set by ShowCursor), and call
host_->ShowCursor(cursor_shown_ && !force_hide_cursor_) when any of them
changes?

+}
+
 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());
+
   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;
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
@@ skipping 705 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura