ash/magnifier/magnification_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/magnifier/magnification_controller.h"
   6
   7 #include "ash/accelerators/accelerator_controller.h"
   8 #include "ash/accessibility_delegate.h"
   9 #include "ash/ash_switches.h"
  10 #include "ash/display/root_window_transformers.h"
  11 #include "ash/host/ash_window_tree_host.h"
  12 #include "ash/host/root_window_transformer.h"
  13 #include "ash/root_window_controller.h"
  14 #include "ash/shell.h"
  15 #include "ash/system/tray/system_tray_delegate.h"
  16 #include "base/command_line.h"
  17 #include "base/synchronization/waitable_event.h"
  18 #include "ui/aura/client/cursor_client.h"
  19 #include "ui/aura/window.h"
  20 #include "ui/aura/window_property.h"
  21 #include "ui/aura/window_tree_host.h"
  22 #include "ui/compositor/dip_util.h"
  23 #include "ui/compositor/layer.h"
  24 #include "ui/compositor/layer_animation_observer.h"
  25 #include "ui/compositor/scoped_layer_animation_settings.h"
  26 #include "ui/events/event.h"
  27 #include "ui/events/event_handler.h"
  28 #include "ui/gfx/point3_f.h"
  29 #include "ui/gfx/point_conversions.h"
  30 #include "ui/gfx/point_f.h"
  31 #include "ui/gfx/rect_conversions.h"
  32 #include "ui/gfx/screen.h"
  33 #include "ui/wm/core/compound_event_filter.h"
  34
  35 namespace {
  36
  37 const float kMaxMagnifiedScale = 4.0f;
  38 const float kMaxMagnifiedScaleThreshold = 4.0f;
  39 const float kMinMagnifiedScaleThreshold = 1.1f;
  40 const float kNonMagnifiedScale = 1.0f;
  41
  42 const float kInitialMagnifiedScale = 2.0f;
  43 const float kScrollScaleChangeFactor = 0.05f;
  44
  45 // Threadshold of panning. If the cursor moves to within pixels (in DIP) of
  46 // |kPanningMergin| from the edge, the view-port moves.
  47 const int kPanningMergin = 100;
  48
  49 void MoveCursorTo(aura::WindowTreeHost* host, const gfx::Point& root_location) {
  50   gfx::Point3F host_location_3f(root_location);
  51   host->GetRootTransform().TransformPoint(&host_location_3f);
  52   host->MoveCursorToHostLocation(
  53       gfx::ToCeiledPoint(host_location_3f.AsPointF()));
  54 }
  55
  56 }  // namespace
  57
  58 namespace ash {
  59
  60 ////////////////////////////////////////////////////////////////////////////////
  61 // MagnificationControllerImpl:
  62
  63 class MagnificationControllerImpl : virtual public MagnificationController,
  64                                     public ui::EventHandler,
  65                                     public ui::ImplicitAnimationObserver,
  66                                     public aura::WindowObserver {
  67  public:
  68   MagnificationControllerImpl();
  69   virtual ~MagnificationControllerImpl();
  70
  71   // MagnificationController overrides:
  72   virtual void SetEnabled(bool enabled) OVERRIDE;
  73   virtual bool IsEnabled() const OVERRIDE;
  74   virtual void SetScale(float scale, bool animate) OVERRIDE;
  75   virtual float GetScale() const OVERRIDE { return scale_; }
  76   virtual void MoveWindow(int x, int y, bool animate) OVERRIDE;
  77   virtual void MoveWindow(const gfx::Point& point, bool animate) OVERRIDE;
  78   virtual gfx::Point GetWindowPosition() const OVERRIDE {
  79     return gfx::ToFlooredPoint(origin_);
  80   }
  81   virtual void SetScrollDirection(ScrollDirection direction) OVERRIDE;
  82
  83   // For test
  84   virtual gfx::Point GetPointOfInterestForTesting() OVERRIDE {
  85     return point_of_interest_;
  86   }
  87
  88  private:
  89   // ui::ImplicitAnimationObserver overrides:
  90   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
  91
  92   // aura::WindowObserver overrides:
  93   virtual void OnWindowDestroying(aura::Window* root_window) OVERRIDE;
  94   virtual void OnWindowBoundsChanged(aura::Window* window,
  95                                      const gfx::Rect& old_bounds,
  96                                      const gfx::Rect& new_bounds) OVERRIDE;
  97
  98   // Redraws the magnification window with the given origin position and the
  99   // given scale. Returns true if the window is changed; otherwise, false.
 100   // These methods should be called internally just after the scale and/or
 101   // the position are changed to redraw the window.
 102   bool Redraw(const gfx::PointF& position, float scale, bool animate);
 103   bool RedrawDIP(const gfx::PointF& position, float scale, bool animate);
 104
 105   // 1) If the screen is scrolling (i.e. animating) and should scroll further,
 106   // it does nothing.
 107   // 2) If the screen is scrolling (i.e. animating) and the direction is NONE,
 108   // it stops the scrolling animation.
 109   // 3) If the direction is set to value other than NONE, it starts the
 110   // scrolling/ animation towards that direction.
 111   void StartOrStopScrollIfNecessary();
 112
 113   // Redraw with the given zoom scale keeping the mouse cursor location. In
 114   // other words, zoom (or unzoom) centering around the cursor.
 115   void RedrawKeepingMousePosition(float scale, bool animate);
 116
 117   void OnMouseMove(const gfx::Point& location);
 118
 119   // Move the mouse cursot to the given point. Actual move will be done when
 120   // the animation is completed. This should be called after animation is
 121   // started.
 122   void AfterAnimationMoveCursorTo(const gfx::Point& location);
 123
 124   // Switch Magnified RootWindow to |new_root_window|. This does following:
 125   //  - Unzoom the current root_window.
 126   //  - Zoom the given new root_window |new_root_window|.
 127   //  - Switch the target window from current window to |new_root_window|.
 128   void SwitchTargetRootWindow(aura::Window* new_root_window,
 129                               bool redraw_original_root_window);
 130
 131   // Returns if the magnification scale is 1.0 or not (larger then 1.0).
 132   bool IsMagnified() const;
 133
 134   // Returns the rect of the magnification window.
 135   gfx::RectF GetWindowRectDIP(float scale) const;
 136   // Returns the size of the root window.
 137   gfx::Size GetHostSizeDIP() const;
 138
 139   // Correct the givin scale value if nessesary.
 140   void ValidateScale(float* scale);
 141
 142   // ui::EventHandler overrides:
 143   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 144   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
 145   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 146
 147   // Target root window. This must not be NULL.
 148   aura::Window* root_window_;
 149
 150   // True if the magnified window is currently animating a change. Otherwise,
 151   // false.
 152   bool is_on_animation_;
 153
 154   bool is_enabled_;
 155
 156   // True if the cursor needs to move the given position after the animation
 157   // will be finished. When using this, set |position_after_animation_| as well.
 158   bool move_cursor_after_animation_;
 159   // Stores the position of cursor to be moved after animation.
 160   gfx::Point position_after_animation_;
 161
 162   // Stores the last mouse cursor (or last touched) location. This value is
 163   // used on zooming to keep this location visible.
 164   gfx::Point point_of_interest_;
 165
 166   // Current scale, origin (left-top) position of the magnification window.
 167   float scale_;
 168   gfx::PointF origin_;
 169
 170   ScrollDirection scroll_direction_;
 171
 172   DISALLOW_COPY_AND_ASSIGN(MagnificationControllerImpl);
 173 };
 174
 175 ////////////////////////////////////////////////////////////////////////////////
 176 // MagnificationControllerImpl:
 177
 178 MagnificationControllerImpl::MagnificationControllerImpl()
 179     : root_window_(Shell::GetPrimaryRootWindow()),
 180       is_on_animation_(false),
 181       is_enabled_(false),
 182       move_cursor_after_animation_(false),
 183       scale_(kNonMagnifiedScale),
 184       scroll_direction_(SCROLL_NONE) {
 185   Shell::GetInstance()->AddPreTargetHandler(this);
 186   root_window_->AddObserver(this);
 187   point_of_interest_ = root_window_->bounds().CenterPoint();
 188 }
 189
 190 MagnificationControllerImpl::~MagnificationControllerImpl() {
 191   root_window_->RemoveObserver(this);
 192
 193   Shell::GetInstance()->RemovePreTargetHandler(this);
 194 }
 195
 196 void MagnificationControllerImpl::RedrawKeepingMousePosition(
 197     float scale, bool animate) {
 198   gfx::Point mouse_in_root = point_of_interest_;
 199
 200   // mouse_in_root is invalid value when the cursor is hidden.
 201   if (!root_window_->bounds().Contains(mouse_in_root))
 202     mouse_in_root = root_window_->bounds().CenterPoint();
 203
 204   const gfx::PointF origin =
 205       gfx::PointF(mouse_in_root.x() -
 206                       (scale_ / scale) * (mouse_in_root.x() - origin_.x()),
 207                   mouse_in_root.y() -
 208                       (scale_ / scale) * (mouse_in_root.y() - origin_.y()));
 209   bool changed = RedrawDIP(origin, scale, animate);
 210   if (changed)
 211     AfterAnimationMoveCursorTo(mouse_in_root);
 212 }
 213
 214 bool MagnificationControllerImpl::Redraw(const gfx::PointF& position,
 215                                          float scale,
 216                                          bool animate) {
 217   const gfx::PointF position_in_dip =
 218       ui::ConvertPointToDIP(root_window_->layer(), position);
 219   return RedrawDIP(position_in_dip, scale, animate);
 220 }
 221
 222 bool MagnificationControllerImpl::RedrawDIP(const gfx::PointF& position_in_dip,
 223                                             float scale,
 224                                             bool animate) {
 225   DCHECK(root_window_);
 226
 227   float x = position_in_dip.x();
 228   float y = position_in_dip.y();
 229
 230   ValidateScale(&scale);
 231
 232   if (x < 0)
 233     x = 0;
 234   if (y < 0)
 235     y = 0;
 236
 237   const gfx::Size host_size_in_dip = GetHostSizeDIP();
 238   const gfx::SizeF window_size_in_dip = GetWindowRectDIP(scale).size();
 239   float max_x = host_size_in_dip.width() - window_size_in_dip.width();
 240   float max_y = host_size_in_dip.height() - window_size_in_dip.height();
 241   if (x > max_x)
 242     x = max_x;
 243   if (y > max_y)
 244     y = max_y;
 245
 246   // Does nothing if both the origin and the scale are not changed.
 247   if (origin_.x() == x  &&
 248       origin_.y() == y &&
 249       scale == scale_) {
 250     return false;
 251   }
 252
 253   origin_.set_x(x);
 254   origin_.set_y(y);
 255   scale_ = scale;
 256
 257   // Creates transform matrix.
 258   gfx::Transform transform;
 259   // Flips the signs intentionally to convert them from the position of the
 260   // magnification window.
 261   transform.Scale(scale_, scale_);
 262   transform.Translate(-origin_.x(), -origin_.y());
 263
 264   ui::ScopedLayerAnimationSettings settings(
 265       root_window_->layer()->GetAnimator());
 266   settings.AddObserver(this);
 267   settings.SetPreemptionStrategy(
 268       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 269   settings.SetTweenType(gfx::Tween::EASE_OUT);
 270   settings.SetTransitionDuration(
 271       base::TimeDelta::FromMilliseconds(animate ? 100 : 0));
 272
 273   gfx::Display display =
 274       Shell::GetScreen()->GetDisplayNearestWindow(root_window_);
 275   scoped_ptr<RootWindowTransformer> transformer(
 276       CreateRootWindowTransformerForDisplay(root_window_, display));
 277   GetRootWindowController(root_window_)->ash_host()->SetRootWindowTransformer(
 278       transformer.Pass());
 279
 280   if (animate)
 281     is_on_animation_ = true;
 282
 283   return true;
 284 }
 285
 286 void MagnificationControllerImpl::StartOrStopScrollIfNecessary() {
 287   // This value controls the scrolling speed.
 288   const int kMoveOffset = 40;
 289   if (is_on_animation_) {
 290     if (scroll_direction_ == SCROLL_NONE)
 291       root_window_->layer()->GetAnimator()->StopAnimating();
 292     return;
 293   }
 294
 295   gfx::PointF new_origin = origin_;
 296   switch (scroll_direction_) {
 297     case SCROLL_NONE:
 298       // No need to take action.
 299       return;
 300     case SCROLL_LEFT:
 301       new_origin.Offset(-kMoveOffset, 0);
 302       break;
 303     case SCROLL_RIGHT:
 304       new_origin.Offset(kMoveOffset, 0);
 305       break;
 306     case SCROLL_UP:
 307       new_origin.Offset(0, -kMoveOffset);
 308       break;
 309     case SCROLL_DOWN:
 310       new_origin.Offset(0, kMoveOffset);
 311       break;
 312   }
 313   RedrawDIP(new_origin, scale_, true);
 314 }
 315
 316 void MagnificationControllerImpl::OnMouseMove(const gfx::Point& location) {
 317   DCHECK(root_window_);
 318
 319   gfx::Point mouse(location);
 320
 321   int x = origin_.x();
 322   int y = origin_.y();
 323   bool start_zoom = false;
 324
 325   const gfx::Rect window_rect = gfx::ToEnclosingRect(GetWindowRectDIP(scale_));
 326   const int left = window_rect.x();
 327   const int right = window_rect.right();
 328   int margin = kPanningMergin / scale_;  // No need to consider DPI.
 329
 330   int x_diff = 0;
 331
 332   if (mouse.x() < left + margin) {
 333     // Panning left.
 334     x_diff = mouse.x() - (left + margin);
 335     start_zoom = true;
 336   } else if (right - margin < mouse.x()) {
 337     // Panning right.
 338     x_diff = mouse.x() - (right - margin);
 339     start_zoom = true;
 340   }
 341   x = left + x_diff;
 342
 343   const int top = window_rect.y();
 344   const int bottom = window_rect.bottom();
 345
 346   int y_diff = 0;
 347   if (mouse.y() < top + margin) {
 348     // Panning up.
 349     y_diff = mouse.y() - (top + margin);
 350     start_zoom = true;
 351   } else if (bottom - margin < mouse.y()) {
 352     // Panning down.
 353     y_diff = mouse.y() - (bottom - margin);
 354     start_zoom = true;
 355   }
 356   y = top + y_diff;
 357
 358   if (start_zoom && !is_on_animation_) {
 359     // No animation on panning.
 360     bool animate = false;
 361     bool ret = RedrawDIP(gfx::Point(x, y), scale_, animate);
 362
 363     if (ret) {
 364       // If the magnified region is moved, hides the mouse cursor and moves it.
 365       if (x_diff != 0 || y_diff != 0)
 366         MoveCursorTo(root_window_->GetHost(), mouse);
 367     }
 368   }
 369 }
 370
 371 void MagnificationControllerImpl::AfterAnimationMoveCursorTo(
 372     const gfx::Point& location) {
 373   DCHECK(root_window_);
 374
 375   aura::client::CursorClient* cursor_client =
 376       aura::client::GetCursorClient(root_window_);
 377   if (cursor_client) {
 378     // When cursor is invisible, do not move or show the cursor after the
 379     // animation.
 380     if (!cursor_client->IsCursorVisible())
 381       return;
 382     cursor_client->DisableMouseEvents();
 383   }
 384   move_cursor_after_animation_ = true;
 385   position_after_animation_ = location;
 386 }
 387
 388 gfx::Size MagnificationControllerImpl::GetHostSizeDIP() const {
 389   return root_window_->bounds().size();
 390 }
 391
 392 gfx::RectF MagnificationControllerImpl::GetWindowRectDIP(float scale) const {
 393   const gfx::Size size_in_dip = root_window_->bounds().size();
 394   const float width = size_in_dip.width() / scale;
 395   const float height = size_in_dip.height() / scale;
 396
 397   return gfx::RectF(origin_.x(), origin_.y(), width, height);
 398 }
 399
 400 bool MagnificationControllerImpl::IsMagnified() const {
 401   return scale_ >= kMinMagnifiedScaleThreshold;
 402 }
 403
 404 void MagnificationControllerImpl::ValidateScale(float* scale) {
 405   // Adjust the scale to just |kNonMagnifiedScale| if scale is smaller than
 406   // |kMinMagnifiedScaleThreshold|;
 407   if (*scale < kMinMagnifiedScaleThreshold)
 408     *scale = kNonMagnifiedScale;
 409
 410   // Adjust the scale to just |kMinMagnifiedScale| if scale is bigger than
 411   // |kMinMagnifiedScaleThreshold|;
 412   if (*scale > kMaxMagnifiedScaleThreshold)
 413     *scale = kMaxMagnifiedScale;
 414
 415   DCHECK(kNonMagnifiedScale <= *scale && *scale <= kMaxMagnifiedScale);
 416 }
 417
 418 void MagnificationControllerImpl::OnImplicitAnimationsCompleted() {
 419   if (!is_on_animation_)
 420     return;
 421
 422   if (move_cursor_after_animation_) {
 423     MoveCursorTo(root_window_->GetHost(), position_after_animation_);
 424     move_cursor_after_animation_ = false;
 425
 426     aura::client::CursorClient* cursor_client =
 427         aura::client::GetCursorClient(root_window_);
 428     if (cursor_client)
 429       cursor_client->EnableMouseEvents();
 430   }
 431
 432   is_on_animation_ = false;
 433
 434   StartOrStopScrollIfNecessary();
 435 }
 436
 437 void MagnificationControllerImpl::OnWindowDestroying(
 438     aura::Window* root_window) {
 439   if (root_window == root_window_) {
 440     // There must be at least one root window because this controller is
 441     // destroyed before the root windows get destroyed.
 442     DCHECK(root_window);
 443
 444     aura::Window* target_root_window = Shell::GetTargetRootWindow();
 445     CHECK(target_root_window);
 446
 447     // The destroyed root window must not be target.
 448     CHECK_NE(target_root_window, root_window);
 449     // Don't redraw the old root window as it's being destroyed.
 450     SwitchTargetRootWindow(target_root_window, false);
 451     point_of_interest_ = target_root_window->bounds().CenterPoint();
 452   }
 453 }
 454
 455 void MagnificationControllerImpl::OnWindowBoundsChanged(
 456     aura::Window* window,
 457     const gfx::Rect& old_bounds,
 458     const gfx::Rect& new_bounds) {
 459   // TODO(yoshiki): implement here. crbug.com/230979
 460 }
 461
 462 void MagnificationControllerImpl::SwitchTargetRootWindow(
 463     aura::Window* new_root_window,
 464     bool redraw_original_root_window) {
 465   DCHECK(new_root_window);
 466
 467   if (new_root_window == root_window_)
 468     return;
 469
 470   // Stores the previous scale.
 471   float scale = GetScale();
 472
 473   // Unmagnify the previous root window.
 474   root_window_->RemoveObserver(this);
 475   if (redraw_original_root_window)
 476     RedrawKeepingMousePosition(1.0f, true);
 477
 478   root_window_ = new_root_window;
 479   RedrawKeepingMousePosition(scale, true);
 480   root_window_->AddObserver(this);
 481 }
 482
 483 ////////////////////////////////////////////////////////////////////////////////
 484 // MagnificationControllerImpl: MagnificationController implementation
 485
 486 void MagnificationControllerImpl::SetScale(float scale, bool animate) {
 487   if (!is_enabled_)
 488     return;
 489
 490   ValidateScale(&scale);
 491   Shell::GetInstance()->accessibility_delegate()->
 492       SaveScreenMagnifierScale(scale);
 493   RedrawKeepingMousePosition(scale, animate);
 494 }
 495
 496 void MagnificationControllerImpl::MoveWindow(int x, int y, bool animate) {
 497   if (!is_enabled_)
 498     return;
 499
 500   Redraw(gfx::Point(x, y), scale_, animate);
 501 }
 502
 503 void MagnificationControllerImpl::MoveWindow(const gfx::Point& point,
 504                                              bool animate) {
 505   if (!is_enabled_)
 506     return;
 507
 508   Redraw(point, scale_, animate);
 509 }
 510
 511 void MagnificationControllerImpl::SetScrollDirection(
 512     ScrollDirection direction) {
 513   scroll_direction_ = direction;
 514   StartOrStopScrollIfNecessary();
 515 }
 516
 517 void MagnificationControllerImpl::SetEnabled(bool enabled) {
 518   Shell* shell = Shell::GetInstance();
 519   if (enabled) {
 520     float scale =
 521         Shell::GetInstance()->accessibility_delegate()->
 522         GetSavedScreenMagnifierScale();
 523     if (scale <= 0.0f)
 524       scale = kInitialMagnifiedScale;
 525     ValidateScale(&scale);
 526
 527     // Do nothing, if already enabled with same scale.
 528     if (is_enabled_ && scale == scale_)
 529       return;
 530
 531     is_enabled_ = enabled;
 532     RedrawKeepingMousePosition(scale, true);
 533     shell->accessibility_delegate()->SaveScreenMagnifierScale(scale);
 534   } else {
 535     // Do nothing, if already disabled.
 536     if (!is_enabled_)
 537       return;
 538
 539     RedrawKeepingMousePosition(kNonMagnifiedScale, true);
 540     is_enabled_ = enabled;
 541   }
 542 }
 543
 544 bool MagnificationControllerImpl::IsEnabled() const {
 545   return is_enabled_;
 546 }
 547
 548 ////////////////////////////////////////////////////////////////////////////////
 549 // MagnificationControllerImpl: aura::EventFilter implementation
 550
 551 void MagnificationControllerImpl::OnMouseEvent(ui::MouseEvent* event) {
 552   aura::Window* target = static_cast<aura::Window*>(event->target());
 553   aura::Window* current_root = target->GetRootWindow();
 554   gfx::Rect root_bounds = current_root->bounds();
 555
 556   if (root_bounds.Contains(event->root_location())) {
 557     // This must be before |SwitchTargetRootWindow()|.
 558     if (event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)
 559       point_of_interest_ = event->root_location();
 560
 561     if (current_root != root_window_) {
 562       DCHECK(current_root);
 563       SwitchTargetRootWindow(current_root, true);
 564     }
 565
 566     if (IsMagnified() && event->type() == ui::ET_MOUSE_MOVED)
 567       OnMouseMove(event->root_location());
 568   }
 569 }
 570
 571 void MagnificationControllerImpl::OnScrollEvent(ui::ScrollEvent* event) {
 572   if (event->IsAltDown() && event->IsControlDown()) {
 573     if (event->type() == ui::ET_SCROLL_FLING_START ||
 574         event->type() == ui::ET_SCROLL_FLING_CANCEL) {
 575       event->StopPropagation();
 576       return;
 577     }
 578
 579     if (event->type() == ui::ET_SCROLL) {
 580       ui::ScrollEvent* scroll_event = static_cast<ui::ScrollEvent*>(event);
 581       float scale = GetScale();
 582       scale += scroll_event->y_offset() * kScrollScaleChangeFactor;
 583       SetScale(scale, true);
 584       event->StopPropagation();
 585       return;
 586     }
 587   }
 588 }
 589
 590 void MagnificationControllerImpl::OnTouchEvent(ui::TouchEvent* event) {
 591   aura::Window* target = static_cast<aura::Window*>(event->target());
 592   aura::Window* current_root = target->GetRootWindow();
 593   if (current_root == root_window_) {
 594     gfx::Rect root_bounds = current_root->bounds();
 595     if (root_bounds.Contains(event->root_location()))
 596       point_of_interest_ = event->root_location();
 597   }
 598 }
 599
 600 ////////////////////////////////////////////////////////////////////////////////
 601 // MagnificationController:
 602
 603 // static
 604 MagnificationController* MagnificationController::CreateInstance() {
 605   return new MagnificationControllerImpl();
 606 }
 607
 608 }  // namespace ash