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