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/native_widget_aura.h"
6
7 #include "base/bind.h"
8 #include "base/strings/string_util.h"
9 #include "third_party/skia/include/core/SkRegion.h"
10 #include "ui/aura/client/aura_constants.h"
11 #include "ui/aura/client/cursor_client.h"
12 #include "ui/aura/client/focus_client.h"
13 #include "ui/aura/client/screen_position_client.h"
14 #include "ui/aura/client/window_tree_client.h"
15 #include "ui/aura/env.h"
16 #include "ui/aura/window.h"
17 #include "ui/aura/window_event_dispatcher.h"
18 #include "ui/aura/window_observer.h"
19 #include "ui/base/dragdrop/os_exchange_data.h"
20 #include "ui/base/ui_base_switches_util.h"
21 #include "ui/base/ui_base_types.h"
22 #include "ui/compositor/layer.h"
23 #include "ui/events/event.h"
24 #include "ui/gfx/canvas.h"
25 #include "ui/gfx/font_list.h"
26 #include "ui/gfx/screen.h"
27 #include "ui/native_theme/native_theme_aura.h"
28 #include "ui/views/drag_utils.h"
29 #include "ui/views/ime/input_method_bridge.h"
30 #include "ui/views/ime/null_input_method.h"
31 #include "ui/views/views_delegate.h"
32 #include "ui/views/widget/drop_helper.h"
33 #include "ui/views/widget/native_widget_delegate.h"
34 #include "ui/views/widget/root_view.h"
35 #include "ui/views/widget/tooltip_manager_aura.h"
36 #include "ui/views/widget/widget_aura_utils.h"
37 #include "ui/views/widget/widget_delegate.h"
38 #include "ui/views/widget/window_reorderer.h"
39 #include "ui/wm/core/shadow_types.h"
40 #include "ui/wm/core/window_util.h"
41 #include "ui/wm/public/activation_client.h"
42 #include "ui/wm/public/drag_drop_client.h"
43 #include "ui/wm/public/window_move_client.h"
44 #include "ui/wm/public/window_types.h"
45
46 #if defined(OS_WIN)
47 #include "base/win/scoped_gdi_object.h"
48 #include "base/win/win_util.h"
49 #include "ui/base/l10n/l10n_util_win.h"
50 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
51 #endif
52
53 #if defined(USE_X11) && !defined(OS_CHROMEOS)
54 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
55 #endif
56
57 #if !defined(OS_CHROMEOS)
58 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
59 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
60 #endif
61
62 namespace views {
63
64 namespace {
65
SetRestoreBounds(aura::Window * window,const gfx::Rect & bounds)66 void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) {
67 window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds));
68 }
69
70 } // namespace
71
72 ////////////////////////////////////////////////////////////////////////////////
73 // NativeWidgetAura, public:
74
NativeWidgetAura(internal::NativeWidgetDelegate * delegate)75 NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
76 : delegate_(delegate),
77 window_(new aura::Window(this)),
78 ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
79 destroying_(false),
80 cursor_(gfx::kNullCursor),
81 saved_window_state_(ui::SHOW_STATE_DEFAULT),
82 close_widget_factory_(this) {
83 aura::client::SetFocusChangeObserver(window_, this);
84 aura::client::SetActivationChangeObserver(window_, this);
85 }
86
87 // static
RegisterNativeWidgetForWindow(internal::NativeWidgetPrivate * native_widget,aura::Window * window)88 void NativeWidgetAura::RegisterNativeWidgetForWindow(
89 internal::NativeWidgetPrivate* native_widget,
90 aura::Window* window) {
91 window->set_user_data(native_widget);
92 }
93
94 ////////////////////////////////////////////////////////////////////////////////
95 // NativeWidgetAura, internal::NativeWidgetPrivate implementation:
96
InitNativeWidget(const Widget::InitParams & params)97 void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
98 // Aura needs to know which desktop (Ash or regular) will manage this widget.
99 // See Widget::InitParams::context for details.
100 DCHECK(params.parent || params.context);
101
102 ownership_ = params.ownership;
103
104 RegisterNativeWidgetForWindow(this, window_);
105 window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
106 window_->SetProperty(aura::client::kShowStateKey, params.show_state);
107 if (params.type == Widget::InitParams::TYPE_BUBBLE)
108 aura::client::SetHideOnDeactivate(window_, true);
109 window_->SetTransparent(
110 params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW);
111 window_->Init(params.layer_type);
112 if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_NONE)
113 SetShadowType(window_, wm::SHADOW_TYPE_NONE);
114 else if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_DROP)
115 SetShadowType(window_, wm::SHADOW_TYPE_RECTANGULAR);
116 if (params.type == Widget::InitParams::TYPE_CONTROL)
117 window_->Show();
118
119 delegate_->OnNativeWidgetCreated(false);
120
121 gfx::Rect window_bounds = params.bounds;
122 gfx::NativeView parent = params.parent;
123 gfx::NativeView context = params.context;
124 if (!params.child) {
125 // Set up the transient child before the window is added. This way the
126 // LayoutManager knows the window has a transient parent.
127 if (parent && parent->type() != ui::wm::WINDOW_TYPE_UNKNOWN) {
128 wm::AddTransientChild(parent, window_);
129 if (!context)
130 context = parent;
131 parent = NULL;
132 }
133 // SetAlwaysOnTop before SetParent so that always-on-top container is used.
134 SetAlwaysOnTop(params.keep_on_top);
135 // Make sure we have a real |window_bounds|.
136 if (parent && window_bounds == gfx::Rect()) {
137 // If a parent is specified but no bounds are given,
138 // use the origin of the parent's display so that the widget
139 // will be added to the same display as the parent.
140 gfx::Rect bounds = gfx::Screen::GetScreenFor(parent)->
141 GetDisplayNearestWindow(parent).bounds();
142 window_bounds.set_origin(bounds.origin());
143 }
144 }
145
146 // Set properties before adding to the parent so that its layout manager sees
147 // the correct values.
148 OnSizeConstraintsChanged();
149
150 if (parent) {
151 parent->AddChild(window_);
152 } else {
153 aura::client::ParentWindowWithContext(
154 window_, context->GetRootWindow(), window_bounds);
155 }
156
157 // Start observing property changes.
158 window_->AddObserver(this);
159
160 // Wait to set the bounds until we have a parent. That way we can know our
161 // true state/bounds (the LayoutManager may enforce a particular
162 // state/bounds).
163 if (IsMaximized())
164 SetRestoreBounds(window_, window_bounds);
165 else
166 SetBounds(window_bounds);
167 window_->set_ignore_events(!params.accept_events);
168 DCHECK(GetWidget()->GetRootView());
169 if (params.type != Widget::InitParams::TYPE_TOOLTIP)
170 tooltip_manager_.reset(new views::TooltipManagerAura(GetWidget()));
171
172 drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
173 if (params.type != Widget::InitParams::TYPE_TOOLTIP &&
174 params.type != Widget::InitParams::TYPE_POPUP) {
175 aura::client::SetDragDropDelegate(window_, this);
176 }
177
178 aura::client::SetActivationDelegate(window_, this);
179
180 window_reorderer_.reset(new WindowReorderer(window_,
181 GetWidget()->GetRootView()));
182 }
183
CreateNonClientFrameView()184 NonClientFrameView* NativeWidgetAura::CreateNonClientFrameView() {
185 return NULL;
186 }
187
ShouldUseNativeFrame() const188 bool NativeWidgetAura::ShouldUseNativeFrame() const {
189 // There is only one frame type for aura.
190 return false;
191 }
192
ShouldWindowContentsBeTransparent() const193 bool NativeWidgetAura::ShouldWindowContentsBeTransparent() const {
194 return false;
195 }
196
FrameTypeChanged()197 void NativeWidgetAura::FrameTypeChanged() {
198 // This is called when the Theme has changed; forward the event to the root
199 // widget.
200 GetWidget()->ThemeChanged();
201 GetWidget()->GetRootView()->SchedulePaint();
202 }
203
GetWidget()204 Widget* NativeWidgetAura::GetWidget() {
205 return delegate_->AsWidget();
206 }
207
GetWidget() const208 const Widget* NativeWidgetAura::GetWidget() const {
209 return delegate_->AsWidget();
210 }
211
GetNativeView() const212 gfx::NativeView NativeWidgetAura::GetNativeView() const {
213 return window_;
214 }
215
GetNativeWindow() const216 gfx::NativeWindow NativeWidgetAura::GetNativeWindow() const {
217 return window_;
218 }
219
GetTopLevelWidget()220 Widget* NativeWidgetAura::GetTopLevelWidget() {
221 NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());
222 return native_widget ? native_widget->GetWidget() : NULL;
223 }
224
GetCompositor() const225 const ui::Compositor* NativeWidgetAura::GetCompositor() const {
226 return window_ ? window_->layer()->GetCompositor() : NULL;
227 }
228
GetCompositor()229 ui::Compositor* NativeWidgetAura::GetCompositor() {
230 return window_ ? window_->layer()->GetCompositor() : NULL;
231 }
232
GetLayer()233 ui::Layer* NativeWidgetAura::GetLayer() {
234 return window_ ? window_->layer() : NULL;
235 }
236
ReorderNativeViews()237 void NativeWidgetAura::ReorderNativeViews() {
238 window_reorderer_->ReorderChildWindows();
239 }
240
ViewRemoved(View * view)241 void NativeWidgetAura::ViewRemoved(View* view) {
242 DCHECK(drop_helper_.get() != NULL);
243 drop_helper_->ResetTargetViewIfEquals(view);
244 }
245
SetNativeWindowProperty(const char * name,void * value)246 void NativeWidgetAura::SetNativeWindowProperty(const char* name, void* value) {
247 if (window_)
248 window_->SetNativeWindowProperty(name, value);
249 }
250
GetNativeWindowProperty(const char * name) const251 void* NativeWidgetAura::GetNativeWindowProperty(const char* name) const {
252 return window_ ? window_->GetNativeWindowProperty(name) : NULL;
253 }
254
GetTooltipManager() const255 TooltipManager* NativeWidgetAura::GetTooltipManager() const {
256 return tooltip_manager_.get();
257 }
258
SetCapture()259 void NativeWidgetAura::SetCapture() {
260 if (window_)
261 window_->SetCapture();
262 }
263
ReleaseCapture()264 void NativeWidgetAura::ReleaseCapture() {
265 if (window_)
266 window_->ReleaseCapture();
267 }
268
HasCapture() const269 bool NativeWidgetAura::HasCapture() const {
270 return window_ && window_->HasCapture();
271 }
272
CreateInputMethod()273 InputMethod* NativeWidgetAura::CreateInputMethod() {
274 if (!window_)
275 return NULL;
276
277 if (switches::IsTextInputFocusManagerEnabled())
278 return new NullInputMethod();
279
280 aura::Window* root_window = window_->GetRootWindow();
281 ui::InputMethod* host =
282 root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
283 return new InputMethodBridge(this, host, true);
284 }
285
GetInputMethodDelegate()286 internal::InputMethodDelegate* NativeWidgetAura::GetInputMethodDelegate() {
287 return this;
288 }
289
GetHostInputMethod()290 ui::InputMethod* NativeWidgetAura::GetHostInputMethod() {
291 aura::Window* root_window = window_->GetRootWindow();
292 return root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
293 }
294
CenterWindow(const gfx::Size & size)295 void NativeWidgetAura::CenterWindow(const gfx::Size& size) {
296 if (!window_)
297 return;
298
299 gfx::Rect parent_bounds(window_->parent()->GetBoundsInRootWindow());
300 // When centering window, we take the intersection of the host and
301 // the parent. We assume the root window represents the visible
302 // rect of a single screen.
303 gfx::Rect work_area = gfx::Screen::GetScreenFor(window_)->
304 GetDisplayNearestWindow(window_).work_area();
305
306 aura::client::ScreenPositionClient* screen_position_client =
307 aura::client::GetScreenPositionClient(window_->GetRootWindow());
308 if (screen_position_client) {
309 gfx::Point origin = work_area.origin();
310 screen_position_client->ConvertPointFromScreen(window_->GetRootWindow(),
311 &origin);
312 work_area.set_origin(origin);
313 }
314
315 parent_bounds.Intersect(work_area);
316
317 // If |window_|'s transient parent's bounds are big enough to fit it, then we
318 // center it with respect to the transient parent.
319 if (wm::GetTransientParent(window_)) {
320 gfx::Rect transient_parent_rect =
321 wm::GetTransientParent(window_)->GetBoundsInRootWindow();
322 transient_parent_rect.Intersect(work_area);
323 if (transient_parent_rect.height() >= size.height() &&
324 transient_parent_rect.width() >= size.width())
325 parent_bounds = transient_parent_rect;
326 }
327
328 gfx::Rect window_bounds(
329 parent_bounds.x() + (parent_bounds.width() - size.width()) / 2,
330 parent_bounds.y() + (parent_bounds.height() - size.height()) / 2,
331 size.width(),
332 size.height());
333 // Don't size the window bigger than the parent, otherwise the user may not be
334 // able to close or move it.
335 window_bounds.AdjustToFit(parent_bounds);
336
337 // Convert the bounds back relative to the parent.
338 gfx::Point origin = window_bounds.origin();
339 aura::Window::ConvertPointToTarget(window_->GetRootWindow(),
340 window_->parent(), &origin);
341 window_bounds.set_origin(origin);
342 window_->SetBounds(window_bounds);
343 }
344
GetWindowPlacement(gfx::Rect * bounds,ui::WindowShowState * show_state) const345 void NativeWidgetAura::GetWindowPlacement(
346 gfx::Rect* bounds,
347 ui::WindowShowState* show_state) const {
348 // The interface specifies returning restored bounds, not current bounds.
349 *bounds = GetRestoredBounds();
350 *show_state = window_ ? window_->GetProperty(aura::client::kShowStateKey) :
351 ui::SHOW_STATE_DEFAULT;
352 }
353
SetWindowTitle(const base::string16 & title)354 bool NativeWidgetAura::SetWindowTitle(const base::string16& title) {
355 if (!window_)
356 return false;
357 if (window_->title() == title)
358 return false;
359 window_->SetTitle(title);
360 return true;
361 }
362
SetWindowIcons(const gfx::ImageSkia & window_icon,const gfx::ImageSkia & app_icon)363 void NativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon,
364 const gfx::ImageSkia& app_icon) {
365 // Aura doesn't have window icons.
366 }
367
InitModalType(ui::ModalType modal_type)368 void NativeWidgetAura::InitModalType(ui::ModalType modal_type) {
369 if (modal_type != ui::MODAL_TYPE_NONE)
370 window_->SetProperty(aura::client::kModalKey, modal_type);
371 }
372
GetWindowBoundsInScreen() const373 gfx::Rect NativeWidgetAura::GetWindowBoundsInScreen() const {
374 return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
375 }
376
GetClientAreaBoundsInScreen() const377 gfx::Rect NativeWidgetAura::GetClientAreaBoundsInScreen() const {
378 // View-to-screen coordinate system transformations depend on this returning
379 // the full window bounds, for example View::ConvertPointToScreen().
380 return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
381 }
382
GetRestoredBounds() const383 gfx::Rect NativeWidgetAura::GetRestoredBounds() const {
384 if (!window_)
385 return gfx::Rect();
386
387 // Restored bounds should only be relevant if the window is minimized or
388 // maximized. However, in some places the code expects GetRestoredBounds()
389 // to return the current window bounds if the window is not in either state.
390 if (IsMinimized() || IsMaximized() || IsFullscreen()) {
391 // Restore bounds are in screen coordinates, no need to convert.
392 gfx::Rect* restore_bounds =
393 window_->GetProperty(aura::client::kRestoreBoundsKey);
394 if (restore_bounds)
395 return *restore_bounds;
396 }
397 return window_->GetBoundsInScreen();
398 }
399
SetBounds(const gfx::Rect & bounds)400 void NativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
401 if (!window_)
402 return;
403
404 aura::Window* root = window_->GetRootWindow();
405 if (root) {
406 aura::client::ScreenPositionClient* screen_position_client =
407 aura::client::GetScreenPositionClient(root);
408 if (screen_position_client) {
409 gfx::Display dst_display =
410 gfx::Screen::GetScreenFor(window_)->GetDisplayMatching(bounds);
411 screen_position_client->SetBounds(window_, bounds, dst_display);
412 return;
413 }
414 }
415 window_->SetBounds(bounds);
416 }
417
SetSize(const gfx::Size & size)418 void NativeWidgetAura::SetSize(const gfx::Size& size) {
419 if (window_)
420 window_->SetBounds(gfx::Rect(window_->bounds().origin(), size));
421 }
422
StackAbove(gfx::NativeView native_view)423 void NativeWidgetAura::StackAbove(gfx::NativeView native_view) {
424 if (window_ && window_->parent() &&
425 window_->parent() == native_view->parent())
426 window_->parent()->StackChildAbove(window_, native_view);
427 }
428
StackAtTop()429 void NativeWidgetAura::StackAtTop() {
430 if (window_)
431 window_->parent()->StackChildAtTop(window_);
432 }
433
StackBelow(gfx::NativeView native_view)434 void NativeWidgetAura::StackBelow(gfx::NativeView native_view) {
435 if (window_ && window_->parent() &&
436 window_->parent() == native_view->parent())
437 window_->parent()->StackChildBelow(window_, native_view);
438 }
439
SetShape(gfx::NativeRegion region)440 void NativeWidgetAura::SetShape(gfx::NativeRegion region) {
441 if (window_)
442 window_->layer()->SetAlphaShape(make_scoped_ptr(region));
443 else
444 delete region;
445 }
446
Close()447 void NativeWidgetAura::Close() {
448 // |window_| may already be deleted by parent window. This can happen
449 // when this widget is child widget or has transient parent
450 // and ownership is WIDGET_OWNS_NATIVE_WIDGET.
451 DCHECK(window_ ||
452 ownership_ == Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
453 if (window_) {
454 window_->SuppressPaint();
455 Hide();
456 window_->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_NONE);
457 }
458
459 if (!close_widget_factory_.HasWeakPtrs()) {
460 base::MessageLoop::current()->PostTask(
461 FROM_HERE,
462 base::Bind(&NativeWidgetAura::CloseNow,
463 close_widget_factory_.GetWeakPtr()));
464 }
465 }
466
CloseNow()467 void NativeWidgetAura::CloseNow() {
468 delete window_;
469 }
470
Show()471 void NativeWidgetAura::Show() {
472 ShowWithWindowState(ui::SHOW_STATE_NORMAL);
473 }
474
Hide()475 void NativeWidgetAura::Hide() {
476 if (window_)
477 window_->Hide();
478 }
479
ShowMaximizedWithBounds(const gfx::Rect & restored_bounds)480 void NativeWidgetAura::ShowMaximizedWithBounds(
481 const gfx::Rect& restored_bounds) {
482 SetRestoreBounds(window_, restored_bounds);
483 ShowWithWindowState(ui::SHOW_STATE_MAXIMIZED);
484 }
485
ShowWithWindowState(ui::WindowShowState state)486 void NativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
487 if (!window_)
488 return;
489
490 if (state == ui::SHOW_STATE_MAXIMIZED || state == ui::SHOW_STATE_FULLSCREEN)
491 window_->SetProperty(aura::client::kShowStateKey, state);
492 window_->Show();
493 if (delegate_->CanActivate()) {
494 if (state != ui::SHOW_STATE_INACTIVE)
495 Activate();
496 // SetInitialFocus() should be always be called, even for
497 // SHOW_STATE_INACTIVE. If the window has to stay inactive, the method will
498 // do the right thing.
499 SetInitialFocus(state);
500 }
501 }
502
IsVisible() const503 bool NativeWidgetAura::IsVisible() const {
504 return window_ && window_->IsVisible();
505 }
506
Activate()507 void NativeWidgetAura::Activate() {
508 if (!window_)
509 return;
510
511 // We don't necessarily have a root window yet. This can happen with
512 // constrained windows.
513 if (window_->GetRootWindow()) {
514 aura::client::GetActivationClient(window_->GetRootWindow())->ActivateWindow(
515 window_);
516 }
517 if (window_->GetProperty(aura::client::kDrawAttentionKey))
518 window_->SetProperty(aura::client::kDrawAttentionKey, false);
519 }
520
Deactivate()521 void NativeWidgetAura::Deactivate() {
522 if (!window_)
523 return;
524 aura::client::GetActivationClient(window_->GetRootWindow())->DeactivateWindow(
525 window_);
526 }
527
IsActive() const528 bool NativeWidgetAura::IsActive() const {
529 return window_ && wm::IsActiveWindow(window_);
530 }
531
SetAlwaysOnTop(bool on_top)532 void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
533 if (window_)
534 window_->SetProperty(aura::client::kAlwaysOnTopKey, on_top);
535 }
536
IsAlwaysOnTop() const537 bool NativeWidgetAura::IsAlwaysOnTop() const {
538 return window_ && window_->GetProperty(aura::client::kAlwaysOnTopKey);
539 }
540
SetVisibleOnAllWorkspaces(bool always_visible)541 void NativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) {
542 // Not implemented on chromeos or for child widgets.
543 }
544
Maximize()545 void NativeWidgetAura::Maximize() {
546 if (window_)
547 window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
548 }
549
Minimize()550 void NativeWidgetAura::Minimize() {
551 if (window_)
552 window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
553 }
554
IsMaximized() const555 bool NativeWidgetAura::IsMaximized() const {
556 return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
557 ui::SHOW_STATE_MAXIMIZED;
558 }
559
IsMinimized() const560 bool NativeWidgetAura::IsMinimized() const {
561 return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
562 ui::SHOW_STATE_MINIMIZED;
563 }
564
Restore()565 void NativeWidgetAura::Restore() {
566 if (window_)
567 window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
568 }
569
SetFullscreen(bool fullscreen)570 void NativeWidgetAura::SetFullscreen(bool fullscreen) {
571 if (!window_ || IsFullscreen() == fullscreen)
572 return; // Nothing to do.
573
574 // Save window state before entering full screen so that it could restored
575 // when exiting full screen.
576 if (fullscreen)
577 saved_window_state_ = window_->GetProperty(aura::client::kShowStateKey);
578
579 window_->SetProperty(
580 aura::client::kShowStateKey,
581 fullscreen ? ui::SHOW_STATE_FULLSCREEN : saved_window_state_);
582 }
583
IsFullscreen() const584 bool NativeWidgetAura::IsFullscreen() const {
585 return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
586 ui::SHOW_STATE_FULLSCREEN;
587 }
588
SetOpacity(unsigned char opacity)589 void NativeWidgetAura::SetOpacity(unsigned char opacity) {
590 if (window_)
591 window_->layer()->SetOpacity(opacity / 255.0);
592 }
593
SetUseDragFrame(bool use_drag_frame)594 void NativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
595 NOTIMPLEMENTED();
596 }
597
FlashFrame(bool flash)598 void NativeWidgetAura::FlashFrame(bool flash) {
599 if (window_)
600 window_->SetProperty(aura::client::kDrawAttentionKey, flash);
601 }
602
RunShellDrag(View * view,const ui::OSExchangeData & data,const gfx::Point & location,int operation,ui::DragDropTypes::DragEventSource source)603 void NativeWidgetAura::RunShellDrag(View* view,
604 const ui::OSExchangeData& data,
605 const gfx::Point& location,
606 int operation,
607 ui::DragDropTypes::DragEventSource source) {
608 if (window_)
609 views::RunShellDrag(window_, data, location, operation, source);
610 }
611
SchedulePaintInRect(const gfx::Rect & rect)612 void NativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) {
613 if (window_)
614 window_->SchedulePaintInRect(rect);
615 }
616
SetCursor(gfx::NativeCursor cursor)617 void NativeWidgetAura::SetCursor(gfx::NativeCursor cursor) {
618 cursor_ = cursor;
619 aura::client::CursorClient* cursor_client =
620 aura::client::GetCursorClient(window_->GetRootWindow());
621 if (cursor_client)
622 cursor_client->SetCursor(cursor);
623 }
624
IsMouseEventsEnabled() const625 bool NativeWidgetAura::IsMouseEventsEnabled() const {
626 if (!window_)
627 return false;
628 aura::client::CursorClient* cursor_client =
629 aura::client::GetCursorClient(window_->GetRootWindow());
630 return cursor_client ? cursor_client->IsMouseEventsEnabled() : true;
631 }
632
ClearNativeFocus()633 void NativeWidgetAura::ClearNativeFocus() {
634 aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
635 if (window_ && client && window_->Contains(client->GetFocusedWindow()))
636 client->ResetFocusWithinActiveWindow(window_);
637 }
638
GetWorkAreaBoundsInScreen() const639 gfx::Rect NativeWidgetAura::GetWorkAreaBoundsInScreen() const {
640 if (!window_)
641 return gfx::Rect();
642 return gfx::Screen::GetScreenFor(window_)->
643 GetDisplayNearestWindow(window_).work_area();
644 }
645
RunMoveLoop(const gfx::Vector2d & drag_offset,Widget::MoveLoopSource source,Widget::MoveLoopEscapeBehavior escape_behavior)646 Widget::MoveLoopResult NativeWidgetAura::RunMoveLoop(
647 const gfx::Vector2d& drag_offset,
648 Widget::MoveLoopSource source,
649 Widget::MoveLoopEscapeBehavior escape_behavior) {
650 // |escape_behavior| is only needed on windows when running the native message
651 // loop.
652 if (!window_ || !window_->GetRootWindow())
653 return Widget::MOVE_LOOP_CANCELED;
654 aura::client::WindowMoveClient* move_client =
655 aura::client::GetWindowMoveClient(window_->GetRootWindow());
656 if (!move_client)
657 return Widget::MOVE_LOOP_CANCELED;
658
659 SetCapture();
660 aura::client::WindowMoveSource window_move_source =
661 source == Widget::MOVE_LOOP_SOURCE_MOUSE ?
662 aura::client::WINDOW_MOVE_SOURCE_MOUSE :
663 aura::client::WINDOW_MOVE_SOURCE_TOUCH;
664 if (move_client->RunMoveLoop(window_, drag_offset, window_move_source) ==
665 aura::client::MOVE_SUCCESSFUL) {
666 return Widget::MOVE_LOOP_SUCCESSFUL;
667 }
668 return Widget::MOVE_LOOP_CANCELED;
669 }
670
EndMoveLoop()671 void NativeWidgetAura::EndMoveLoop() {
672 if (!window_ || !window_->GetRootWindow())
673 return;
674 aura::client::WindowMoveClient* move_client =
675 aura::client::GetWindowMoveClient(window_->GetRootWindow());
676 if (move_client)
677 move_client->EndMoveLoop();
678 }
679
SetVisibilityChangedAnimationsEnabled(bool value)680 void NativeWidgetAura::SetVisibilityChangedAnimationsEnabled(bool value) {
681 if (window_)
682 window_->SetProperty(aura::client::kAnimationsDisabledKey, !value);
683 }
684
GetNativeTheme() const685 ui::NativeTheme* NativeWidgetAura::GetNativeTheme() const {
686 #if !defined(OS_CHROMEOS)
687 return DesktopWindowTreeHost::GetNativeTheme(window_);
688 #else
689 return ui::NativeThemeAura::instance();
690 #endif
691 }
692
OnRootViewLayout()693 void NativeWidgetAura::OnRootViewLayout() {
694 }
695
IsTranslucentWindowOpacitySupported() const696 bool NativeWidgetAura::IsTranslucentWindowOpacitySupported() const {
697 return true;
698 }
699
OnSizeConstraintsChanged()700 void NativeWidgetAura::OnSizeConstraintsChanged() {
701 window_->SetProperty(aura::client::kCanMaximizeKey,
702 GetWidget()->widget_delegate()->CanMaximize());
703 window_->SetProperty(aura::client::kCanResizeKey,
704 GetWidget()->widget_delegate()->CanResize());
705 }
706
RepostNativeEvent(gfx::NativeEvent native_event)707 void NativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) {
708 OnEvent(native_event);
709 }
710
711 ////////////////////////////////////////////////////////////////////////////////
712 // NativeWidgetAura, views::InputMethodDelegate implementation:
713
DispatchKeyEventPostIME(const ui::KeyEvent & key)714 void NativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
715 FocusManager* focus_manager = GetWidget()->GetFocusManager();
716 delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key));
717 if (key.handled() || !focus_manager)
718 return;
719 focus_manager->OnKeyEvent(key);
720 }
721
722 ////////////////////////////////////////////////////////////////////////////////
723 // NativeWidgetAura, aura::WindowDelegate implementation:
724
GetMinimumSize() const725 gfx::Size NativeWidgetAura::GetMinimumSize() const {
726 return delegate_->GetMinimumSize();
727 }
728
GetMaximumSize() const729 gfx::Size NativeWidgetAura::GetMaximumSize() const {
730 // If a window have a maximum size, the window should not be
731 // maximizable.
732 DCHECK(delegate_->GetMaximumSize().IsEmpty() ||
733 !window_->GetProperty(aura::client::kCanMaximizeKey));
734 return delegate_->GetMaximumSize();
735 }
736
OnBoundsChanged(const gfx::Rect & old_bounds,const gfx::Rect & new_bounds)737 void NativeWidgetAura::OnBoundsChanged(const gfx::Rect& old_bounds,
738 const gfx::Rect& new_bounds) {
739 // Assume that if the old bounds was completely empty a move happened. This
740 // handles the case of a maximize animation acquiring the layer (acquiring a
741 // layer results in clearing the bounds).
742 if (old_bounds.origin() != new_bounds.origin() ||
743 (old_bounds == gfx::Rect(0, 0, 0, 0) && !new_bounds.IsEmpty())) {
744 delegate_->OnNativeWidgetMove();
745 }
746 if (old_bounds.size() != new_bounds.size())
747 delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
748 }
749
GetCursor(const gfx::Point & point)750 gfx::NativeCursor NativeWidgetAura::GetCursor(const gfx::Point& point) {
751 return cursor_;
752 }
753
GetNonClientComponent(const gfx::Point & point) const754 int NativeWidgetAura::GetNonClientComponent(const gfx::Point& point) const {
755 return delegate_->GetNonClientComponent(point);
756 }
757
ShouldDescendIntoChildForEventHandling(aura::Window * child,const gfx::Point & location)758 bool NativeWidgetAura::ShouldDescendIntoChildForEventHandling(
759 aura::Window* child,
760 const gfx::Point& location) {
761 views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
762 if (widget_delegate &&
763 !widget_delegate->ShouldDescendIntoChildForEventHandling(child, location))
764 return false;
765
766 // Don't descend into |child| if there is a view with a Layer that contains
767 // the point and is stacked above |child|s layer.
768 typedef std::vector<ui::Layer*> Layers;
769 const Layers& root_layers(delegate_->GetRootLayers());
770 if (root_layers.empty())
771 return true;
772
773 Layers::const_iterator child_layer_iter(
774 std::find(window_->layer()->children().begin(),
775 window_->layer()->children().end(), child->layer()));
776 if (child_layer_iter == window_->layer()->children().end())
777 return true;
778
779 for (std::vector<ui::Layer*>::const_reverse_iterator i = root_layers.rbegin();
780 i != root_layers.rend(); ++i) {
781 ui::Layer* layer = *i;
782 if (layer->visible() && layer->bounds().Contains(location)) {
783 Layers::const_iterator root_layer_iter(
784 std::find(window_->layer()->children().begin(),
785 window_->layer()->children().end(), layer));
786 if (root_layer_iter > child_layer_iter)
787 return false;
788 }
789 }
790 return true;
791 }
792
CanFocus()793 bool NativeWidgetAura::CanFocus() {
794 return ShouldActivate();
795 }
796
OnCaptureLost()797 void NativeWidgetAura::OnCaptureLost() {
798 delegate_->OnMouseCaptureLost();
799 }
800
OnPaint(gfx::Canvas * canvas)801 void NativeWidgetAura::OnPaint(gfx::Canvas* canvas) {
802 delegate_->OnNativeWidgetPaint(canvas);
803 }
804
OnDeviceScaleFactorChanged(float device_scale_factor)805 void NativeWidgetAura::OnDeviceScaleFactorChanged(float device_scale_factor) {
806 // Repainting with new scale factor will paint the content at the right scale.
807 }
808
OnWindowDestroying(aura::Window * window)809 void NativeWidgetAura::OnWindowDestroying(aura::Window* window) {
810 window_->RemoveObserver(this);
811 delegate_->OnNativeWidgetDestroying();
812
813 // If the aura::Window is destroyed, we can no longer show tooltips.
814 tooltip_manager_.reset();
815 }
816
OnWindowDestroyed(aura::Window * window)817 void NativeWidgetAura::OnWindowDestroyed(aura::Window* window) {
818 window_ = NULL;
819 delegate_->OnNativeWidgetDestroyed();
820 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
821 delete this;
822 }
823
OnWindowTargetVisibilityChanged(bool visible)824 void NativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
825 delegate_->OnNativeWidgetVisibilityChanged(visible);
826 }
827
HasHitTestMask() const828 bool NativeWidgetAura::HasHitTestMask() const {
829 return delegate_->HasHitTestMask();
830 }
831
GetHitTestMask(gfx::Path * mask) const832 void NativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
833 DCHECK(mask);
834 delegate_->GetHitTestMask(mask);
835 }
836
837 ////////////////////////////////////////////////////////////////////////////////
838 // NativeWidgetAura, aura::WindowObserver implementation:
839
OnWindowPropertyChanged(aura::Window * window,const void * key,intptr_t old)840 void NativeWidgetAura::OnWindowPropertyChanged(aura::Window* window,
841 const void* key,
842 intptr_t old) {
843 if (key == aura::client::kShowStateKey)
844 delegate_->OnNativeWidgetWindowShowStateChanged();
845 }
846
847 ////////////////////////////////////////////////////////////////////////////////
848 // NativeWidgetAura, ui::EventHandler implementation:
849
OnKeyEvent(ui::KeyEvent * event)850 void NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
851 DCHECK(window_);
852 if (event->is_char()) {
853 // If a ui::InputMethod object is attached to the root window, character
854 // events are handled inside the object and are not passed to this function.
855 // If such object is not attached, character events might be sent (e.g. on
856 // Windows). In this case, we just skip these.
857 return;
858 }
859 // Renderer may send a key event back to us if the key event wasn't handled,
860 // and the window may be invisible by that time.
861 if (!window_->IsVisible())
862 return;
863 InputMethod* input_method = GetWidget()->GetInputMethod();
864 if (!input_method)
865 return;
866 input_method->DispatchKeyEvent(*event);
867 if (switches::IsTextInputFocusManagerEnabled()) {
868 FocusManager* focus_manager = GetWidget()->GetFocusManager();
869 delegate_->OnKeyEvent(event);
870 if (!event->handled() && focus_manager)
871 focus_manager->OnKeyEvent(*event);
872 }
873 event->SetHandled();
874 }
875
OnMouseEvent(ui::MouseEvent * event)876 void NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
877 DCHECK(window_);
878 DCHECK(window_->IsVisible());
879 if (event->type() == ui::ET_MOUSEWHEEL) {
880 delegate_->OnMouseEvent(event);
881 if (event->handled())
882 return;
883 }
884
885 if (tooltip_manager_.get())
886 tooltip_manager_->UpdateTooltip();
887 TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
888 delegate_->OnMouseEvent(event);
889 }
890
OnScrollEvent(ui::ScrollEvent * event)891 void NativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
892 delegate_->OnScrollEvent(event);
893 }
894
OnGestureEvent(ui::GestureEvent * event)895 void NativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
896 DCHECK(window_);
897 DCHECK(window_->IsVisible() || event->IsEndingEvent());
898 delegate_->OnGestureEvent(event);
899 }
900
901 ////////////////////////////////////////////////////////////////////////////////
902 // NativeWidgetAura, aura::client::ActivationDelegate implementation:
903
ShouldActivate() const904 bool NativeWidgetAura::ShouldActivate() const {
905 return delegate_->CanActivate();
906 }
907
908 ////////////////////////////////////////////////////////////////////////////////
909 // NativeWidgetAura, aura::client::ActivationChangeObserver implementation:
910
OnWindowActivated(aura::Window * gained_active,aura::Window * lost_active)911 void NativeWidgetAura::OnWindowActivated(aura::Window* gained_active,
912 aura::Window* lost_active) {
913 DCHECK(window_ == gained_active || window_ == lost_active);
914 if (GetWidget()->GetFocusManager()) {
915 if (window_ == gained_active)
916 GetWidget()->GetFocusManager()->RestoreFocusedView();
917 else if (window_ == lost_active)
918 GetWidget()->GetFocusManager()->StoreFocusedView(true);
919 }
920 delegate_->OnNativeWidgetActivationChanged(window_ == gained_active);
921 }
922
923 ////////////////////////////////////////////////////////////////////////////////
924 // NativeWidgetAura, aura::client::FocusChangeObserver:
925
OnWindowFocused(aura::Window * gained_focus,aura::Window * lost_focus)926 void NativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
927 aura::Window* lost_focus) {
928 if (window_ == gained_focus) {
929 // In aura, it is possible for child native widgets to take input and focus,
930 // this differs from the behavior on windows.
931 if (GetWidget()->GetInputMethod()) // Null in tests.
932 GetWidget()->GetInputMethod()->OnFocus();
933 delegate_->OnNativeFocus(lost_focus);
934 } else if (window_ == lost_focus) {
935 // GetInputMethod() recreates the input method if it's previously been
936 // destroyed. If we get called during destruction, the input method will be
937 // gone, and creating a new one and telling it that we lost the focus will
938 // trigger a DCHECK (the new input method doesn't think that we have the
939 // focus and doesn't expect a blur). OnBlur() shouldn't be called during
940 // destruction unless WIDGET_OWNS_NATIVE_WIDGET is set (which is just the
941 // case in tests).
942 if (!destroying_) {
943 if (GetWidget()->GetInputMethod())
944 GetWidget()->GetInputMethod()->OnBlur();
945 } else {
946 DCHECK_EQ(ownership_, Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
947 }
948
949 delegate_->OnNativeBlur(gained_focus);
950 }
951 }
952
953 ////////////////////////////////////////////////////////////////////////////////
954 // NativeWidgetAura, aura::WindowDragDropDelegate implementation:
955
OnDragEntered(const ui::DropTargetEvent & event)956 void NativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
957 DCHECK(drop_helper_.get() != NULL);
958 last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
959 event.location(), event.source_operations());
960 }
961
OnDragUpdated(const ui::DropTargetEvent & event)962 int NativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
963 DCHECK(drop_helper_.get() != NULL);
964 last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
965 event.location(), event.source_operations());
966 return last_drop_operation_;
967 }
968
OnDragExited()969 void NativeWidgetAura::OnDragExited() {
970 DCHECK(drop_helper_.get() != NULL);
971 drop_helper_->OnDragExit();
972 }
973
OnPerformDrop(const ui::DropTargetEvent & event)974 int NativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
975 DCHECK(drop_helper_.get() != NULL);
976 return drop_helper_->OnDrop(event.data(), event.location(),
977 last_drop_operation_);
978 }
979
980 ////////////////////////////////////////////////////////////////////////////////
981 // NativeWidgetAura, protected:
982
~NativeWidgetAura()983 NativeWidgetAura::~NativeWidgetAura() {
984 destroying_ = true;
985 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
986 delete delegate_;
987 else
988 CloseNow();
989 }
990
991 ////////////////////////////////////////////////////////////////////////////////
992 // NativeWidgetAura, private:
993
SetInitialFocus(ui::WindowShowState show_state)994 void NativeWidgetAura::SetInitialFocus(ui::WindowShowState show_state) {
995 // The window does not get keyboard messages unless we focus it.
996 if (!GetWidget()->SetInitialFocus(show_state))
997 window_->Focus();
998 }
999
1000 ////////////////////////////////////////////////////////////////////////////////
1001 // Widget, public:
1002
1003 namespace {
1004 #if defined(OS_WIN) || (defined(USE_X11) && !defined(OS_CHROMEOS))
CloseWindow(aura::Window * window)1005 void CloseWindow(aura::Window* window) {
1006 if (window) {
1007 Widget* widget = Widget::GetWidgetForNativeView(window);
1008 if (widget && widget->is_secondary_widget())
1009 // To avoid the delay in shutdown caused by using Close which may wait
1010 // for animations, use CloseNow. Because this is only used on secondary
1011 // widgets it seems relatively safe to skip the extra processing of
1012 // Close.
1013 widget->CloseNow();
1014 }
1015 }
1016 #endif
1017
1018 #if defined(OS_WIN)
WindowCallbackProc(HWND hwnd,LPARAM lParam)1019 BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
1020 aura::Window* root_window =
1021 DesktopWindowTreeHostWin::GetContentWindowForHWND(hwnd);
1022 CloseWindow(root_window);
1023 return TRUE;
1024 }
1025 #endif
1026 } // namespace
1027
1028 // static
CloseAllSecondaryWidgets()1029 void Widget::CloseAllSecondaryWidgets() {
1030 #if defined(OS_WIN)
1031 EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
1032 #endif
1033
1034 #if defined(USE_X11) && !defined(OS_CHROMEOS)
1035 std::vector<aura::Window*> open_windows =
1036 DesktopWindowTreeHostX11::GetAllOpenWindows();
1037 std::for_each(open_windows.begin(), open_windows.end(), CloseWindow);
1038 DesktopWindowTreeHostX11::CleanUpWindowList();
1039 #endif
1040 }
1041
ConvertRect(const Widget * source,const Widget * target,gfx::Rect * rect)1042 bool Widget::ConvertRect(const Widget* source,
1043 const Widget* target,
1044 gfx::Rect* rect) {
1045 return false;
1046 }
1047
1048 namespace internal {
1049
1050 ////////////////////////////////////////////////////////////////////////////////
1051 // internal::NativeWidgetPrivate, public:
1052
1053 // static
CreateNativeWidget(internal::NativeWidgetDelegate * delegate)1054 NativeWidgetPrivate* NativeWidgetPrivate::CreateNativeWidget(
1055 internal::NativeWidgetDelegate* delegate) {
1056 return new NativeWidgetAura(delegate);
1057 }
1058
1059 // static
GetNativeWidgetForNativeView(gfx::NativeView native_view)1060 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeView(
1061 gfx::NativeView native_view) {
1062 // Cast must match type supplied to RegisterNativeWidgetForWindow().
1063 return reinterpret_cast<NativeWidgetPrivate*>(native_view->user_data());
1064 }
1065
1066 // static
GetNativeWidgetForNativeWindow(gfx::NativeWindow native_window)1067 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeWindow(
1068 gfx::NativeWindow native_window) {
1069 // Cast must match type supplied to RegisterNativeWidgetForWindow().
1070 return reinterpret_cast<NativeWidgetPrivate*>(native_window->user_data());
1071 }
1072
1073 // static
GetTopLevelNativeWidget(gfx::NativeView native_view)1074 NativeWidgetPrivate* NativeWidgetPrivate::GetTopLevelNativeWidget(
1075 gfx::NativeView native_view) {
1076 aura::Window* window = native_view;
1077 NativeWidgetPrivate* top_level_native_widget = NULL;
1078 while (window) {
1079 NativeWidgetPrivate* native_widget = GetNativeWidgetForNativeView(window);
1080 if (native_widget)
1081 top_level_native_widget = native_widget;
1082 window = window->parent();
1083 }
1084 return top_level_native_widget;
1085 }
1086
1087 // static
GetAllChildWidgets(gfx::NativeView native_view,Widget::Widgets * children)1088 void NativeWidgetPrivate::GetAllChildWidgets(gfx::NativeView native_view,
1089 Widget::Widgets* children) {
1090 {
1091 // Code expects widget for |native_view| to be added to |children|.
1092 NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
1093 GetNativeWidgetForNativeView(native_view));
1094 if (native_widget && native_widget->GetWidget())
1095 children->insert(native_widget->GetWidget());
1096 }
1097
1098 const aura::Window::Windows& child_windows = native_view->children();
1099 for (aura::Window::Windows::const_iterator i = child_windows.begin();
1100 i != child_windows.end(); ++i) {
1101 GetAllChildWidgets((*i), children);
1102 }
1103 }
1104
1105 // static
GetAllOwnedWidgets(gfx::NativeView native_view,Widget::Widgets * owned)1106 void NativeWidgetPrivate::GetAllOwnedWidgets(gfx::NativeView native_view,
1107 Widget::Widgets* owned) {
1108 const aura::Window::Windows& transient_children =
1109 wm::GetTransientChildren(native_view);
1110 for (aura::Window::Windows::const_iterator i = transient_children.begin();
1111 i != transient_children.end(); ++i) {
1112 NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
1113 GetNativeWidgetForNativeView(*i));
1114 if (native_widget && native_widget->GetWidget())
1115 owned->insert(native_widget->GetWidget());
1116 GetAllOwnedWidgets((*i), owned);
1117 }
1118 }
1119
1120 // static
ReparentNativeView(gfx::NativeView native_view,gfx::NativeView new_parent)1121 void NativeWidgetPrivate::ReparentNativeView(gfx::NativeView native_view,
1122 gfx::NativeView new_parent) {
1123 DCHECK(native_view != new_parent);
1124
1125 gfx::NativeView previous_parent = native_view->parent();
1126 if (previous_parent == new_parent)
1127 return;
1128
1129 Widget::Widgets widgets;
1130 GetAllChildWidgets(native_view, &widgets);
1131
1132 // First notify all the widgets that they are being disassociated
1133 // from their previous parent.
1134 for (Widget::Widgets::iterator it = widgets.begin();
1135 it != widgets.end(); ++it) {
1136 (*it)->NotifyNativeViewHierarchyWillChange();
1137 }
1138
1139 if (new_parent) {
1140 new_parent->AddChild(native_view);
1141 } else {
1142 // The following looks weird, but it's the equivalent of what aura has
1143 // always done. (The previous behaviour of aura::Window::SetParent() used
1144 // NULL as a special value that meant ask the WindowTreeClient where things
1145 // should go.)
1146 //
1147 // This probably isn't strictly correct, but its an invariant that a Window
1148 // in use will be attached to a RootWindow, so we can't just call
1149 // RemoveChild here. The only possible thing that could assign a RootWindow
1150 // in this case is the stacking client of the current RootWindow. This
1151 // matches our previous behaviour; the global stacking client would almost
1152 // always reattach the window to the same RootWindow.
1153 aura::Window* root_window = native_view->GetRootWindow();
1154 aura::client::ParentWindowWithContext(
1155 native_view, root_window, root_window->GetBoundsInScreen());
1156 }
1157
1158 // And now, notify them that they have a brand new parent.
1159 for (Widget::Widgets::iterator it = widgets.begin();
1160 it != widgets.end(); ++it) {
1161 (*it)->NotifyNativeViewHierarchyChanged();
1162 }
1163 }
1164
1165 // static
IsMouseButtonDown()1166 bool NativeWidgetPrivate::IsMouseButtonDown() {
1167 return aura::Env::GetInstance()->IsMouseButtonDown();
1168 }
1169
1170 // static
GetWindowTitleFontList()1171 gfx::FontList NativeWidgetPrivate::GetWindowTitleFontList() {
1172 #if defined(OS_WIN)
1173 NONCLIENTMETRICS ncm;
1174 base::win::GetNonClientMetrics(&ncm);
1175 l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
1176 base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
1177 return gfx::FontList(gfx::Font(caption_font));
1178 #else
1179 return gfx::FontList();
1180 #endif
1181 }
1182
1183 } // namespace internal
1184 } // namespace views
1185