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/partial_magnification_controller.h"
6
7 #include "ash/shell.h"
8 #include "ash/shell_window_ids.h"
9 #include "ui/aura/window.h"
10 #include "ui/aura/window_event_dispatcher.h"
11 #include "ui/aura/window_property.h"
12 #include "ui/aura/window_tree_host.h"
13 #include "ui/gfx/screen.h"
14 #include "ui/compositor/layer.h"
15 #include "ui/views/layout/fill_layout.h"
16 #include "ui/views/widget/widget.h"
17 #include "ui/views/widget/widget_delegate.h"
18 #include "ui/wm/core/compound_event_filter.h"
19
20 namespace {
21
22 const float kMinPartialMagnifiedScaleThreshold = 1.1f;
23
24 // Number of pixels to make the border of the magnified area.
25 const int kZoomInset = 16;
26
27 // Width of the magnified area.
28 const int kMagnifierWidth = 200;
29
30 // Height of the magnified area.
31 const int kMagnifierHeight = 200;
32
33 // Name of the magnifier window.
34 const char kPartialMagniferWindowName[] = "PartialMagnifierWindow";
35
36 } // namespace
37
38 namespace ash {
39
PartialMagnificationController()40 PartialMagnificationController::PartialMagnificationController()
41 : is_on_zooming_(false),
42 is_enabled_(false),
43 scale_(kNonPartialMagnifiedScale),
44 zoom_widget_(NULL) {
45 Shell::GetInstance()->AddPreTargetHandler(this);
46 }
47
~PartialMagnificationController()48 PartialMagnificationController::~PartialMagnificationController() {
49 CloseMagnifierWindow();
50
51 Shell::GetInstance()->RemovePreTargetHandler(this);
52 }
53
SetScale(float scale)54 void PartialMagnificationController::SetScale(float scale) {
55 if (!is_enabled_)
56 return;
57
58 scale_ = scale;
59
60 if (IsPartialMagnified()) {
61 CreateMagnifierWindow();
62 } else {
63 CloseMagnifierWindow();
64 }
65 }
66
SetEnabled(bool enabled)67 void PartialMagnificationController::SetEnabled(bool enabled) {
68 if (enabled) {
69 is_enabled_ = enabled;
70 SetScale(kDefaultPartialMagnifiedScale);
71 } else {
72 SetScale(kNonPartialMagnifiedScale);
73 is_enabled_ = enabled;
74 }
75 }
76
77 ////////////////////////////////////////////////////////////////////////////////
78 // PartialMagnificationController: ui::EventHandler implementation
79
OnMouseEvent(ui::MouseEvent * event)80 void PartialMagnificationController::OnMouseEvent(ui::MouseEvent* event) {
81 if (IsPartialMagnified() && event->type() == ui::ET_MOUSE_MOVED) {
82 aura::Window* target = static_cast<aura::Window*>(event->target());
83 aura::Window* current_root = target->GetRootWindow();
84 // TODO(zork): Handle the case where the event is captured on a different
85 // display, such as when a menu is opened.
86 gfx::Rect root_bounds = current_root->bounds();
87
88 if (root_bounds.Contains(event->root_location())) {
89 SwitchTargetRootWindow(current_root);
90
91 OnMouseMove(event->root_location());
92 }
93 }
94 }
95
96 ////////////////////////////////////////////////////////////////////////////////
97 // PartialMagnificationController: aura::WindowObserver implementation
98
OnWindowDestroying(aura::Window * window)99 void PartialMagnificationController::OnWindowDestroying(
100 aura::Window* window) {
101 CloseMagnifierWindow();
102
103 aura::Window* new_root_window = GetCurrentRootWindow();
104 if (new_root_window != window)
105 SwitchTargetRootWindow(new_root_window);
106 }
107
OnWidgetDestroying(views::Widget * widget)108 void PartialMagnificationController::OnWidgetDestroying(
109 views::Widget* widget) {
110 DCHECK_EQ(widget, zoom_widget_);
111 RemoveZoomWidgetObservers();
112 zoom_widget_ = NULL;
113 }
114
OnMouseMove(const gfx::Point & location_in_root)115 void PartialMagnificationController::OnMouseMove(
116 const gfx::Point& location_in_root) {
117 gfx::Point origin(location_in_root);
118
119 origin.Offset(-kMagnifierWidth / 2, -kMagnifierHeight / 2);
120
121 if (zoom_widget_) {
122 zoom_widget_->SetBounds(gfx::Rect(origin.x(), origin.y(),
123 kMagnifierWidth, kMagnifierHeight));
124 }
125 }
126
IsPartialMagnified() const127 bool PartialMagnificationController::IsPartialMagnified() const {
128 return scale_ >= kMinPartialMagnifiedScaleThreshold;
129 }
130
CreateMagnifierWindow()131 void PartialMagnificationController::CreateMagnifierWindow() {
132 if (zoom_widget_)
133 return;
134
135 aura::Window* root_window = GetCurrentRootWindow();
136 if (!root_window)
137 return;
138
139 root_window->AddObserver(this);
140
141 gfx::Point mouse(
142 root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot());
143
144 zoom_widget_ = new views::Widget;
145 views::Widget::InitParams params(
146 views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
147 params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
148 params.accept_events = false;
149 params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
150 params.parent = root_window;
151 zoom_widget_->Init(params);
152 zoom_widget_->SetBounds(gfx::Rect(mouse.x() - kMagnifierWidth / 2,
153 mouse.y() - kMagnifierHeight / 2,
154 kMagnifierWidth, kMagnifierHeight));
155 zoom_widget_->set_focus_on_creation(false);
156 zoom_widget_->Show();
157
158 aura::Window* window = zoom_widget_->GetNativeView();
159 window->SetName(kPartialMagniferWindowName);
160
161 zoom_widget_->GetNativeView()->layer()->SetBounds(
162 gfx::Rect(0, 0,
163 kMagnifierWidth,
164 kMagnifierHeight));
165 zoom_widget_->GetNativeView()->layer()->SetBackgroundZoom(
166 scale_,
167 kZoomInset);
168
169 zoom_widget_->AddObserver(this);
170 }
171
CloseMagnifierWindow()172 void PartialMagnificationController::CloseMagnifierWindow() {
173 if (zoom_widget_) {
174 RemoveZoomWidgetObservers();
175 zoom_widget_->Close();
176 zoom_widget_ = NULL;
177 }
178 }
179
RemoveZoomWidgetObservers()180 void PartialMagnificationController::RemoveZoomWidgetObservers() {
181 DCHECK(zoom_widget_);
182 zoom_widget_->RemoveObserver(this);
183 aura::Window* root_window =
184 zoom_widget_->GetNativeView()->GetRootWindow();
185 DCHECK(root_window);
186 root_window->RemoveObserver(this);
187 }
188
SwitchTargetRootWindow(aura::Window * new_root_window)189 void PartialMagnificationController::SwitchTargetRootWindow(
190 aura::Window* new_root_window) {
191 if (zoom_widget_ &&
192 new_root_window == zoom_widget_->GetNativeView()->GetRootWindow())
193 return;
194
195 CloseMagnifierWindow();
196
197 // Recreate the magnifier window by updating the scale factor.
198 SetScale(GetScale());
199 }
200
GetCurrentRootWindow()201 aura::Window* PartialMagnificationController::GetCurrentRootWindow() {
202 aura::Window::Windows root_windows = Shell::GetAllRootWindows();
203 for (aura::Window::Windows::const_iterator iter = root_windows.begin();
204 iter != root_windows.end(); ++iter) {
205 aura::Window* root_window = *iter;
206 if (root_window->ContainsPointInRoot(
207 root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot()))
208 return root_window;
209 }
210 return NULL;
211 }
212
213 } // namespace ash
214