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 "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
6
7 #include "base/bind.h"
8 #include "base/debug/trace_event.h"
9 #include "ui/aura/client/aura_constants.h"
10 #include "ui/aura/client/cursor_client.h"
11 #include "ui/aura/client/focus_client.h"
12 #include "ui/aura/client/window_tree_client.h"
13 #include "ui/aura/window.h"
14 #include "ui/aura/window_observer.h"
15 #include "ui/aura/window_property.h"
16 #include "ui/aura/window_tree_host.h"
17 #include "ui/base/hit_test.h"
18 #include "ui/base/ui_base_switches_util.h"
19 #include "ui/compositor/layer.h"
20 #include "ui/gfx/canvas.h"
21 #include "ui/gfx/display.h"
22 #include "ui/gfx/point_conversions.h"
23 #include "ui/gfx/geometry/rect.h"
24 #include "ui/gfx/screen.h"
25 #include "ui/gfx/size_conversions.h"
26 #include "ui/native_theme/native_theme.h"
27 #include "ui/views/corewm/tooltip.h"
28 #include "ui/views/corewm/tooltip_controller.h"
29 #include "ui/views/drag_utils.h"
30 #include "ui/views/ime/input_method_bridge.h"
31 #include "ui/views/ime/null_input_method.h"
32 #include "ui/views/view_constants_aura.h"
33 #include "ui/views/widget/desktop_aura/desktop_capture_client.h"
34 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
35 #include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h"
36 #include "ui/views/widget/desktop_aura/desktop_event_client.h"
37 #include "ui/views/widget/desktop_aura/desktop_focus_rules.h"
38 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
39 #include "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
40 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
41 #include "ui/views/widget/drop_helper.h"
42 #include "ui/views/widget/native_widget_aura.h"
43 #include "ui/views/widget/root_view.h"
44 #include "ui/views/widget/tooltip_manager_aura.h"
45 #include "ui/views/widget/widget.h"
46 #include "ui/views/widget/widget_aura_utils.h"
47 #include "ui/views/widget/widget_delegate.h"
48 #include "ui/views/widget/window_reorderer.h"
49 #include "ui/views/window/native_frame_view.h"
50 #include "ui/wm/core/compound_event_filter.h"
51 #include "ui/wm/core/cursor_manager.h"
52 #include "ui/wm/core/focus_controller.h"
53 #include "ui/wm/core/input_method_event_filter.h"
54 #include "ui/wm/core/native_cursor_manager.h"
55 #include "ui/wm/core/shadow_controller.h"
56 #include "ui/wm/core/shadow_types.h"
57 #include "ui/wm/core/visibility_controller.h"
58 #include "ui/wm/core/window_modality_controller.h"
59 #include "ui/wm/public/activation_client.h"
60 #include "ui/wm/public/drag_drop_client.h"
61
62 #if defined(OS_WIN)
63 #include "ui/base/win/shell.h"
64 #include "ui/gfx/win/dpi.h"
65 #endif
66
67 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(VIEWS_EXPORT,
68 views::DesktopNativeWidgetAura*);
69
70 namespace views {
71
72 DEFINE_WINDOW_PROPERTY_KEY(DesktopNativeWidgetAura*,
73 kDesktopNativeWidgetAuraKey, NULL);
74
75 namespace {
76
77 // This class provides functionality to create a top level widget to host a
78 // child window.
79 class DesktopNativeWidgetTopLevelHandler : public aura::WindowObserver {
80 public:
81 // This function creates a widget with the bounds passed in which eventually
82 // becomes the parent of the child window passed in.
CreateParentWindow(aura::Window * child_window,const gfx::Rect & bounds,bool full_screen,bool root_is_always_on_top)83 static aura::Window* CreateParentWindow(aura::Window* child_window,
84 const gfx::Rect& bounds,
85 bool full_screen,
86 bool root_is_always_on_top) {
87 // This instance will get deleted when the widget is destroyed.
88 DesktopNativeWidgetTopLevelHandler* top_level_handler =
89 new DesktopNativeWidgetTopLevelHandler;
90
91 child_window->SetBounds(gfx::Rect(bounds.size()));
92
93 Widget::InitParams init_params;
94 init_params.type = full_screen ? Widget::InitParams::TYPE_WINDOW :
95 Widget::InitParams::TYPE_POPUP;
96 init_params.bounds = bounds;
97 init_params.ownership = Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET;
98 init_params.layer_type = aura::WINDOW_LAYER_NOT_DRAWN;
99 init_params.activatable = full_screen ?
100 Widget::InitParams::ACTIVATABLE_YES :
101 Widget::InitParams::ACTIVATABLE_NO;
102 init_params.keep_on_top = root_is_always_on_top;
103
104 // This widget instance will get deleted when the window is
105 // destroyed.
106 top_level_handler->top_level_widget_ = new Widget();
107 top_level_handler->top_level_widget_->Init(init_params);
108
109 top_level_handler->top_level_widget_->SetFullscreen(full_screen);
110 top_level_handler->top_level_widget_->Show();
111
112 aura::Window* native_window =
113 top_level_handler->top_level_widget_->GetNativeView();
114 child_window->AddObserver(top_level_handler);
115 native_window->AddObserver(top_level_handler);
116 top_level_handler->child_window_ = child_window;
117 return native_window;
118 }
119
120 // aura::WindowObserver overrides
OnWindowDestroying(aura::Window * window)121 virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
122 window->RemoveObserver(this);
123
124 // If the widget is being destroyed by the OS then we should not try and
125 // destroy it again.
126 if (top_level_widget_ &&
127 window == top_level_widget_->GetNativeView()) {
128 top_level_widget_ = NULL;
129 return;
130 }
131
132 if (top_level_widget_) {
133 DCHECK(top_level_widget_->GetNativeView());
134 top_level_widget_->GetNativeView()->RemoveObserver(this);
135 // When we receive a notification that the child of the window created
136 // above is being destroyed we go ahead and initiate the destruction of
137 // the corresponding widget.
138 top_level_widget_->Close();
139 top_level_widget_ = NULL;
140 }
141 delete this;
142 }
143
OnWindowBoundsChanged(aura::Window * window,const gfx::Rect & old_bounds,const gfx::Rect & new_bounds)144 virtual void OnWindowBoundsChanged(aura::Window* window,
145 const gfx::Rect& old_bounds,
146 const gfx::Rect& new_bounds) OVERRIDE {
147 if (top_level_widget_ && window == child_window_)
148 top_level_widget_->SetSize(new_bounds.size());
149 }
150
151 private:
DesktopNativeWidgetTopLevelHandler()152 DesktopNativeWidgetTopLevelHandler()
153 : top_level_widget_(NULL),
154 child_window_(NULL) {}
155
~DesktopNativeWidgetTopLevelHandler()156 virtual ~DesktopNativeWidgetTopLevelHandler() {}
157
158 Widget* top_level_widget_;
159 aura::Window* child_window_;
160
161 DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetTopLevelHandler);
162 };
163
164 class DesktopNativeWidgetAuraWindowTreeClient :
165 public aura::client::WindowTreeClient {
166 public:
DesktopNativeWidgetAuraWindowTreeClient(aura::Window * root_window)167 explicit DesktopNativeWidgetAuraWindowTreeClient(
168 aura::Window* root_window)
169 : root_window_(root_window) {
170 aura::client::SetWindowTreeClient(root_window_, this);
171 }
~DesktopNativeWidgetAuraWindowTreeClient()172 virtual ~DesktopNativeWidgetAuraWindowTreeClient() {
173 aura::client::SetWindowTreeClient(root_window_, NULL);
174 }
175
176 // Overridden from client::WindowTreeClient:
GetDefaultParent(aura::Window * context,aura::Window * window,const gfx::Rect & bounds)177 virtual aura::Window* GetDefaultParent(aura::Window* context,
178 aura::Window* window,
179 const gfx::Rect& bounds) OVERRIDE {
180 bool is_fullscreen = window->GetProperty(aura::client::kShowStateKey) ==
181 ui::SHOW_STATE_FULLSCREEN;
182 bool is_menu = window->type() == ui::wm::WINDOW_TYPE_MENU;
183
184 if (is_fullscreen || is_menu) {
185 bool root_is_always_on_top = false;
186 internal::NativeWidgetPrivate* native_widget =
187 DesktopNativeWidgetAura::ForWindow(root_window_);
188 if (native_widget)
189 root_is_always_on_top = native_widget->IsAlwaysOnTop();
190
191 return DesktopNativeWidgetTopLevelHandler::CreateParentWindow(
192 window, bounds, is_fullscreen, root_is_always_on_top);
193 }
194 return root_window_;
195 }
196
197 private:
198 aura::Window* root_window_;
199
200 DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetAuraWindowTreeClient);
201 };
202
203 } // namespace
204
205 class FocusManagerEventHandler : public ui::EventHandler {
206 public:
FocusManagerEventHandler(DesktopNativeWidgetAura * desktop_native_widget_aura)207 FocusManagerEventHandler(DesktopNativeWidgetAura* desktop_native_widget_aura)
208 : desktop_native_widget_aura_(desktop_native_widget_aura) {}
209
210 // Implementation of ui::EventHandler:
OnKeyEvent(ui::KeyEvent * event)211 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
212 Widget* widget = desktop_native_widget_aura_->GetWidget();
213 if (widget && widget->GetFocusManager()->GetFocusedView() &&
214 !widget->GetFocusManager()->OnKeyEvent(*event)) {
215 event->SetHandled();
216 }
217 }
218
219 private:
220 DesktopNativeWidgetAura* desktop_native_widget_aura_;
221
222 DISALLOW_COPY_AND_ASSIGN(FocusManagerEventHandler);
223 };
224
225 class RootWindowDestructionObserver : public aura::WindowObserver {
226 public:
RootWindowDestructionObserver(DesktopNativeWidgetAura * parent)227 explicit RootWindowDestructionObserver(DesktopNativeWidgetAura* parent)
228 : parent_(parent) {}
~RootWindowDestructionObserver()229 virtual ~RootWindowDestructionObserver() {}
230
231 private:
232 // Overridden from aura::WindowObserver:
OnWindowDestroyed(aura::Window * window)233 virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
234 parent_->RootWindowDestroyed();
235 window->RemoveObserver(this);
236 delete this;
237 }
238
239 DesktopNativeWidgetAura* parent_;
240
241 DISALLOW_COPY_AND_ASSIGN(RootWindowDestructionObserver);
242 };
243
244 ////////////////////////////////////////////////////////////////////////////////
245 // DesktopNativeWidgetAura, public:
246
247 int DesktopNativeWidgetAura::cursor_reference_count_ = 0;
248 DesktopNativeCursorManager* DesktopNativeWidgetAura::native_cursor_manager_ =
249 NULL;
250 wm::CursorManager* DesktopNativeWidgetAura::cursor_manager_ = NULL;
251
DesktopNativeWidgetAura(internal::NativeWidgetDelegate * delegate)252 DesktopNativeWidgetAura::DesktopNativeWidgetAura(
253 internal::NativeWidgetDelegate* delegate)
254 : desktop_window_tree_host_(NULL),
255 ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
256 content_window_container_(NULL),
257 content_window_(new aura::Window(this)),
258 native_widget_delegate_(delegate),
259 last_drop_operation_(ui::DragDropTypes::DRAG_NONE),
260 restore_focus_on_activate_(false),
261 cursor_(gfx::kNullCursor),
262 widget_type_(Widget::InitParams::TYPE_WINDOW),
263 close_widget_factory_(this) {
264 aura::client::SetFocusChangeObserver(content_window_, this);
265 aura::client::SetActivationChangeObserver(content_window_, this);
266 }
267
~DesktopNativeWidgetAura()268 DesktopNativeWidgetAura::~DesktopNativeWidgetAura() {
269 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
270 delete native_widget_delegate_;
271 else
272 CloseNow();
273 }
274
275 // static
ForWindow(aura::Window * window)276 DesktopNativeWidgetAura* DesktopNativeWidgetAura::ForWindow(
277 aura::Window* window) {
278 return window->GetProperty(kDesktopNativeWidgetAuraKey);
279 }
280
OnHostClosed()281 void DesktopNativeWidgetAura::OnHostClosed() {
282 // Don't invoke Widget::OnNativeWidgetDestroying(), its done by
283 // DesktopWindowTreeHost.
284
285 // The WindowModalityController is at the front of the event pretarget
286 // handler list. We destroy it first to preserve order symantics.
287 if (window_modality_controller_)
288 window_modality_controller_.reset();
289
290 // Make sure we don't have capture. Otherwise CaptureController and
291 // WindowEventDispatcher are left referencing a deleted Window.
292 {
293 aura::Window* capture_window = capture_client_->GetCaptureWindow();
294 if (capture_window && host_->window()->Contains(capture_window))
295 capture_window->ReleaseCapture();
296 }
297
298 // DesktopWindowTreeHost owns the ActivationController which ShadowController
299 // references. Make sure we destroy ShadowController early on.
300 shadow_controller_.reset();
301 tooltip_manager_.reset();
302 if (tooltip_controller_.get()) {
303 host_->window()->RemovePreTargetHandler(tooltip_controller_.get());
304 aura::client::SetTooltipClient(host_->window(), NULL);
305 tooltip_controller_.reset();
306 }
307
308 root_window_event_filter_->RemoveHandler(input_method_event_filter_.get());
309
310 window_tree_client_.reset(); // Uses host_->dispatcher() at destruction.
311
312 capture_client_.reset(); // Uses host_->dispatcher() at destruction.
313
314 // FocusController uses |content_window_|. Destroy it now so that we don't
315 // have to worry about the possibility of FocusController attempting to use
316 // |content_window_| after it's been destroyed but before all child windows
317 // have been destroyed.
318 host_->window()->RemovePreTargetHandler(focus_client_.get());
319 aura::client::SetFocusClient(host_->window(), NULL);
320 aura::client::SetActivationClient(host_->window(), NULL);
321 focus_client_.reset();
322
323 host_->RemoveObserver(this);
324 host_.reset(); // Uses input_method_event_filter_ at destruction.
325 // WindowEventDispatcher owns |desktop_window_tree_host_|.
326 desktop_window_tree_host_ = NULL;
327 content_window_ = NULL;
328
329 native_widget_delegate_->OnNativeWidgetDestroyed();
330 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
331 delete this;
332 }
333
OnDesktopWindowTreeHostDestroyed(aura::WindowTreeHost * host)334 void DesktopNativeWidgetAura::OnDesktopWindowTreeHostDestroyed(
335 aura::WindowTreeHost* host) {
336 // |dispatcher_| is still valid, but DesktopWindowTreeHost is nearly
337 // destroyed. Do cleanup here of members DesktopWindowTreeHost may also use.
338 aura::client::SetDispatcherClient(host->window(), NULL);
339 dispatcher_client_.reset();
340
341 // We explicitly do NOT clear the cursor client property. Since the cursor
342 // manager is a singleton, it can outlive any window hierarchy, and it's
343 // important that objects attached to this destroying window hierarchy have
344 // an opportunity to deregister their observers from the cursor manager.
345 // They may want to do this when they are notified that they're being
346 // removed from the window hierarchy, which happens soon after this
347 // function when DesktopWindowTreeHost* calls DestroyDispatcher().
348 native_cursor_manager_->RemoveHost(host);
349
350 aura::client::SetScreenPositionClient(host->window(), NULL);
351 position_client_.reset();
352
353 aura::client::SetDragDropClient(host->window(), NULL);
354 drag_drop_client_.reset();
355
356 aura::client::SetEventClient(host->window(), NULL);
357 event_client_.reset();
358 }
359
HandleActivationChanged(bool active)360 void DesktopNativeWidgetAura::HandleActivationChanged(bool active) {
361 native_widget_delegate_->OnNativeWidgetActivationChanged(active);
362 aura::client::ActivationClient* activation_client =
363 aura::client::GetActivationClient(host_->window());
364 if (!activation_client)
365 return;
366 if (active) {
367 if (GetWidget()->HasFocusManager()) {
368 // This function can be called before the focus manager has had a
369 // chance to set the focused view. In which case we should get the
370 // last focused view.
371 View* view_for_activation =
372 GetWidget()->GetFocusManager()->GetFocusedView() ?
373 GetWidget()->GetFocusManager()->GetFocusedView() :
374 GetWidget()->GetFocusManager()->GetStoredFocusView();
375 if (!view_for_activation)
376 view_for_activation = GetWidget()->GetRootView();
377 activation_client->ActivateWindow(
378 view_for_activation->GetWidget()->GetNativeView());
379 }
380 } else {
381 // If we're not active we need to deactivate the corresponding
382 // aura::Window. This way if a child widget is active it gets correctly
383 // deactivated (child widgets don't get native desktop activation changes,
384 // only aura activation changes).
385 aura::Window* active_window = activation_client->GetActiveWindow();
386 if (active_window)
387 activation_client->DeactivateWindow(active_window);
388 }
389 }
390
391 ////////////////////////////////////////////////////////////////////////////////
392 // DesktopNativeWidgetAura, internal::NativeWidgetPrivate implementation:
393
InitNativeWidget(const Widget::InitParams & params)394 void DesktopNativeWidgetAura::InitNativeWidget(
395 const Widget::InitParams& params) {
396 ownership_ = params.ownership;
397 widget_type_ = params.type;
398
399 NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_window_);
400 // Animations on TYPE_WINDOW are handled by the OS. Additionally if we animate
401 // these windows the size of the window gets augmented, effecting restore
402 // bounds and maximized windows in bad ways.
403 if (params.type == Widget::InitParams::TYPE_WINDOW &&
404 !params.remove_standard_frame) {
405 content_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
406 }
407 content_window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
408 content_window_->Init(params.layer_type);
409 wm::SetShadowType(content_window_, wm::SHADOW_TYPE_NONE);
410
411 content_window_container_ = new aura::Window(NULL);
412 content_window_container_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
413 content_window_container_->Show();
414 content_window_container_->AddChild(content_window_);
415
416 desktop_window_tree_host_ = params.desktop_window_tree_host ?
417 params.desktop_window_tree_host :
418 DesktopWindowTreeHost::Create(native_widget_delegate_, this);
419 host_.reset(desktop_window_tree_host_->AsWindowTreeHost());
420 desktop_window_tree_host_->Init(content_window_, params);
421
422 // Mark this window as Desktop root window.
423 host_->window()->SetProperty(views::kDesktopRootWindow, true);
424
425 host_->InitHost();
426 host_->window()->AddChild(content_window_container_);
427 host_->window()->SetProperty(kDesktopNativeWidgetAuraKey, this);
428
429 host_->window()->AddObserver(new RootWindowDestructionObserver(this));
430
431 // The WindowsModalityController event filter should be at the head of the
432 // pre target handlers list. This ensures that it handles input events first
433 // when modal windows are at the top of the Zorder.
434 if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
435 window_modality_controller_.reset(
436 new wm::WindowModalityController(host_->window()));
437
438 // |root_window_event_filter_| must be created before
439 // OnWindowTreeHostCreated() is invoked.
440
441 // CEF sets focus to the window the user clicks down on.
442 // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
443 // handed way of accomplishing focus.
444 // No event filter for aura::Env. Create CompoundEventFilter per
445 // WindowEventDispatcher.
446 root_window_event_filter_.reset(new wm::CompoundEventFilter);
447 host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
448
449 // The host's dispatcher must be added to |native_cursor_manager_| before
450 // OnNativeWidgetCreated() is called.
451 cursor_reference_count_++;
452 if (!native_cursor_manager_) {
453 native_cursor_manager_ = new DesktopNativeCursorManager(
454 DesktopCursorLoaderUpdater::Create());
455 }
456 if (!cursor_manager_) {
457 cursor_manager_ = new wm::CursorManager(
458 scoped_ptr<wm::NativeCursorManager>(native_cursor_manager_));
459 }
460 native_cursor_manager_->AddHost(host());
461 aura::client::SetCursorClient(host_->window(), cursor_manager_);
462
463 desktop_window_tree_host_->OnNativeWidgetCreated(params);
464
465 UpdateWindowTransparency();
466
467 capture_client_.reset(new DesktopCaptureClient(host_->window()));
468
469 wm::FocusController* focus_controller =
470 new wm::FocusController(new DesktopFocusRules(content_window_));
471 focus_client_.reset(focus_controller);
472 aura::client::SetFocusClient(host_->window(), focus_controller);
473 aura::client::SetActivationClient(host_->window(), focus_controller);
474 host_->window()->AddPreTargetHandler(focus_controller);
475
476 dispatcher_client_.reset(new DesktopDispatcherClient);
477 aura::client::SetDispatcherClient(host_->window(),
478 dispatcher_client_.get());
479
480 position_client_.reset(new DesktopScreenPositionClient(host_->window()));
481
482 InstallInputMethodEventFilter();
483
484 drag_drop_client_ = desktop_window_tree_host_->CreateDragDropClient(
485 native_cursor_manager_);
486 aura::client::SetDragDropClient(host_->window(),
487 drag_drop_client_.get());
488
489 static_cast<aura::client::FocusClient*>(focus_client_.get())->
490 FocusWindow(content_window_);
491
492 OnHostResized(host());
493
494 host_->AddObserver(this);
495
496 window_tree_client_.reset(
497 new DesktopNativeWidgetAuraWindowTreeClient(host_->window()));
498 drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
499 aura::client::SetDragDropDelegate(content_window_, this);
500
501 if (params.type != Widget::InitParams::TYPE_TOOLTIP) {
502 tooltip_manager_.reset(new TooltipManagerAura(GetWidget()));
503 tooltip_controller_.reset(
504 new corewm::TooltipController(
505 desktop_window_tree_host_->CreateTooltip()));
506 aura::client::SetTooltipClient(host_->window(),
507 tooltip_controller_.get());
508 host_->window()->AddPreTargetHandler(tooltip_controller_.get());
509 }
510
511 if (params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW) {
512 visibility_controller_.reset(new wm::VisibilityController);
513 aura::client::SetVisibilityClient(host_->window(),
514 visibility_controller_.get());
515 wm::SetChildWindowVisibilityChangesAnimated(host_->window());
516 wm::SetChildWindowVisibilityChangesAnimated(
517 content_window_container_);
518 }
519
520 if (params.type == Widget::InitParams::TYPE_WINDOW) {
521 focus_manager_event_handler_.reset(new FocusManagerEventHandler(this));
522 host_->window()->AddPreTargetHandler(focus_manager_event_handler_.get());
523 }
524
525 event_client_.reset(new DesktopEventClient);
526 aura::client::SetEventClient(host_->window(), event_client_.get());
527
528 aura::client::GetFocusClient(content_window_)->FocusWindow(content_window_);
529
530 aura::client::SetActivationDelegate(content_window_, this);
531
532 shadow_controller_.reset(new wm::ShadowController(
533 aura::client::GetActivationClient(host_->window())));
534
535 OnSizeConstraintsChanged();
536
537 window_reorderer_.reset(new WindowReorderer(content_window_,
538 GetWidget()->GetRootView()));
539 }
540
CreateNonClientFrameView()541 NonClientFrameView* DesktopNativeWidgetAura::CreateNonClientFrameView() {
542 return ShouldUseNativeFrame() ? new NativeFrameView(GetWidget()) : NULL;
543 }
544
ShouldUseNativeFrame() const545 bool DesktopNativeWidgetAura::ShouldUseNativeFrame() const {
546 return desktop_window_tree_host_->ShouldUseNativeFrame();
547 }
548
ShouldWindowContentsBeTransparent() const549 bool DesktopNativeWidgetAura::ShouldWindowContentsBeTransparent() const {
550 return desktop_window_tree_host_->ShouldWindowContentsBeTransparent();
551 }
552
FrameTypeChanged()553 void DesktopNativeWidgetAura::FrameTypeChanged() {
554 desktop_window_tree_host_->FrameTypeChanged();
555 UpdateWindowTransparency();
556 }
557
GetWidget()558 Widget* DesktopNativeWidgetAura::GetWidget() {
559 return native_widget_delegate_->AsWidget();
560 }
561
GetWidget() const562 const Widget* DesktopNativeWidgetAura::GetWidget() const {
563 return native_widget_delegate_->AsWidget();
564 }
565
GetNativeView() const566 gfx::NativeView DesktopNativeWidgetAura::GetNativeView() const {
567 return content_window_;
568 }
569
GetNativeWindow() const570 gfx::NativeWindow DesktopNativeWidgetAura::GetNativeWindow() const {
571 return content_window_;
572 }
573
GetTopLevelWidget()574 Widget* DesktopNativeWidgetAura::GetTopLevelWidget() {
575 return GetWidget();
576 }
577
GetCompositor() const578 const ui::Compositor* DesktopNativeWidgetAura::GetCompositor() const {
579 return content_window_ ? content_window_->layer()->GetCompositor() : NULL;
580 }
581
GetCompositor()582 ui::Compositor* DesktopNativeWidgetAura::GetCompositor() {
583 return const_cast<ui::Compositor*>(
584 const_cast<const DesktopNativeWidgetAura*>(this)->GetCompositor());
585 }
586
GetLayer()587 ui::Layer* DesktopNativeWidgetAura::GetLayer() {
588 return content_window_ ? content_window_->layer() : NULL;
589 }
590
ReorderNativeViews()591 void DesktopNativeWidgetAura::ReorderNativeViews() {
592 window_reorderer_->ReorderChildWindows();
593 }
594
ViewRemoved(View * view)595 void DesktopNativeWidgetAura::ViewRemoved(View* view) {
596 DCHECK(drop_helper_.get() != NULL);
597 drop_helper_->ResetTargetViewIfEquals(view);
598 }
599
SetNativeWindowProperty(const char * name,void * value)600 void DesktopNativeWidgetAura::SetNativeWindowProperty(const char* name,
601 void* value) {
602 if (content_window_)
603 content_window_->SetNativeWindowProperty(name, value);
604 }
605
GetNativeWindowProperty(const char * name) const606 void* DesktopNativeWidgetAura::GetNativeWindowProperty(const char* name) const {
607 return content_window_ ?
608 content_window_->GetNativeWindowProperty(name) : NULL;
609 }
610
GetTooltipManager() const611 TooltipManager* DesktopNativeWidgetAura::GetTooltipManager() const {
612 return tooltip_manager_.get();
613 }
614
SetCapture()615 void DesktopNativeWidgetAura::SetCapture() {
616 if (!content_window_)
617 return;
618
619 content_window_->SetCapture();
620 }
621
ReleaseCapture()622 void DesktopNativeWidgetAura::ReleaseCapture() {
623 if (!content_window_)
624 return;
625
626 content_window_->ReleaseCapture();
627 }
628
HasCapture() const629 bool DesktopNativeWidgetAura::HasCapture() const {
630 return content_window_ && content_window_->HasCapture() &&
631 desktop_window_tree_host_->HasCapture();
632 }
633
CreateInputMethod()634 InputMethod* DesktopNativeWidgetAura::CreateInputMethod() {
635 if (switches::IsTextInputFocusManagerEnabled())
636 return new NullInputMethod();
637
638 ui::InputMethod* host = input_method_event_filter_->input_method();
639 return new InputMethodBridge(this, host, false);
640 }
641
642 internal::InputMethodDelegate*
GetInputMethodDelegate()643 DesktopNativeWidgetAura::GetInputMethodDelegate() {
644 return this;
645 }
646
GetHostInputMethod()647 ui::InputMethod* DesktopNativeWidgetAura::GetHostInputMethod() {
648 return input_method_event_filter_->input_method();
649 }
650
CenterWindow(const gfx::Size & size)651 void DesktopNativeWidgetAura::CenterWindow(const gfx::Size& size) {
652 if (content_window_)
653 desktop_window_tree_host_->CenterWindow(size);
654 }
655
GetWindowPlacement(gfx::Rect * bounds,ui::WindowShowState * maximized) const656 void DesktopNativeWidgetAura::GetWindowPlacement(
657 gfx::Rect* bounds,
658 ui::WindowShowState* maximized) const {
659 if (content_window_)
660 desktop_window_tree_host_->GetWindowPlacement(bounds, maximized);
661 }
662
SetWindowTitle(const base::string16 & title)663 bool DesktopNativeWidgetAura::SetWindowTitle(const base::string16& title) {
664 if (!content_window_)
665 return false;
666 return desktop_window_tree_host_->SetWindowTitle(title);
667 }
668
SetWindowIcons(const gfx::ImageSkia & window_icon,const gfx::ImageSkia & app_icon)669 void DesktopNativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon,
670 const gfx::ImageSkia& app_icon) {
671 if (content_window_)
672 desktop_window_tree_host_->SetWindowIcons(window_icon, app_icon);
673 }
674
InitModalType(ui::ModalType modal_type)675 void DesktopNativeWidgetAura::InitModalType(ui::ModalType modal_type) {
676 // 99% of the time, we should not be asked to create a
677 // DesktopNativeWidgetAura that is modal. We only support window modal
678 // dialogs on the same lines as non AURA.
679 desktop_window_tree_host_->InitModalType(modal_type);
680 }
681
GetWindowBoundsInScreen() const682 gfx::Rect DesktopNativeWidgetAura::GetWindowBoundsInScreen() const {
683 return content_window_ ?
684 desktop_window_tree_host_->GetWindowBoundsInScreen() : gfx::Rect();
685 }
686
GetClientAreaBoundsInScreen() const687 gfx::Rect DesktopNativeWidgetAura::GetClientAreaBoundsInScreen() const {
688 return content_window_ ?
689 desktop_window_tree_host_->GetClientAreaBoundsInScreen() : gfx::Rect();
690 }
691
GetRestoredBounds() const692 gfx::Rect DesktopNativeWidgetAura::GetRestoredBounds() const {
693 return content_window_ ?
694 desktop_window_tree_host_->GetRestoredBounds() : gfx::Rect();
695 }
696
SetBounds(const gfx::Rect & bounds)697 void DesktopNativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
698 if (!content_window_)
699 return;
700 // TODO(ananta)
701 // This code by default scales the bounds rectangle by 1.
702 // We could probably get rid of this and similar logic from
703 // the DesktopNativeWidgetAura::OnWindowTreeHostResized function.
704 float scale = 1;
705 aura::Window* root = host_->window();
706 if (root) {
707 scale = gfx::Screen::GetScreenFor(root)->
708 GetDisplayNearestWindow(root).device_scale_factor();
709 }
710 gfx::Rect bounds_in_pixels =
711 gfx::ScaleToEnclosingRect(bounds, scale, scale);
712 desktop_window_tree_host_->AsWindowTreeHost()->SetBounds(bounds_in_pixels);
713 }
714
SetSize(const gfx::Size & size)715 void DesktopNativeWidgetAura::SetSize(const gfx::Size& size) {
716 if (content_window_)
717 desktop_window_tree_host_->SetSize(size);
718 }
719
StackAbove(gfx::NativeView native_view)720 void DesktopNativeWidgetAura::StackAbove(gfx::NativeView native_view) {
721 }
722
StackAtTop()723 void DesktopNativeWidgetAura::StackAtTop() {
724 if (content_window_)
725 desktop_window_tree_host_->StackAtTop();
726 }
727
StackBelow(gfx::NativeView native_view)728 void DesktopNativeWidgetAura::StackBelow(gfx::NativeView native_view) {
729 }
730
SetShape(gfx::NativeRegion shape)731 void DesktopNativeWidgetAura::SetShape(gfx::NativeRegion shape) {
732 if (content_window_)
733 desktop_window_tree_host_->SetShape(shape);
734 }
735
Close()736 void DesktopNativeWidgetAura::Close() {
737 if (!content_window_)
738 return;
739
740 content_window_->SuppressPaint();
741 content_window_->Hide();
742
743 desktop_window_tree_host_->Close();
744 }
745
CloseNow()746 void DesktopNativeWidgetAura::CloseNow() {
747 if (content_window_)
748 desktop_window_tree_host_->CloseNow();
749 }
750
Show()751 void DesktopNativeWidgetAura::Show() {
752 if (!content_window_)
753 return;
754 desktop_window_tree_host_->AsWindowTreeHost()->Show();
755 content_window_->Show();
756 }
757
Hide()758 void DesktopNativeWidgetAura::Hide() {
759 if (!content_window_)
760 return;
761 desktop_window_tree_host_->AsWindowTreeHost()->Hide();
762 content_window_->Hide();
763 }
764
ShowMaximizedWithBounds(const gfx::Rect & restored_bounds)765 void DesktopNativeWidgetAura::ShowMaximizedWithBounds(
766 const gfx::Rect& restored_bounds) {
767 if (!content_window_)
768 return;
769 desktop_window_tree_host_->ShowMaximizedWithBounds(restored_bounds);
770 content_window_->Show();
771 }
772
ShowWithWindowState(ui::WindowShowState state)773 void DesktopNativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
774 if (!content_window_)
775 return;
776 desktop_window_tree_host_->ShowWindowWithState(state);
777 content_window_->Show();
778 }
779
IsVisible() const780 bool DesktopNativeWidgetAura::IsVisible() const {
781 return content_window_ && desktop_window_tree_host_->IsVisible();
782 }
783
Activate()784 void DesktopNativeWidgetAura::Activate() {
785 if (content_window_)
786 desktop_window_tree_host_->Activate();
787 }
788
Deactivate()789 void DesktopNativeWidgetAura::Deactivate() {
790 if (content_window_)
791 desktop_window_tree_host_->Deactivate();
792 }
793
IsActive() const794 bool DesktopNativeWidgetAura::IsActive() const {
795 return content_window_ && desktop_window_tree_host_->IsActive();
796 }
797
SetAlwaysOnTop(bool always_on_top)798 void DesktopNativeWidgetAura::SetAlwaysOnTop(bool always_on_top) {
799 if (content_window_)
800 desktop_window_tree_host_->SetAlwaysOnTop(always_on_top);
801 }
802
IsAlwaysOnTop() const803 bool DesktopNativeWidgetAura::IsAlwaysOnTop() const {
804 return content_window_ && desktop_window_tree_host_->IsAlwaysOnTop();
805 }
806
SetVisibleOnAllWorkspaces(bool always_visible)807 void DesktopNativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) {
808 if (content_window_)
809 desktop_window_tree_host_->SetVisibleOnAllWorkspaces(always_visible);
810 }
811
Maximize()812 void DesktopNativeWidgetAura::Maximize() {
813 if (content_window_)
814 desktop_window_tree_host_->Maximize();
815 }
816
Minimize()817 void DesktopNativeWidgetAura::Minimize() {
818 if (content_window_)
819 desktop_window_tree_host_->Minimize();
820 }
821
IsMaximized() const822 bool DesktopNativeWidgetAura::IsMaximized() const {
823 return content_window_ && desktop_window_tree_host_->IsMaximized();
824 }
825
IsMinimized() const826 bool DesktopNativeWidgetAura::IsMinimized() const {
827 return content_window_ && desktop_window_tree_host_->IsMinimized();
828 }
829
Restore()830 void DesktopNativeWidgetAura::Restore() {
831 if (content_window_)
832 desktop_window_tree_host_->Restore();
833 }
834
SetFullscreen(bool fullscreen)835 void DesktopNativeWidgetAura::SetFullscreen(bool fullscreen) {
836 if (content_window_)
837 desktop_window_tree_host_->SetFullscreen(fullscreen);
838 }
839
IsFullscreen() const840 bool DesktopNativeWidgetAura::IsFullscreen() const {
841 return content_window_ && desktop_window_tree_host_->IsFullscreen();
842 }
843
SetOpacity(unsigned char opacity)844 void DesktopNativeWidgetAura::SetOpacity(unsigned char opacity) {
845 if (content_window_)
846 desktop_window_tree_host_->SetOpacity(opacity);
847 }
848
SetUseDragFrame(bool use_drag_frame)849 void DesktopNativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
850 }
851
FlashFrame(bool flash_frame)852 void DesktopNativeWidgetAura::FlashFrame(bool flash_frame) {
853 if (content_window_)
854 desktop_window_tree_host_->FlashFrame(flash_frame);
855 }
856
RunShellDrag(View * view,const ui::OSExchangeData & data,const gfx::Point & location,int operation,ui::DragDropTypes::DragEventSource source)857 void DesktopNativeWidgetAura::RunShellDrag(
858 View* view,
859 const ui::OSExchangeData& data,
860 const gfx::Point& location,
861 int operation,
862 ui::DragDropTypes::DragEventSource source) {
863 views::RunShellDrag(content_window_, data, location, operation, source);
864 }
865
SchedulePaintInRect(const gfx::Rect & rect)866 void DesktopNativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) {
867 if (content_window_)
868 content_window_->SchedulePaintInRect(rect);
869 }
870
SetCursor(gfx::NativeCursor cursor)871 void DesktopNativeWidgetAura::SetCursor(gfx::NativeCursor cursor) {
872 cursor_ = cursor;
873 aura::client::CursorClient* cursor_client =
874 aura::client::GetCursorClient(host_->window());
875 if (cursor_client)
876 cursor_client->SetCursor(cursor);
877 }
878
IsMouseEventsEnabled() const879 bool DesktopNativeWidgetAura::IsMouseEventsEnabled() const {
880 if (!content_window_)
881 return false;
882 aura::client::CursorClient* cursor_client =
883 aura::client::GetCursorClient(host_->window());
884 return cursor_client ? cursor_client->IsMouseEventsEnabled() : true;
885 }
886
ClearNativeFocus()887 void DesktopNativeWidgetAura::ClearNativeFocus() {
888 desktop_window_tree_host_->ClearNativeFocus();
889
890 if (ShouldActivate()) {
891 aura::client::GetFocusClient(content_window_)->
892 ResetFocusWithinActiveWindow(content_window_);
893 }
894 }
895
GetWorkAreaBoundsInScreen() const896 gfx::Rect DesktopNativeWidgetAura::GetWorkAreaBoundsInScreen() const {
897 return desktop_window_tree_host_ ?
898 desktop_window_tree_host_->GetWorkAreaBoundsInScreen() : gfx::Rect();
899 }
900
RunMoveLoop(const gfx::Vector2d & drag_offset,Widget::MoveLoopSource source,Widget::MoveLoopEscapeBehavior escape_behavior)901 Widget::MoveLoopResult DesktopNativeWidgetAura::RunMoveLoop(
902 const gfx::Vector2d& drag_offset,
903 Widget::MoveLoopSource source,
904 Widget::MoveLoopEscapeBehavior escape_behavior) {
905 if (!content_window_)
906 return Widget::MOVE_LOOP_CANCELED;
907 return desktop_window_tree_host_->RunMoveLoop(drag_offset, source,
908 escape_behavior);
909 }
910
EndMoveLoop()911 void DesktopNativeWidgetAura::EndMoveLoop() {
912 if (content_window_)
913 desktop_window_tree_host_->EndMoveLoop();
914 }
915
SetVisibilityChangedAnimationsEnabled(bool value)916 void DesktopNativeWidgetAura::SetVisibilityChangedAnimationsEnabled(
917 bool value) {
918 if (content_window_)
919 desktop_window_tree_host_->SetVisibilityChangedAnimationsEnabled(value);
920 }
921
GetNativeTheme() const922 ui::NativeTheme* DesktopNativeWidgetAura::GetNativeTheme() const {
923 return DesktopWindowTreeHost::GetNativeTheme(content_window_);
924 }
925
OnRootViewLayout()926 void DesktopNativeWidgetAura::OnRootViewLayout() {
927 if (content_window_)
928 desktop_window_tree_host_->OnRootViewLayout();
929 }
930
IsTranslucentWindowOpacitySupported() const931 bool DesktopNativeWidgetAura::IsTranslucentWindowOpacitySupported() const {
932 return content_window_ &&
933 desktop_window_tree_host_->IsTranslucentWindowOpacitySupported();
934 }
935
OnSizeConstraintsChanged()936 void DesktopNativeWidgetAura::OnSizeConstraintsChanged() {
937 content_window_->SetProperty(aura::client::kCanMaximizeKey,
938 GetWidget()->widget_delegate()->CanMaximize());
939 content_window_->SetProperty(aura::client::kCanResizeKey,
940 GetWidget()->widget_delegate()->CanResize());
941 desktop_window_tree_host_->SizeConstraintsChanged();
942 }
943
RepostNativeEvent(gfx::NativeEvent native_event)944 void DesktopNativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) {
945 OnEvent(native_event);
946 }
947
948 ////////////////////////////////////////////////////////////////////////////////
949 // DesktopNativeWidgetAura, aura::WindowDelegate implementation:
950
GetMinimumSize() const951 gfx::Size DesktopNativeWidgetAura::GetMinimumSize() const {
952 return native_widget_delegate_->GetMinimumSize();
953 }
954
GetMaximumSize() const955 gfx::Size DesktopNativeWidgetAura::GetMaximumSize() const {
956 return native_widget_delegate_->GetMaximumSize();
957 }
958
GetCursor(const gfx::Point & point)959 gfx::NativeCursor DesktopNativeWidgetAura::GetCursor(const gfx::Point& point) {
960 return cursor_;
961 }
962
GetNonClientComponent(const gfx::Point & point) const963 int DesktopNativeWidgetAura::GetNonClientComponent(
964 const gfx::Point& point) const {
965 return native_widget_delegate_->GetNonClientComponent(point);
966 }
967
ShouldDescendIntoChildForEventHandling(aura::Window * child,const gfx::Point & location)968 bool DesktopNativeWidgetAura::ShouldDescendIntoChildForEventHandling(
969 aura::Window* child,
970 const gfx::Point& location) {
971 views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
972 return !widget_delegate ||
973 widget_delegate->ShouldDescendIntoChildForEventHandling(child, location);
974 }
975
CanFocus()976 bool DesktopNativeWidgetAura::CanFocus() {
977 return true;
978 }
979
OnCaptureLost()980 void DesktopNativeWidgetAura::OnCaptureLost() {
981 native_widget_delegate_->OnMouseCaptureLost();
982 }
983
OnPaint(gfx::Canvas * canvas)984 void DesktopNativeWidgetAura::OnPaint(gfx::Canvas* canvas) {
985 native_widget_delegate_->OnNativeWidgetPaint(canvas);
986 }
987
OnDeviceScaleFactorChanged(float device_scale_factor)988 void DesktopNativeWidgetAura::OnDeviceScaleFactorChanged(
989 float device_scale_factor) {
990 }
991
OnWindowDestroying(aura::Window * window)992 void DesktopNativeWidgetAura::OnWindowDestroying(aura::Window* window) {
993 // Cleanup happens in OnHostClosed().
994 }
995
OnWindowDestroyed(aura::Window * window)996 void DesktopNativeWidgetAura::OnWindowDestroyed(aura::Window* window) {
997 // Cleanup happens in OnHostClosed(). We own |content_window_| (indirectly by
998 // way of |dispatcher_|) so there should be no need to do any processing
999 // here.
1000 }
1001
OnWindowTargetVisibilityChanged(bool visible)1002 void DesktopNativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
1003 }
1004
HasHitTestMask() const1005 bool DesktopNativeWidgetAura::HasHitTestMask() const {
1006 return native_widget_delegate_->HasHitTestMask();
1007 }
1008
GetHitTestMask(gfx::Path * mask) const1009 void DesktopNativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
1010 native_widget_delegate_->GetHitTestMask(mask);
1011 }
1012
1013 ////////////////////////////////////////////////////////////////////////////////
1014 // DesktopNativeWidgetAura, ui::EventHandler implementation:
1015
OnKeyEvent(ui::KeyEvent * event)1016 void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
1017 if (event->is_char()) {
1018 // If a ui::InputMethod object is attached to the root window, character
1019 // events are handled inside the object and are not passed to this function.
1020 // If such object is not attached, character events might be sent (e.g. on
1021 // Windows). In this case, we just skip these.
1022 return;
1023 }
1024 // Renderer may send a key event back to us if the key event wasn't handled,
1025 // and the window may be invisible by that time.
1026 if (!content_window_->IsVisible())
1027 return;
1028
1029 native_widget_delegate_->OnKeyEvent(event);
1030 if (event->handled())
1031 return;
1032
1033 if (GetWidget()->HasFocusManager() &&
1034 !GetWidget()->GetFocusManager()->OnKeyEvent(*event))
1035 event->SetHandled();
1036 }
1037
OnMouseEvent(ui::MouseEvent * event)1038 void DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
1039 DCHECK(content_window_->IsVisible());
1040 if (tooltip_manager_.get())
1041 tooltip_manager_->UpdateTooltip();
1042 TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
1043 native_widget_delegate_->OnMouseEvent(event);
1044 // WARNING: we may have been deleted.
1045 }
1046
OnScrollEvent(ui::ScrollEvent * event)1047 void DesktopNativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
1048 if (event->type() == ui::ET_SCROLL) {
1049 native_widget_delegate_->OnScrollEvent(event);
1050 if (event->handled())
1051 return;
1052
1053 // Convert unprocessed scroll events into wheel events.
1054 ui::MouseWheelEvent mwe(*static_cast<ui::ScrollEvent*>(event));
1055 native_widget_delegate_->OnMouseEvent(&mwe);
1056 if (mwe.handled())
1057 event->SetHandled();
1058 } else {
1059 native_widget_delegate_->OnScrollEvent(event);
1060 }
1061 }
1062
OnGestureEvent(ui::GestureEvent * event)1063 void DesktopNativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
1064 native_widget_delegate_->OnGestureEvent(event);
1065 }
1066
1067 ////////////////////////////////////////////////////////////////////////////////
1068 // DesktopNativeWidgetAura, aura::client::ActivationDelegate implementation:
1069
ShouldActivate() const1070 bool DesktopNativeWidgetAura::ShouldActivate() const {
1071 return native_widget_delegate_->CanActivate();
1072 }
1073
1074 ////////////////////////////////////////////////////////////////////////////////
1075 // DesktopNativeWidgetAura, aura::client::ActivationChangeObserver
1076 // implementation:
1077
OnWindowActivated(aura::Window * gained_active,aura::Window * lost_active)1078 void DesktopNativeWidgetAura::OnWindowActivated(aura::Window* gained_active,
1079 aura::Window* lost_active) {
1080 DCHECK(content_window_ == gained_active || content_window_ == lost_active);
1081 if (gained_active == content_window_ && restore_focus_on_activate_) {
1082 restore_focus_on_activate_ = false;
1083 GetWidget()->GetFocusManager()->RestoreFocusedView();
1084 } else if (lost_active == content_window_ && GetWidget()->HasFocusManager()) {
1085 DCHECK(!restore_focus_on_activate_);
1086 restore_focus_on_activate_ = true;
1087 // Pass in false so that ClearNativeFocus() isn't invoked.
1088 GetWidget()->GetFocusManager()->StoreFocusedView(false);
1089 }
1090 }
1091
1092 ////////////////////////////////////////////////////////////////////////////////
1093 // DesktopNativeWidgetAura, aura::client::FocusChangeObserver implementation:
1094
OnWindowFocused(aura::Window * gained_focus,aura::Window * lost_focus)1095 void DesktopNativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
1096 aura::Window* lost_focus) {
1097 if (content_window_ == gained_focus) {
1098 desktop_window_tree_host_->OnNativeWidgetFocus();
1099 native_widget_delegate_->OnNativeFocus(lost_focus);
1100
1101 // If focus is moving from a descendant Window to |content_window_| then
1102 // native activation hasn't changed. Still, the InputMethod must be informed
1103 // of the Window focus change.
1104 InputMethod* input_method = GetWidget()->GetInputMethod();
1105 if (input_method)
1106 input_method->OnFocus();
1107 } else if (content_window_ == lost_focus) {
1108 desktop_window_tree_host_->OnNativeWidgetBlur();
1109 native_widget_delegate_->OnNativeBlur(gained_focus);
1110 }
1111 }
1112
1113 ////////////////////////////////////////////////////////////////////////////////
1114 // DesktopNativeWidgetAura, views::internal::InputMethodDelegate:
1115
DispatchKeyEventPostIME(const ui::KeyEvent & key)1116 void DesktopNativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
1117 FocusManager* focus_manager =
1118 native_widget_delegate_->AsWidget()->GetFocusManager();
1119 native_widget_delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key));
1120 if (key.handled() || !focus_manager)
1121 return;
1122 focus_manager->OnKeyEvent(key);
1123 }
1124
1125 ////////////////////////////////////////////////////////////////////////////////
1126 // DesktopNativeWidgetAura, aura::WindowDragDropDelegate implementation:
1127
OnDragEntered(const ui::DropTargetEvent & event)1128 void DesktopNativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
1129 DCHECK(drop_helper_.get() != NULL);
1130 last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
1131 event.location(), event.source_operations());
1132 }
1133
OnDragUpdated(const ui::DropTargetEvent & event)1134 int DesktopNativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
1135 DCHECK(drop_helper_.get() != NULL);
1136 last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
1137 event.location(), event.source_operations());
1138 return last_drop_operation_;
1139 }
1140
OnDragExited()1141 void DesktopNativeWidgetAura::OnDragExited() {
1142 DCHECK(drop_helper_.get() != NULL);
1143 drop_helper_->OnDragExit();
1144 }
1145
OnPerformDrop(const ui::DropTargetEvent & event)1146 int DesktopNativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
1147 DCHECK(drop_helper_.get() != NULL);
1148 if (ShouldActivate())
1149 Activate();
1150 return drop_helper_->OnDrop(event.data(), event.location(),
1151 last_drop_operation_);
1152 }
1153
1154 ////////////////////////////////////////////////////////////////////////////////
1155 // DesktopNativeWidgetAura, aura::WindowTreeHostObserver implementation:
1156
OnHostCloseRequested(const aura::WindowTreeHost * host)1157 void DesktopNativeWidgetAura::OnHostCloseRequested(
1158 const aura::WindowTreeHost* host) {
1159 GetWidget()->Close();
1160 }
1161
OnHostResized(const aura::WindowTreeHost * host)1162 void DesktopNativeWidgetAura::OnHostResized(const aura::WindowTreeHost* host) {
1163 // Don't update the bounds of the child layers when animating closed. If we
1164 // did it would force a paint, which we don't want. We don't want the paint
1165 // as we can't assume any of the children are valid.
1166 if (desktop_window_tree_host_->IsAnimatingClosed())
1167 return;
1168
1169 gfx::Rect new_bounds = gfx::Rect(host->window()->bounds().size());
1170 content_window_->SetBounds(new_bounds);
1171 // Can be NULL at start.
1172 if (content_window_container_)
1173 content_window_container_->SetBounds(new_bounds);
1174 native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
1175 }
1176
OnHostMoved(const aura::WindowTreeHost * host,const gfx::Point & new_origin)1177 void DesktopNativeWidgetAura::OnHostMoved(const aura::WindowTreeHost* host,
1178 const gfx::Point& new_origin) {
1179 TRACE_EVENT1("views", "DesktopNativeWidgetAura::OnHostMoved",
1180 "new_origin", new_origin.ToString());
1181
1182 native_widget_delegate_->OnNativeWidgetMove();
1183 }
1184
1185 ////////////////////////////////////////////////////////////////////////////////
1186 // DesktopNativeWidgetAura, private:
1187
InstallInputMethodEventFilter()1188 void DesktopNativeWidgetAura::InstallInputMethodEventFilter() {
1189 DCHECK(!input_method_event_filter_.get());
1190
1191 input_method_event_filter_.reset(new wm::InputMethodEventFilter(
1192 host_->GetAcceleratedWidget()));
1193 input_method_event_filter_->SetInputMethodPropertyInRootWindow(
1194 host_->window());
1195 root_window_event_filter_->AddHandler(input_method_event_filter_.get());
1196 }
1197
UpdateWindowTransparency()1198 void DesktopNativeWidgetAura::UpdateWindowTransparency() {
1199 content_window_->SetTransparent(
1200 desktop_window_tree_host_->ShouldWindowContentsBeTransparent());
1201 // Regardless of transparency or not, this root content window will always
1202 // fill its bounds completely, so set this flag to true to avoid an
1203 // unecessary clear before update.
1204 content_window_->SetFillsBoundsCompletely(true);
1205 }
1206
RootWindowDestroyed()1207 void DesktopNativeWidgetAura::RootWindowDestroyed() {
1208 cursor_reference_count_--;
1209 if (cursor_reference_count_ == 0) {
1210 // We are the last DesktopNativeWidgetAura instance, and we are responsible
1211 // for cleaning up |cursor_manager_|.
1212 delete cursor_manager_;
1213 native_cursor_manager_ = NULL;
1214 cursor_manager_ = NULL;
1215 }
1216 }
1217
1218 } // namespace views
1219