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/widget.h"
6
7 #include <set>
8 #include <utility>
9
10 #include "base/auto_reset.h"
11 #include "base/check_op.h"
12 #include "base/containers/adapters.h"
13 #include "base/macros.h"
14 #include "base/notreached.h"
15 #include "base/strings/utf_string_conversions.h"
16 #include "base/trace_event/trace_event.h"
17 #include "ui/base/cursor/cursor.h"
18 #include "ui/base/default_style.h"
19 #include "ui/base/hit_test.h"
20 #include "ui/base/ime/input_method.h"
21 #include "ui/base/l10n/l10n_font_util.h"
22 #include "ui/base/resource/resource_bundle.h"
23 #include "ui/compositor/compositor.h"
24 #include "ui/compositor/layer.h"
25 #include "ui/display/screen.h"
26 #include "ui/events/event.h"
27 #include "ui/events/event_utils.h"
28 #include "ui/gfx/image/image_skia.h"
29 #include "ui/views/controls/menu/menu_controller.h"
30 #include "ui/views/event_monitor.h"
31 #include "ui/views/focus/focus_manager.h"
32 #include "ui/views/focus/focus_manager_factory.h"
33 #include "ui/views/focus/widget_focus_manager.h"
34 #include "ui/views/views_delegate.h"
35 #include "ui/views/widget/any_widget_observer_singleton.h"
36 #include "ui/views/widget/native_widget_private.h"
37 #include "ui/views/widget/root_view.h"
38 #include "ui/views/widget/tooltip_manager.h"
39 #include "ui/views/widget/widget_delegate.h"
40 #include "ui/views/widget/widget_deletion_observer.h"
41 #include "ui/views/widget/widget_observer.h"
42 #include "ui/views/widget/widget_removals_observer.h"
43 #include "ui/views/window/custom_frame_view.h"
44 #include "ui/views/window/dialog_delegate.h"
45
46 namespace views {
47
48 namespace {
49
50 // If |view| has a layer the layer is added to |layers|. Else this recurses
51 // through the children. This is used to build a list of the layers created by
52 // views that are direct children of the Widgets layer.
BuildViewsWithLayers(View * view,View::Views * views)53 void BuildViewsWithLayers(View* view, View::Views* views) {
54 if (view->layer()) {
55 views->push_back(view);
56 } else {
57 for (View* child : view->children())
58 BuildViewsWithLayers(child, views);
59 }
60 }
61
62 // Create a native widget implementation.
63 // First, use the supplied one if non-NULL.
64 // Finally, make a default one.
CreateNativeWidget(const Widget::InitParams & params,internal::NativeWidgetDelegate * delegate)65 NativeWidget* CreateNativeWidget(const Widget::InitParams& params,
66 internal::NativeWidgetDelegate* delegate) {
67 if (params.native_widget)
68 return params.native_widget;
69
70 const auto& factory = ViewsDelegate::GetInstance()->native_widget_factory();
71 if (!factory.is_null()) {
72 NativeWidget* native_widget = factory.Run(params, delegate);
73 if (native_widget)
74 return native_widget;
75 }
76 return internal::NativeWidgetPrivate::CreateNativeWidget(delegate);
77 }
78
NotifyCaretBoundsChanged(ui::InputMethod * input_method)79 void NotifyCaretBoundsChanged(ui::InputMethod* input_method) {
80 if (!input_method)
81 return;
82 ui::TextInputClient* client = input_method->GetTextInputClient();
83 if (client)
84 input_method->OnCaretBoundsChanged(client);
85 }
86
87 } // namespace
88
89 // static
90 bool Widget::g_disable_activation_change_handling_ = false;
91
92 // A default implementation of WidgetDelegate, used by Widget when no
93 // WidgetDelegate is supplied.
94 class DefaultWidgetDelegate : public WidgetDelegate {
95 public:
DefaultWidgetDelegate()96 DefaultWidgetDelegate() {
97 // In most situations where a Widget is used without a delegate the Widget
98 // is used as a container, so that we want focus to advance to the top-level
99 // widget. A good example of this is the find bar.
100 SetOwnedByWidget(true);
101 SetFocusTraversesOut(true);
102 }
103 ~DefaultWidgetDelegate() override = default;
104
105 private:
106 DISALLOW_COPY_AND_ASSIGN(DefaultWidgetDelegate);
107 };
108
109 ////////////////////////////////////////////////////////////////////////////////
110 // Widget, PaintAsActiveLock:
111
112 Widget::PaintAsActiveLock::PaintAsActiveLock() = default;
113 Widget::PaintAsActiveLock::~PaintAsActiveLock() = default;
114
115 ////////////////////////////////////////////////////////////////////////////////
116 // Widget, PaintAsActiveLockImpl:
117
118 class Widget::PaintAsActiveLockImpl : public Widget::PaintAsActiveLock {
119 public:
PaintAsActiveLockImpl(base::WeakPtr<Widget> && widget)120 explicit PaintAsActiveLockImpl(base::WeakPtr<Widget>&& widget)
121 : widget_(widget) {}
122
~PaintAsActiveLockImpl()123 ~PaintAsActiveLockImpl() override {
124 Widget* const widget = widget_.get();
125 if (widget)
126 widget->UnlockPaintAsActive();
127 }
128
129 private:
130 base::WeakPtr<Widget> widget_;
131 };
132
133 ////////////////////////////////////////////////////////////////////////////////
134 // Widget, InitParams:
135
136 Widget::InitParams::InitParams() = default;
137
InitParams(Type type)138 Widget::InitParams::InitParams(Type type) : type(type) {}
139
140 Widget::InitParams::InitParams(InitParams&& other) = default;
141
142 Widget::InitParams::~InitParams() = default;
143
CanActivate() const144 bool Widget::InitParams::CanActivate() const {
145 if (activatable != InitParams::ACTIVATABLE_DEFAULT)
146 return activatable == InitParams::ACTIVATABLE_YES;
147 return type != InitParams::TYPE_CONTROL && type != InitParams::TYPE_POPUP &&
148 type != InitParams::TYPE_MENU && type != InitParams::TYPE_TOOLTIP &&
149 type != InitParams::TYPE_DRAG;
150 }
151
EffectiveZOrderLevel() const152 ui::ZOrderLevel Widget::InitParams::EffectiveZOrderLevel() const {
153 if (z_order.has_value())
154 return z_order.value();
155
156 switch (type) {
157 case TYPE_MENU:
158 return ui::ZOrderLevel::kFloatingWindow;
159 case TYPE_DRAG:
160 return ui::ZOrderLevel::kFloatingUIElement;
161 default:
162 return ui::ZOrderLevel::kNormal;
163 }
164 }
165
166 ////////////////////////////////////////////////////////////////////////////////
167 // Widget, public:
168
169 Widget::Widget() = default;
170
Widget(InitParams params)171 Widget::Widget(InitParams params) {
172 Init(std::move(params));
173 }
174
~Widget()175 Widget::~Widget() {
176 if (widget_delegate_)
177 widget_delegate_->WidgetDestroying();
178 DestroyRootView();
179 if (ownership_ == InitParams::WIDGET_OWNS_NATIVE_WIDGET) {
180 delete native_widget_;
181 } else {
182 // TODO(crbug.com/937381): Revert to DCHECK once we figure out the reason.
183 CHECK(native_widget_destroyed_)
184 << "Destroying a widget with a live native widget. "
185 << "Widget probably should use WIDGET_OWNS_NATIVE_WIDGET ownership.";
186 }
187 }
188
189 // static
CreateWindowWithParent(WidgetDelegate * delegate,gfx::NativeView parent,const gfx::Rect & bounds)190 Widget* Widget::CreateWindowWithParent(WidgetDelegate* delegate,
191 gfx::NativeView parent,
192 const gfx::Rect& bounds) {
193 Widget::InitParams params;
194 params.delegate = delegate;
195 params.parent = parent;
196 params.bounds = bounds;
197 return new Widget(std::move(params));
198 }
199
CreateWindowWithParent(std::unique_ptr<WidgetDelegate> delegate,gfx::NativeView parent,const gfx::Rect & bounds)200 Widget* Widget::CreateWindowWithParent(std::unique_ptr<WidgetDelegate> delegate,
201 gfx::NativeView parent,
202 const gfx::Rect& bounds) {
203 DCHECK(delegate->owned_by_widget());
204 return CreateWindowWithParent(delegate.release(), parent, bounds);
205 }
206
207 // static
CreateWindowWithContext(WidgetDelegate * delegate,gfx::NativeWindow context,const gfx::Rect & bounds)208 Widget* Widget::CreateWindowWithContext(WidgetDelegate* delegate,
209 gfx::NativeWindow context,
210 const gfx::Rect& bounds) {
211 Widget::InitParams params;
212 params.delegate = delegate;
213 params.context = context;
214 params.bounds = bounds;
215 return new Widget(std::move(params));
216 }
217
218 // static
CreateWindowWithContext(std::unique_ptr<WidgetDelegate> delegate,gfx::NativeWindow context,const gfx::Rect & bounds)219 Widget* Widget::CreateWindowWithContext(
220 std::unique_ptr<WidgetDelegate> delegate,
221 gfx::NativeWindow context,
222 const gfx::Rect& bounds) {
223 DCHECK(delegate->owned_by_widget());
224 return CreateWindowWithContext(delegate.release(), context, bounds);
225 }
226
227 // static
GetWidgetForNativeView(gfx::NativeView native_view)228 Widget* Widget::GetWidgetForNativeView(gfx::NativeView native_view) {
229 internal::NativeWidgetPrivate* native_widget =
230 internal::NativeWidgetPrivate::GetNativeWidgetForNativeView(native_view);
231 return native_widget ? native_widget->GetWidget() : nullptr;
232 }
233
234 // static
GetWidgetForNativeWindow(gfx::NativeWindow native_window)235 Widget* Widget::GetWidgetForNativeWindow(gfx::NativeWindow native_window) {
236 internal::NativeWidgetPrivate* native_widget =
237 internal::NativeWidgetPrivate::GetNativeWidgetForNativeWindow(
238 native_window);
239 return native_widget ? native_widget->GetWidget() : nullptr;
240 }
241
242 // static
GetTopLevelWidgetForNativeView(gfx::NativeView native_view)243 Widget* Widget::GetTopLevelWidgetForNativeView(gfx::NativeView native_view) {
244 internal::NativeWidgetPrivate* native_widget =
245 internal::NativeWidgetPrivate::GetTopLevelNativeWidget(native_view);
246 return native_widget ? native_widget->GetWidget() : nullptr;
247 }
248
249 // static
GetAllChildWidgets(gfx::NativeView native_view,Widgets * children)250 void Widget::GetAllChildWidgets(gfx::NativeView native_view,
251 Widgets* children) {
252 internal::NativeWidgetPrivate::GetAllChildWidgets(native_view, children);
253 }
254
255 // static
GetAllOwnedWidgets(gfx::NativeView native_view,Widgets * owned)256 void Widget::GetAllOwnedWidgets(gfx::NativeView native_view, Widgets* owned) {
257 internal::NativeWidgetPrivate::GetAllOwnedWidgets(native_view, owned);
258 }
259
260 // static
ReparentNativeView(gfx::NativeView native_view,gfx::NativeView new_parent)261 void Widget::ReparentNativeView(gfx::NativeView native_view,
262 gfx::NativeView new_parent) {
263 internal::NativeWidgetPrivate::ReparentNativeView(native_view, new_parent);
264
265 Widget* child_widget = GetWidgetForNativeView(native_view);
266 Widget* parent_widget =
267 new_parent ? GetWidgetForNativeView(new_parent) : nullptr;
268 if (child_widget)
269 child_widget->parent_ = parent_widget;
270 }
271
272 // static
GetLocalizedContentsWidth(int col_resource_id)273 int Widget::GetLocalizedContentsWidth(int col_resource_id) {
274 return ui::GetLocalizedContentsWidthForFont(
275 col_resource_id, ui::ResourceBundle::GetSharedInstance().GetFontWithDelta(
276 ui::kMessageFontSizeDelta));
277 }
278
279 // static
GetLocalizedContentsHeight(int row_resource_id)280 int Widget::GetLocalizedContentsHeight(int row_resource_id) {
281 return ui::GetLocalizedContentsHeightForFont(
282 row_resource_id, ui::ResourceBundle::GetSharedInstance().GetFontWithDelta(
283 ui::kMessageFontSizeDelta));
284 }
285
286 // static
GetLocalizedContentsSize(int col_resource_id,int row_resource_id)287 gfx::Size Widget::GetLocalizedContentsSize(int col_resource_id,
288 int row_resource_id) {
289 return gfx::Size(GetLocalizedContentsWidth(col_resource_id),
290 GetLocalizedContentsHeight(row_resource_id));
291 }
292
293 // static
RequiresNonClientView(InitParams::Type type)294 bool Widget::RequiresNonClientView(InitParams::Type type) {
295 return type == InitParams::TYPE_WINDOW || type == InitParams::TYPE_BUBBLE;
296 }
297
Init(InitParams params)298 void Widget::Init(InitParams params) {
299 TRACE_EVENT0("views", "Widget::Init");
300
301 if (params.name.empty() && params.delegate) {
302 params.name = params.delegate->internal_name();
303 // If an internal name was not provided the class name of the contents view
304 // is a reasonable default.
305 if (params.name.empty() && params.delegate->GetContentsView())
306 params.name = params.delegate->GetContentsView()->GetClassName();
307 }
308
309 parent_ = params.parent ? GetWidgetForNativeView(params.parent) : nullptr;
310
311 params.child |= (params.type == InitParams::TYPE_CONTROL);
312 is_top_level_ = !params.child;
313
314 if (params.opacity == views::Widget::InitParams::WindowOpacity::kInferred &&
315 params.type != views::Widget::InitParams::TYPE_WINDOW) {
316 params.opacity = views::Widget::InitParams::WindowOpacity::kOpaque;
317 }
318
319 {
320 // ViewsDelegate::OnBeforeWidgetInit() may change `params.delegate` either
321 // by setting it to null or assigning a different value to it, so handle
322 // both cases.
323 auto default_widget_delegate = std::make_unique<DefaultWidgetDelegate>();
324 widget_delegate_ =
325 params.delegate ? params.delegate : default_widget_delegate.get();
326
327 ViewsDelegate::GetInstance()->OnBeforeWidgetInit(¶ms, this);
328
329 widget_delegate_ =
330 params.delegate ? params.delegate : default_widget_delegate.release();
331 }
332 DCHECK(widget_delegate_);
333
334 if (params.opacity == views::Widget::InitParams::WindowOpacity::kInferred)
335 params.opacity = views::Widget::InitParams::WindowOpacity::kOpaque;
336
337 bool can_activate = params.CanActivate();
338 params.activatable =
339 can_activate ? InitParams::ACTIVATABLE_YES : InitParams::ACTIVATABLE_NO;
340
341 widget_delegate_->SetCanActivate(can_activate);
342
343 // Henceforth, ensure the delegate outlives the Widget.
344 widget_delegate_->can_delete_this_ = false;
345
346 if (params.delegate)
347 params.delegate->WidgetInitializing(this);
348
349 ownership_ = params.ownership;
350 native_widget_ = CreateNativeWidget(params, this)->AsNativeWidgetPrivate();
351 root_view_.reset(CreateRootView());
352
353 // Copy the elements of params that will be used after it is moved.
354 const InitParams::Type type = params.type;
355 const gfx::Rect bounds = params.bounds;
356 const ui::WindowShowState show_state = params.show_state;
357 WidgetDelegate* delegate = params.delegate;
358
359 native_widget_->InitNativeWidget(std::move(params));
360 if (type == InitParams::TYPE_MENU)
361 is_mouse_button_pressed_ = native_widget_->IsMouseButtonDown();
362 if (RequiresNonClientView(type)) {
363 non_client_view_ =
364 new NonClientView(widget_delegate_->CreateClientView(this));
365 non_client_view_->SetFrameView(CreateNonClientFrameView());
366 non_client_view_->SetOverlayView(widget_delegate_->CreateOverlayView());
367
368 // Bypass the Layout() that happens in Widget::SetContentsView(). Layout()
369 // will occur after setting the initial bounds below. The RootView's size is
370 // not valid until that happens.
371 root_view_->SetContentsView(non_client_view_);
372
373 // Initialize the window's icon and title before setting the window's
374 // initial bounds; the frame view's preferred height may depend on the
375 // presence of an icon or a title.
376 UpdateWindowIcon();
377 UpdateWindowTitle();
378 non_client_view_->ResetWindowControls();
379 SetInitialBounds(bounds);
380
381 // Perform the initial layout. This handles the case where the size might
382 // not actually change when setting the initial bounds. If it did, child
383 // views won't have a dirty Layout state, so won't do any work.
384 root_view_->Layout();
385
386 if (show_state == ui::SHOW_STATE_MAXIMIZED) {
387 Maximize();
388 } else if (show_state == ui::SHOW_STATE_MINIMIZED) {
389 Minimize();
390 saved_show_state_ = ui::SHOW_STATE_MINIMIZED;
391 }
392 } else if (delegate) {
393 SetContentsView(delegate->TransferOwnershipOfContentsView());
394 SetInitialBoundsForFramelessWindow(bounds);
395 }
396
397 observer_manager_.Add(GetNativeTheme());
398 native_widget_initialized_ = true;
399 native_widget_->OnWidgetInitDone();
400
401 if (delegate)
402 delegate->WidgetInitialized();
403
404 internal::AnyWidgetObserverSingleton::GetInstance()->OnAnyWidgetInitialized(
405 this);
406 }
407
ShowEmojiPanel()408 void Widget::ShowEmojiPanel() {
409 native_widget_->ShowEmojiPanel();
410 }
411
412 // Unconverted methods (see header) --------------------------------------------
413
GetNativeView() const414 gfx::NativeView Widget::GetNativeView() const {
415 return native_widget_->GetNativeView();
416 }
417
GetNativeWindow() const418 gfx::NativeWindow Widget::GetNativeWindow() const {
419 return native_widget_->GetNativeWindow();
420 }
421
AddObserver(WidgetObserver * observer)422 void Widget::AddObserver(WidgetObserver* observer) {
423 // Make sure that there is no nullptr in observer list. crbug.com/471649.
424 CHECK(observer);
425 observers_.AddObserver(observer);
426 }
427
RemoveObserver(WidgetObserver * observer)428 void Widget::RemoveObserver(WidgetObserver* observer) {
429 observers_.RemoveObserver(observer);
430 }
431
HasObserver(const WidgetObserver * observer) const432 bool Widget::HasObserver(const WidgetObserver* observer) const {
433 return observers_.HasObserver(observer);
434 }
435
AddRemovalsObserver(WidgetRemovalsObserver * observer)436 void Widget::AddRemovalsObserver(WidgetRemovalsObserver* observer) {
437 removals_observers_.AddObserver(observer);
438 }
439
RemoveRemovalsObserver(WidgetRemovalsObserver * observer)440 void Widget::RemoveRemovalsObserver(WidgetRemovalsObserver* observer) {
441 removals_observers_.RemoveObserver(observer);
442 }
443
HasRemovalsObserver(const WidgetRemovalsObserver * observer) const444 bool Widget::HasRemovalsObserver(const WidgetRemovalsObserver* observer) const {
445 return removals_observers_.HasObserver(observer);
446 }
447
GetAccelerator(int cmd_id,ui::Accelerator * accelerator) const448 bool Widget::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) const {
449 return false;
450 }
451
ViewHierarchyChanged(const ViewHierarchyChangedDetails & details)452 void Widget::ViewHierarchyChanged(const ViewHierarchyChangedDetails& details) {
453 if (!details.is_add) {
454 if (details.child == dragged_view_)
455 dragged_view_ = nullptr;
456 FocusManager* focus_manager = GetFocusManager();
457 if (focus_manager)
458 focus_manager->ViewRemoved(details.child);
459 native_widget_->ViewRemoved(details.child);
460 }
461 }
462
NotifyNativeViewHierarchyWillChange()463 void Widget::NotifyNativeViewHierarchyWillChange() {
464 // During tear-down the top-level focus manager becomes unavailable to
465 // GTK tabbed panes and their children, so normal deregistration via
466 // |FocusManager::ViewRemoved()| calls are fouled. We clear focus here
467 // to avoid these redundant steps and to avoid accessing deleted views
468 // that may have been in focus.
469 ClearFocusFromWidget();
470 native_widget_->OnNativeViewHierarchyChanged();
471 }
472
NotifyNativeViewHierarchyChanged()473 void Widget::NotifyNativeViewHierarchyChanged() {
474 native_widget_->OnNativeViewHierarchyWillChange();
475 root_view_->NotifyNativeViewHierarchyChanged();
476 }
477
NotifyWillRemoveView(View * view)478 void Widget::NotifyWillRemoveView(View* view) {
479 for (WidgetRemovalsObserver& observer : removals_observers_)
480 observer.OnWillRemoveView(this, view);
481 }
482
483 // Converted methods (see header) ----------------------------------------------
484
GetTopLevelWidget()485 Widget* Widget::GetTopLevelWidget() {
486 return const_cast<Widget*>(
487 static_cast<const Widget*>(this)->GetTopLevelWidget());
488 }
489
GetTopLevelWidget() const490 const Widget* Widget::GetTopLevelWidget() const {
491 // GetTopLevelNativeWidget doesn't work during destruction because
492 // property is gone after gobject gets deleted. Short circuit here
493 // for toplevel so that InputMethod can remove itself from
494 // focus manager.
495 return is_top_level() ? this : native_widget_->GetTopLevelWidget();
496 }
497
SetContentsView(View * view)498 void Widget::SetContentsView(View* view) {
499 // Do not SetContentsView() again if it is already set to the same view.
500 if (view == GetContentsView())
501 return;
502
503 // |non_client_view_| can only be non-null here if RequiresNonClientView() was
504 // true when the widget was initialized. Creating widgets with non-client
505 // views and then setting the contents view can cause subtle problems on
506 // Windows, where the native widget thinks there is still a
507 // |non_client_view_|. If you get this error, either use a different type when
508 // initializing the widget, or don't call SetContentsView().
509 DCHECK(!non_client_view_);
510
511 root_view_->SetContentsView(view);
512
513 // Force a layout now, since the attached hierarchy won't be ready for the
514 // containing window's bounds. Note that we call Layout directly rather than
515 // calling the widget's size changed handler, since the RootView's bounds may
516 // not have changed, which will cause the Layout not to be done otherwise.
517 root_view_->Layout();
518 }
519
GetContentsView()520 View* Widget::GetContentsView() {
521 return root_view_->GetContentsView();
522 }
523
GetWindowBoundsInScreen() const524 gfx::Rect Widget::GetWindowBoundsInScreen() const {
525 return native_widget_->GetWindowBoundsInScreen();
526 }
527
GetClientAreaBoundsInScreen() const528 gfx::Rect Widget::GetClientAreaBoundsInScreen() const {
529 return native_widget_->GetClientAreaBoundsInScreen();
530 }
531
GetRestoredBounds() const532 gfx::Rect Widget::GetRestoredBounds() const {
533 return native_widget_->GetRestoredBounds();
534 }
535
GetWorkspace() const536 std::string Widget::GetWorkspace() const {
537 return native_widget_->GetWorkspace();
538 }
539
SetBounds(const gfx::Rect & bounds)540 void Widget::SetBounds(const gfx::Rect& bounds) {
541 native_widget_->SetBounds(bounds);
542 }
543
SetSize(const gfx::Size & size)544 void Widget::SetSize(const gfx::Size& size) {
545 native_widget_->SetSize(size);
546 }
547
CenterWindow(const gfx::Size & size)548 void Widget::CenterWindow(const gfx::Size& size) {
549 native_widget_->CenterWindow(size);
550 }
551
SetBoundsConstrained(const gfx::Rect & bounds)552 void Widget::SetBoundsConstrained(const gfx::Rect& bounds) {
553 native_widget_->SetBoundsConstrained(bounds);
554 }
555
SetVisibilityChangedAnimationsEnabled(bool value)556 void Widget::SetVisibilityChangedAnimationsEnabled(bool value) {
557 native_widget_->SetVisibilityChangedAnimationsEnabled(value);
558 }
559
SetVisibilityAnimationDuration(const base::TimeDelta & duration)560 void Widget::SetVisibilityAnimationDuration(const base::TimeDelta& duration) {
561 native_widget_->SetVisibilityAnimationDuration(duration);
562 }
563
SetVisibilityAnimationTransition(VisibilityTransition transition)564 void Widget::SetVisibilityAnimationTransition(VisibilityTransition transition) {
565 native_widget_->SetVisibilityAnimationTransition(transition);
566 }
567
RunMoveLoop(const gfx::Vector2d & drag_offset,MoveLoopSource source,MoveLoopEscapeBehavior escape_behavior)568 Widget::MoveLoopResult Widget::RunMoveLoop(
569 const gfx::Vector2d& drag_offset,
570 MoveLoopSource source,
571 MoveLoopEscapeBehavior escape_behavior) {
572 return native_widget_->RunMoveLoop(drag_offset, source, escape_behavior);
573 }
574
EndMoveLoop()575 void Widget::EndMoveLoop() {
576 native_widget_->EndMoveLoop();
577 }
578
StackAboveWidget(Widget * widget)579 void Widget::StackAboveWidget(Widget* widget) {
580 native_widget_->StackAbove(widget->GetNativeView());
581 }
582
StackAbove(gfx::NativeView native_view)583 void Widget::StackAbove(gfx::NativeView native_view) {
584 native_widget_->StackAbove(native_view);
585 }
586
StackAtTop()587 void Widget::StackAtTop() {
588 native_widget_->StackAtTop();
589 }
590
SetShape(std::unique_ptr<ShapeRects> shape)591 void Widget::SetShape(std::unique_ptr<ShapeRects> shape) {
592 native_widget_->SetShape(std::move(shape));
593 }
594
CloseWithReason(ClosedReason closed_reason)595 void Widget::CloseWithReason(ClosedReason closed_reason) {
596 if (widget_closed_) {
597 // It appears we can hit this code path if you close a modal dialog then
598 // close the last browser before the destructor is hit, which triggers
599 // invoking Close again.
600 return;
601 }
602 if (block_close_) {
603 return;
604 }
605 if (non_client_view_ && non_client_view_->OnWindowCloseRequested() ==
606 CloseRequestResult::kCannotClose)
607 return;
608
609 // This is the last chance to cancel closing.
610 if (widget_delegate_ && !widget_delegate_->OnCloseRequested(closed_reason))
611 return;
612
613 // The actions below can cause this function to be called again, so mark
614 // |this| as closed early. See crbug.com/714334
615 widget_closed_ = true;
616 closed_reason_ = closed_reason;
617 SaveWindowPlacement();
618 ClearFocusFromWidget();
619
620 for (WidgetObserver& observer : observers_)
621 observer.OnWidgetClosing(this);
622
623 internal::AnyWidgetObserverSingleton::GetInstance()->OnAnyWidgetClosing(this);
624
625 if (widget_delegate_)
626 widget_delegate_->WindowWillClose();
627
628 native_widget_->Close();
629 }
630
Close()631 void Widget::Close() {
632 CloseWithReason(ClosedReason::kUnspecified);
633 }
634
CloseNow()635 void Widget::CloseNow() {
636 for (WidgetObserver& observer : observers_)
637 observer.OnWidgetClosing(this);
638 internal::AnyWidgetObserverSingleton::GetInstance()->OnAnyWidgetClosing(this);
639 native_widget_->CloseNow();
640 }
641
IsClosed() const642 bool Widget::IsClosed() const {
643 return widget_closed_;
644 }
645
Show()646 void Widget::Show() {
647 const ui::Layer* layer = GetLayer();
648 TRACE_EVENT1("views", "Widget::Show", "layer",
649 layer ? layer->name() : "none");
650 ui::WindowShowState preferred_show_state =
651 CanActivate() ? ui::SHOW_STATE_NORMAL : ui::SHOW_STATE_INACTIVE;
652 if (non_client_view_) {
653 // While initializing, the kiosk mode will go to full screen before the
654 // widget gets shown. In that case we stay in full screen mode, regardless
655 // of the |saved_show_state_| member.
656 if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED &&
657 !initial_restored_bounds_.IsEmpty() && !IsFullscreen()) {
658 native_widget_->Show(ui::SHOW_STATE_MAXIMIZED, initial_restored_bounds_);
659 } else {
660 native_widget_->Show(
661 IsFullscreen() ? ui::SHOW_STATE_FULLSCREEN : saved_show_state_,
662 gfx::Rect());
663 }
664 // |saved_show_state_| only applies the first time the window is shown.
665 // If we don't reset the value the window may be shown maximized every time
666 // it is subsequently shown after being hidden.
667 saved_show_state_ = preferred_show_state;
668 } else {
669 native_widget_->Show(preferred_show_state, gfx::Rect());
670 }
671 internal::AnyWidgetObserverSingleton::GetInstance()->OnAnyWidgetShown(this);
672 }
673
Hide()674 void Widget::Hide() {
675 native_widget_->Hide();
676 internal::AnyWidgetObserverSingleton::GetInstance()->OnAnyWidgetHidden(this);
677 }
678
ShowInactive()679 void Widget::ShowInactive() {
680 // If this gets called with saved_show_state_ == ui::SHOW_STATE_MAXIMIZED,
681 // call SetBounds()with the restored bounds to set the correct size. This
682 // normally should not happen, but if it does we should avoid showing unsized
683 // windows.
684 if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED &&
685 !initial_restored_bounds_.IsEmpty()) {
686 SetBounds(initial_restored_bounds_);
687 saved_show_state_ = ui::SHOW_STATE_NORMAL;
688 }
689 native_widget_->Show(ui::SHOW_STATE_INACTIVE, gfx::Rect());
690 }
691
Activate()692 void Widget::Activate() {
693 if (CanActivate())
694 native_widget_->Activate();
695 }
696
Deactivate()697 void Widget::Deactivate() {
698 native_widget_->Deactivate();
699 }
700
IsActive() const701 bool Widget::IsActive() const {
702 return native_widget_->IsActive();
703 }
704
SetZOrderLevel(ui::ZOrderLevel order)705 void Widget::SetZOrderLevel(ui::ZOrderLevel order) {
706 native_widget_->SetZOrderLevel(order);
707 }
708
GetZOrderLevel() const709 ui::ZOrderLevel Widget::GetZOrderLevel() const {
710 return native_widget_->GetZOrderLevel();
711 }
712
SetVisibleOnAllWorkspaces(bool always_visible)713 void Widget::SetVisibleOnAllWorkspaces(bool always_visible) {
714 native_widget_->SetVisibleOnAllWorkspaces(always_visible);
715 }
716
IsVisibleOnAllWorkspaces() const717 bool Widget::IsVisibleOnAllWorkspaces() const {
718 return native_widget_->IsVisibleOnAllWorkspaces();
719 }
720
Maximize()721 void Widget::Maximize() {
722 native_widget_->Maximize();
723 }
724
Minimize()725 void Widget::Minimize() {
726 native_widget_->Minimize();
727 }
728
Restore()729 void Widget::Restore() {
730 native_widget_->Restore();
731 }
732
IsMaximized() const733 bool Widget::IsMaximized() const {
734 return native_widget_->IsMaximized();
735 }
736
IsMinimized() const737 bool Widget::IsMinimized() const {
738 return native_widget_->IsMinimized();
739 }
740
SetFullscreen(bool fullscreen)741 void Widget::SetFullscreen(bool fullscreen) {
742 if (IsFullscreen() == fullscreen)
743 return;
744
745 native_widget_->SetFullscreen(fullscreen);
746
747 if (non_client_view_)
748 non_client_view_->InvalidateLayout();
749 }
750
IsFullscreen() const751 bool Widget::IsFullscreen() const {
752 return native_widget_->IsFullscreen();
753 }
754
SetCanAppearInExistingFullscreenSpaces(bool can_appear_in_existing_fullscreen_spaces)755 void Widget::SetCanAppearInExistingFullscreenSpaces(
756 bool can_appear_in_existing_fullscreen_spaces) {
757 native_widget_->SetCanAppearInExistingFullscreenSpaces(
758 can_appear_in_existing_fullscreen_spaces);
759 }
760
SetOpacity(float opacity)761 void Widget::SetOpacity(float opacity) {
762 DCHECK(opacity >= 0.0f);
763 DCHECK(opacity <= 1.0f);
764 native_widget_->SetOpacity(opacity);
765 }
766
SetAspectRatio(const gfx::SizeF & aspect_ratio)767 void Widget::SetAspectRatio(const gfx::SizeF& aspect_ratio) {
768 native_widget_->SetAspectRatio(aspect_ratio);
769 }
770
FlashFrame(bool flash)771 void Widget::FlashFrame(bool flash) {
772 native_widget_->FlashFrame(flash);
773 }
774
GetRootView()775 View* Widget::GetRootView() {
776 return root_view_.get();
777 }
778
GetRootView() const779 const View* Widget::GetRootView() const {
780 return root_view_.get();
781 }
782
IsVisible() const783 bool Widget::IsVisible() const {
784 return native_widget_->IsVisible();
785 }
786
GetThemeProvider() const787 const ui::ThemeProvider* Widget::GetThemeProvider() const {
788 const Widget* root_widget = GetTopLevelWidget();
789 return (root_widget && root_widget != this) ? root_widget->GetThemeProvider()
790 : nullptr;
791 }
792
GetFocusManager()793 FocusManager* Widget::GetFocusManager() {
794 Widget* toplevel_widget = GetTopLevelWidget();
795 return toplevel_widget ? toplevel_widget->focus_manager_.get() : nullptr;
796 }
797
GetFocusManager() const798 const FocusManager* Widget::GetFocusManager() const {
799 const Widget* toplevel_widget = GetTopLevelWidget();
800 return toplevel_widget ? toplevel_widget->focus_manager_.get() : nullptr;
801 }
802
GetInputMethod()803 ui::InputMethod* Widget::GetInputMethod() {
804 if (is_top_level()) {
805 // Only creates the shared the input method instance on top level widget.
806 return native_widget_private()->GetInputMethod();
807 } else {
808 Widget* toplevel = GetTopLevelWidget();
809 // If GetTopLevelWidget() returns itself which is not toplevel,
810 // the widget is detached from toplevel widget.
811 // TODO(oshima): Fix GetTopLevelWidget() to return NULL
812 // if there is no toplevel. We probably need to add GetTopMostWidget()
813 // to replace some use cases.
814 return (toplevel && toplevel != this) ? toplevel->GetInputMethod()
815 : nullptr;
816 }
817 }
818
RunShellDrag(View * view,std::unique_ptr<ui::OSExchangeData> data,const gfx::Point & location,int operation,ui::mojom::DragEventSource source)819 void Widget::RunShellDrag(View* view,
820 std::unique_ptr<ui::OSExchangeData> data,
821 const gfx::Point& location,
822 int operation,
823 ui::mojom::DragEventSource source) {
824 dragged_view_ = view;
825 OnDragWillStart();
826
827 for (WidgetObserver& observer : observers_)
828 observer.OnWidgetDragWillStart(this);
829
830 WidgetDeletionObserver widget_deletion_observer(this);
831 native_widget_->RunShellDrag(view, std::move(data), location, operation,
832 source);
833
834 // The widget may be destroyed during the drag operation.
835 if (!widget_deletion_observer.IsWidgetAlive())
836 return;
837
838 // If the view is removed during the drag operation, dragged_view_ is set to
839 // NULL.
840 if (view && dragged_view_ == view) {
841 dragged_view_ = nullptr;
842 view->OnDragDone();
843 }
844 OnDragComplete();
845
846 for (WidgetObserver& observer : observers_)
847 observer.OnWidgetDragComplete(this);
848 }
849
SchedulePaintInRect(const gfx::Rect & rect)850 void Widget::SchedulePaintInRect(const gfx::Rect& rect) {
851 native_widget_->SchedulePaintInRect(rect);
852 }
853
ScheduleLayout()854 void Widget::ScheduleLayout() {
855 native_widget_->ScheduleLayout();
856 }
857
SetCursor(gfx::NativeCursor cursor)858 void Widget::SetCursor(gfx::NativeCursor cursor) {
859 native_widget_->SetCursor(cursor);
860 }
861
IsMouseEventsEnabled() const862 bool Widget::IsMouseEventsEnabled() const {
863 return native_widget_->IsMouseEventsEnabled();
864 }
865
SetNativeWindowProperty(const char * name,void * value)866 void Widget::SetNativeWindowProperty(const char* name, void* value) {
867 native_widget_->SetNativeWindowProperty(name, value);
868 }
869
GetNativeWindowProperty(const char * name) const870 void* Widget::GetNativeWindowProperty(const char* name) const {
871 return native_widget_->GetNativeWindowProperty(name);
872 }
873
UpdateWindowTitle()874 void Widget::UpdateWindowTitle() {
875 if (!non_client_view_)
876 return;
877
878 // Update the native frame's text. We do this regardless of whether or not
879 // the native frame is being used, since this also updates the taskbar, etc.
880 base::string16 window_title = widget_delegate_->GetWindowTitle();
881 base::i18n::AdjustStringForLocaleDirection(&window_title);
882 if (!native_widget_->SetWindowTitle(window_title))
883 return;
884
885 non_client_view_->UpdateWindowTitle();
886 }
887
UpdateWindowIcon()888 void Widget::UpdateWindowIcon() {
889 if (non_client_view_)
890 non_client_view_->UpdateWindowIcon();
891 native_widget_->SetWindowIcons(widget_delegate_->GetWindowIcon(),
892 widget_delegate_->GetWindowAppIcon());
893 }
894
GetFocusTraversable()895 FocusTraversable* Widget::GetFocusTraversable() {
896 return static_cast<internal::RootView*>(root_view_.get());
897 }
898
ThemeChanged()899 void Widget::ThemeChanged() {
900 root_view_->ThemeChanged();
901 }
902
DeviceScaleFactorChanged(float old_device_scale_factor,float new_device_scale_factor)903 void Widget::DeviceScaleFactorChanged(float old_device_scale_factor,
904 float new_device_scale_factor) {
905 root_view_->DeviceScaleFactorChanged(old_device_scale_factor,
906 new_device_scale_factor);
907 }
908
SetFocusTraversableParent(FocusTraversable * parent)909 void Widget::SetFocusTraversableParent(FocusTraversable* parent) {
910 root_view_->SetFocusTraversableParent(parent);
911 }
912
SetFocusTraversableParentView(View * parent_view)913 void Widget::SetFocusTraversableParentView(View* parent_view) {
914 root_view_->SetFocusTraversableParentView(parent_view);
915 }
916
ClearNativeFocus()917 void Widget::ClearNativeFocus() {
918 native_widget_->ClearNativeFocus();
919 }
920
CreateNonClientFrameView()921 std::unique_ptr<NonClientFrameView> Widget::CreateNonClientFrameView() {
922 auto frame_view = widget_delegate_->CreateNonClientFrameView(this);
923 if (!frame_view)
924 frame_view = native_widget_->CreateNonClientFrameView();
925 if (!frame_view) {
926 frame_view =
927 ViewsDelegate::GetInstance()->CreateDefaultNonClientFrameView(this);
928 }
929 if (frame_view)
930 return frame_view;
931
932 return std::make_unique<CustomFrameView>(this);
933 }
934
ShouldUseNativeFrame() const935 bool Widget::ShouldUseNativeFrame() const {
936 if (frame_type_ != FrameType::kDefault)
937 return frame_type_ == FrameType::kForceNative;
938 return native_widget_->ShouldUseNativeFrame();
939 }
940
ShouldWindowContentsBeTransparent() const941 bool Widget::ShouldWindowContentsBeTransparent() const {
942 return native_widget_->ShouldWindowContentsBeTransparent();
943 }
944
DebugToggleFrameType()945 void Widget::DebugToggleFrameType() {
946 if (frame_type_ == FrameType::kDefault) {
947 frame_type_ = ShouldUseNativeFrame() ? FrameType::kForceCustom
948 : FrameType::kForceNative;
949 } else {
950 frame_type_ = frame_type_ == FrameType::kForceCustom
951 ? FrameType::kForceNative
952 : FrameType::kForceCustom;
953 }
954 FrameTypeChanged();
955 }
956
FrameTypeChanged()957 void Widget::FrameTypeChanged() {
958 native_widget_->FrameTypeChanged();
959 }
960
GetCompositor() const961 const ui::Compositor* Widget::GetCompositor() const {
962 return native_widget_->GetCompositor();
963 }
964
GetLayer() const965 const ui::Layer* Widget::GetLayer() const {
966 return native_widget_->GetLayer();
967 }
968
ReorderNativeViews()969 void Widget::ReorderNativeViews() {
970 native_widget_->ReorderNativeViews();
971 }
972
LayerTreeChanged()973 void Widget::LayerTreeChanged() {
974 // Calculate the layers requires traversing the tree, and since nearly any
975 // mutation of the tree can trigger this call we delay until absolutely
976 // necessary.
977 views_with_layers_dirty_ = true;
978 }
979
native_widget() const980 const NativeWidget* Widget::native_widget() const {
981 return native_widget_;
982 }
983
native_widget()984 NativeWidget* Widget::native_widget() {
985 return native_widget_;
986 }
987
SetCapture(View * view)988 void Widget::SetCapture(View* view) {
989 if (!native_widget_->HasCapture()) {
990 native_widget_->SetCapture();
991
992 // Early return if setting capture was unsuccessful.
993 if (!native_widget_->HasCapture())
994 return;
995 }
996
997 if (native_widget_->IsMouseButtonDown())
998 is_mouse_button_pressed_ = true;
999 root_view_->SetMouseHandler(view);
1000 }
1001
ReleaseCapture()1002 void Widget::ReleaseCapture() {
1003 if (native_widget_->HasCapture())
1004 native_widget_->ReleaseCapture();
1005 }
1006
HasCapture()1007 bool Widget::HasCapture() {
1008 return native_widget_->HasCapture();
1009 }
1010
GetTooltipManager()1011 TooltipManager* Widget::GetTooltipManager() {
1012 return native_widget_->GetTooltipManager();
1013 }
1014
GetTooltipManager() const1015 const TooltipManager* Widget::GetTooltipManager() const {
1016 return native_widget_->GetTooltipManager();
1017 }
1018
GetWorkAreaBoundsInScreen() const1019 gfx::Rect Widget::GetWorkAreaBoundsInScreen() const {
1020 return native_widget_->GetWorkAreaBoundsInScreen();
1021 }
1022
SynthesizeMouseMoveEvent()1023 void Widget::SynthesizeMouseMoveEvent() {
1024 // In screen coordinate.
1025 gfx::Point mouse_location =
1026 display::Screen::GetScreen()->GetCursorScreenPoint();
1027 if (!GetWindowBoundsInScreen().Contains(mouse_location))
1028 return;
1029
1030 // Convert: screen coordinate -> widget coordinate.
1031 View::ConvertPointFromScreen(root_view_.get(), &mouse_location);
1032 last_mouse_event_was_move_ = false;
1033 ui::MouseEvent mouse_event(ui::ET_MOUSE_MOVED, mouse_location, mouse_location,
1034 ui::EventTimeForNow(), ui::EF_IS_SYNTHESIZED, 0);
1035 root_view_->OnMouseMoved(mouse_event);
1036 }
1037
IsTranslucentWindowOpacitySupported() const1038 bool Widget::IsTranslucentWindowOpacitySupported() const {
1039 return native_widget_->IsTranslucentWindowOpacitySupported();
1040 }
1041
GetGestureRecognizer()1042 ui::GestureRecognizer* Widget::GetGestureRecognizer() {
1043 return native_widget_->GetGestureRecognizer();
1044 }
1045
OnSizeConstraintsChanged()1046 void Widget::OnSizeConstraintsChanged() {
1047 native_widget_->OnSizeConstraintsChanged();
1048 if (non_client_view_)
1049 non_client_view_->SizeConstraintsChanged();
1050 }
1051
OnOwnerClosing()1052 void Widget::OnOwnerClosing() {}
1053
GetName() const1054 std::string Widget::GetName() const {
1055 return native_widget_->GetName();
1056 }
1057
1058 std::unique_ptr<Widget::PaintAsActiveCallbackList::Subscription>
RegisterPaintAsActiveChangedCallback(PaintAsActiveCallbackList::CallbackType callback)1059 Widget::RegisterPaintAsActiveChangedCallback(
1060 PaintAsActiveCallbackList::CallbackType callback) {
1061 return paint_as_active_callbacks_.Add(std::move(callback));
1062 }
1063
LockPaintAsActive()1064 std::unique_ptr<Widget::PaintAsActiveLock> Widget::LockPaintAsActive() {
1065 const bool was_paint_as_active = ShouldPaintAsActive();
1066 ++paint_as_active_refcount_;
1067 if (ShouldPaintAsActive() != was_paint_as_active)
1068 paint_as_active_callbacks_.Notify();
1069 return std::make_unique<PaintAsActiveLockImpl>(
1070 weak_ptr_factory_.GetWeakPtr());
1071 }
1072
GetWeakPtr()1073 base::WeakPtr<Widget> Widget::GetWeakPtr() {
1074 return weak_ptr_factory_.GetWeakPtr();
1075 }
1076
ShouldPaintAsActive() const1077 bool Widget::ShouldPaintAsActive() const {
1078 return native_widget_active_ || paint_as_active_refcount_;
1079 }
1080
1081 ////////////////////////////////////////////////////////////////////////////////
1082 // Widget, NativeWidgetDelegate implementation:
1083
IsModal() const1084 bool Widget::IsModal() const {
1085 return widget_delegate_->GetModalType() != ui::MODAL_TYPE_NONE;
1086 }
1087
IsDialogBox() const1088 bool Widget::IsDialogBox() const {
1089 return !!widget_delegate_->AsDialogDelegate();
1090 }
1091
CanActivate() const1092 bool Widget::CanActivate() const {
1093 // This may be called after OnNativeWidgetDestroyed(), which sets
1094 // |widget_delegate_| to null.
1095 return widget_delegate_ && widget_delegate_->CanActivate();
1096 }
1097
IsNativeWidgetInitialized() const1098 bool Widget::IsNativeWidgetInitialized() const {
1099 return native_widget_initialized_;
1100 }
1101
OnNativeWidgetActivationChanged(bool active)1102 bool Widget::OnNativeWidgetActivationChanged(bool active) {
1103 if (g_disable_activation_change_handling_)
1104 return false;
1105
1106 // On windows we may end up here before we've completed initialization (from
1107 // an WM_NCACTIVATE). If that happens the WidgetDelegate likely doesn't know
1108 // the Widget and will crash attempting to access it.
1109 if (!active && native_widget_initialized_)
1110 SaveWindowPlacement();
1111
1112 for (WidgetObserver& observer : observers_)
1113 observer.OnWidgetActivationChanged(this, active);
1114
1115 const bool was_paint_as_active = ShouldPaintAsActive();
1116 native_widget_active_ = active;
1117 if (ShouldPaintAsActive() != was_paint_as_active)
1118 paint_as_active_callbacks_.Notify();
1119
1120 return true;
1121 }
1122
OnNativeFocus()1123 void Widget::OnNativeFocus() {
1124 WidgetFocusManager::GetInstance()->OnNativeFocusChanged(GetNativeView());
1125 }
1126
OnNativeBlur()1127 void Widget::OnNativeBlur() {
1128 WidgetFocusManager::GetInstance()->OnNativeFocusChanged(nullptr);
1129 }
1130
OnNativeWidgetVisibilityChanging(bool visible)1131 void Widget::OnNativeWidgetVisibilityChanging(bool visible) {
1132 for (WidgetObserver& observer : observers_)
1133 observer.OnWidgetVisibilityChanging(this, visible);
1134 }
1135
OnNativeWidgetVisibilityChanged(bool visible)1136 void Widget::OnNativeWidgetVisibilityChanged(bool visible) {
1137 View* root = GetRootView();
1138 if (root)
1139 root->PropagateVisibilityNotifications(root, visible);
1140 for (WidgetObserver& observer : observers_)
1141 observer.OnWidgetVisibilityChanged(this, visible);
1142 if (GetCompositor() && root && root->layer())
1143 root->layer()->SetVisible(visible);
1144 }
1145
OnNativeWidgetCreated()1146 void Widget::OnNativeWidgetCreated() {
1147 if (is_top_level())
1148 focus_manager_ = FocusManagerFactory::Create(this);
1149
1150 native_widget_->InitModalType(widget_delegate_->GetModalType());
1151
1152 for (WidgetObserver& observer : observers_)
1153 observer.OnWidgetCreated(this);
1154 }
1155
OnNativeWidgetDestroying()1156 void Widget::OnNativeWidgetDestroying() {
1157 // Tell the focus manager (if any) that root_view is being removed
1158 // in case that the focused view is under this root view.
1159 if (GetFocusManager() && root_view_)
1160 GetFocusManager()->ViewRemoved(root_view_.get());
1161 for (WidgetObserver& observer : observers_)
1162 observer.OnWidgetDestroying(this);
1163 if (non_client_view_)
1164 non_client_view_->WindowClosing();
1165 widget_delegate_->WindowClosing();
1166 }
1167
OnNativeWidgetDestroyed()1168 void Widget::OnNativeWidgetDestroyed() {
1169 for (WidgetObserver& observer : observers_)
1170 observer.OnWidgetDestroyed(this);
1171 widget_delegate_->can_delete_this_ = true;
1172 widget_delegate_->DeleteDelegate();
1173 widget_delegate_ = nullptr;
1174 native_widget_destroyed_ = true;
1175 }
1176
GetMinimumSize() const1177 gfx::Size Widget::GetMinimumSize() const {
1178 return non_client_view_ ? non_client_view_->GetMinimumSize() : gfx::Size();
1179 }
1180
GetMaximumSize() const1181 gfx::Size Widget::GetMaximumSize() const {
1182 return non_client_view_ ? non_client_view_->GetMaximumSize() : gfx::Size();
1183 }
1184
OnNativeWidgetMove()1185 void Widget::OnNativeWidgetMove() {
1186 TRACE_EVENT0("ui", "Widget::OnNativeWidgetMove");
1187
1188 widget_delegate_->OnWidgetMove();
1189 NotifyCaretBoundsChanged(GetInputMethod());
1190
1191 for (WidgetObserver& observer : observers_)
1192 observer.OnWidgetBoundsChanged(this, GetWindowBoundsInScreen());
1193 }
1194
OnNativeWidgetSizeChanged(const gfx::Size & new_size)1195 void Widget::OnNativeWidgetSizeChanged(const gfx::Size& new_size) {
1196 TRACE_EVENT0("ui", "Widget::OnNativeWidgetSizeChanged");
1197
1198 View* root = GetRootView();
1199 if (root)
1200 root->SetSize(new_size);
1201
1202 NotifyCaretBoundsChanged(GetInputMethod());
1203 SaveWindowPlacementIfInitialized();
1204
1205 for (WidgetObserver& observer : observers_)
1206 observer.OnWidgetBoundsChanged(this, GetWindowBoundsInScreen());
1207 }
1208
OnNativeWidgetWorkspaceChanged()1209 void Widget::OnNativeWidgetWorkspaceChanged() {}
1210
OnNativeWidgetWindowShowStateChanged()1211 void Widget::OnNativeWidgetWindowShowStateChanged() {
1212 SaveWindowPlacementIfInitialized();
1213 }
1214
OnNativeWidgetBeginUserBoundsChange()1215 void Widget::OnNativeWidgetBeginUserBoundsChange() {
1216 widget_delegate_->OnWindowBeginUserBoundsChange();
1217 }
1218
OnNativeWidgetEndUserBoundsChange()1219 void Widget::OnNativeWidgetEndUserBoundsChange() {
1220 widget_delegate_->OnWindowEndUserBoundsChange();
1221 }
1222
HasFocusManager() const1223 bool Widget::HasFocusManager() const {
1224 return !!focus_manager_.get();
1225 }
1226
OnNativeWidgetPaint(const ui::PaintContext & context)1227 void Widget::OnNativeWidgetPaint(const ui::PaintContext& context) {
1228 // On Linux Aura, we can get here during Init() because of the
1229 // SetInitialBounds call.
1230 if (!native_widget_initialized_)
1231 return;
1232 GetRootView()->PaintFromPaintRoot(context);
1233 }
1234
GetNonClientComponent(const gfx::Point & point)1235 int Widget::GetNonClientComponent(const gfx::Point& point) {
1236 int component =
1237 non_client_view_ ? non_client_view_->NonClientHitTest(point) : HTNOWHERE;
1238
1239 if (movement_disabled_ && (component == HTCAPTION || component == HTSYSMENU))
1240 return HTNOWHERE;
1241
1242 return component;
1243 }
1244
OnKeyEvent(ui::KeyEvent * event)1245 void Widget::OnKeyEvent(ui::KeyEvent* event) {
1246 SendEventToSink(event);
1247 if (!event->handled() && GetFocusManager() &&
1248 !GetFocusManager()->OnKeyEvent(*event)) {
1249 event->StopPropagation();
1250 }
1251 }
1252
1253 // TODO(tdanderson): We should not be calling the OnMouse*() functions on
1254 // RootView from anywhere in Widget. Use
1255 // SendEventToSink() instead. See crbug.com/348087.
OnMouseEvent(ui::MouseEvent * event)1256 void Widget::OnMouseEvent(ui::MouseEvent* event) {
1257 TRACE_EVENT0("ui", "Widget::OnMouseEvent");
1258
1259 View* root_view = GetRootView();
1260 switch (event->type()) {
1261 case ui::ET_MOUSE_PRESSED: {
1262 last_mouse_event_was_move_ = false;
1263
1264 // We may get deleted by the time we return from OnMousePressed. So we
1265 // use an observer to make sure we are still alive.
1266 WidgetDeletionObserver widget_deletion_observer(this);
1267
1268 gfx::NativeView current_capture =
1269 internal::NativeWidgetPrivate::GetGlobalCapture(
1270 native_widget_->GetNativeView());
1271 // Make sure we're still visible before we attempt capture as the mouse
1272 // press processing may have made the window hide (as happens with menus).
1273 //
1274 // It is possible that capture has changed as a result of a mouse-press.
1275 // In these cases do not update internal state.
1276 //
1277 // A mouse-press may trigger a nested message-loop, and absorb the paired
1278 // release. If so the code returns here. So make sure that that
1279 // mouse-button is still down before attempting to do a capture.
1280 if (root_view && root_view->OnMousePressed(*event) &&
1281 widget_deletion_observer.IsWidgetAlive() && IsVisible() &&
1282 native_widget_->IsMouseButtonDown() &&
1283 current_capture == internal::NativeWidgetPrivate::GetGlobalCapture(
1284 native_widget_->GetNativeView())) {
1285 is_mouse_button_pressed_ = true;
1286 if (!native_widget_->HasCapture())
1287 native_widget_->SetCapture();
1288 event->SetHandled();
1289 }
1290 return;
1291 }
1292
1293 case ui::ET_MOUSE_RELEASED:
1294 last_mouse_event_was_move_ = false;
1295 is_mouse_button_pressed_ = false;
1296 // Release capture first, to avoid confusion if OnMouseReleased blocks.
1297 if (auto_release_capture_ && native_widget_->HasCapture()) {
1298 base::AutoReset<bool> resetter(&ignore_capture_loss_, true);
1299 native_widget_->ReleaseCapture();
1300 }
1301 if (root_view)
1302 root_view->OnMouseReleased(*event);
1303 if ((event->flags() & ui::EF_IS_NON_CLIENT) == 0 &&
1304 // If none of the "normal" buttons are pressed, this event may be from
1305 // one of the newer mice that have buttons bound to browser forward
1306 // back actions. Don't squelch the event and let the default handler
1307 // process it.
1308 (event->flags() &
1309 (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON |
1310 ui::EF_RIGHT_MOUSE_BUTTON)) != 0)
1311 event->SetHandled();
1312 return;
1313
1314 case ui::ET_MOUSE_MOVED:
1315 case ui::ET_MOUSE_DRAGGED:
1316 if (native_widget_->HasCapture() && is_mouse_button_pressed_) {
1317 last_mouse_event_was_move_ = false;
1318 if (root_view)
1319 root_view->OnMouseDragged(*event);
1320 } else if (!last_mouse_event_was_move_ ||
1321 last_mouse_event_position_ != event->location()) {
1322 last_mouse_event_position_ = event->location();
1323 last_mouse_event_was_move_ = true;
1324 if (root_view)
1325 root_view->OnMouseMoved(*event);
1326 }
1327 return;
1328
1329 case ui::ET_MOUSE_EXITED:
1330 last_mouse_event_was_move_ = false;
1331 if (root_view)
1332 root_view->OnMouseExited(*event);
1333 return;
1334
1335 case ui::ET_MOUSEWHEEL:
1336 if (root_view && root_view->OnMouseWheel(
1337 static_cast<const ui::MouseWheelEvent&>(*event)))
1338 event->SetHandled();
1339 return;
1340
1341 default:
1342 return;
1343 }
1344 }
1345
OnMouseCaptureLost()1346 void Widget::OnMouseCaptureLost() {
1347 if (ignore_capture_loss_)
1348 return;
1349
1350 View* root_view = GetRootView();
1351 if (root_view)
1352 root_view->OnMouseCaptureLost();
1353 is_mouse_button_pressed_ = false;
1354 }
1355
OnScrollEvent(ui::ScrollEvent * event)1356 void Widget::OnScrollEvent(ui::ScrollEvent* event) {
1357 ui::ScrollEvent event_copy(*event);
1358 SendEventToSink(&event_copy);
1359
1360 // Convert unhandled ui::ET_SCROLL events into ui::ET_MOUSEWHEEL events.
1361 if (!event_copy.handled() && event_copy.type() == ui::ET_SCROLL) {
1362 ui::MouseWheelEvent wheel(*event);
1363 OnMouseEvent(&wheel);
1364 }
1365 }
1366
OnGestureEvent(ui::GestureEvent * event)1367 void Widget::OnGestureEvent(ui::GestureEvent* event) {
1368 // We explicitly do not capture here. Not capturing enables multiple widgets
1369 // to get tap events at the same time. Views (such as tab dragging) may
1370 // explicitly capture.
1371 SendEventToSink(event);
1372 }
1373
ExecuteCommand(int command_id)1374 bool Widget::ExecuteCommand(int command_id) {
1375 return widget_delegate_->ExecuteWindowsCommand(command_id);
1376 }
1377
HasHitTestMask() const1378 bool Widget::HasHitTestMask() const {
1379 return widget_delegate_->WidgetHasHitTestMask();
1380 }
1381
GetHitTestMask(SkPath * mask) const1382 void Widget::GetHitTestMask(SkPath* mask) const {
1383 DCHECK(mask);
1384 widget_delegate_->GetWidgetHitTestMask(mask);
1385 }
1386
AsWidget()1387 Widget* Widget::AsWidget() {
1388 return this;
1389 }
1390
AsWidget() const1391 const Widget* Widget::AsWidget() const {
1392 return this;
1393 }
1394
SetInitialFocus(ui::WindowShowState show_state)1395 bool Widget::SetInitialFocus(ui::WindowShowState show_state) {
1396 FocusManager* focus_manager = GetFocusManager();
1397 if (!focus_manager)
1398 return false;
1399 View* v = widget_delegate_->GetInitiallyFocusedView();
1400 if (!focus_on_creation_ || show_state == ui::SHOW_STATE_INACTIVE ||
1401 show_state == ui::SHOW_STATE_MINIMIZED) {
1402 // If not focusing the window now, tell the focus manager which view to
1403 // focus when the window is restored.
1404 if (v)
1405 focus_manager->SetStoredFocusView(v);
1406 return true;
1407 }
1408 if (v) {
1409 v->RequestFocus();
1410 // If the Widget is active (thus allowing its child Views to receive focus),
1411 // but the request for focus was unsuccessful, fall back to using the first
1412 // focusable View instead.
1413 if (focus_manager->GetFocusedView() == nullptr && IsActive())
1414 focus_manager->AdvanceFocus(false);
1415 }
1416 return !!focus_manager->GetFocusedView();
1417 }
1418
ShouldDescendIntoChildForEventHandling(ui::Layer * root_layer,gfx::NativeView child,ui::Layer * child_layer,const gfx::Point & location)1419 bool Widget::ShouldDescendIntoChildForEventHandling(
1420 ui::Layer* root_layer,
1421 gfx::NativeView child,
1422 ui::Layer* child_layer,
1423 const gfx::Point& location) {
1424 if (widget_delegate_ &&
1425 !widget_delegate_->ShouldDescendIntoChildForEventHandling(child,
1426 location)) {
1427 return false;
1428 }
1429
1430 const View::Views& views_with_layers = GetViewsWithLayers();
1431 if (views_with_layers.empty())
1432 return true;
1433
1434 // Don't descend into |child| if there is a view with a Layer that contains
1435 // the point and is stacked above |child_layer|.
1436 auto child_layer_iter = std::find(root_layer->children().begin(),
1437 root_layer->children().end(), child_layer);
1438 if (child_layer_iter == root_layer->children().end())
1439 return true;
1440
1441 for (View* view : base::Reversed(views_with_layers)) {
1442 ui::Layer* layer = view->layer();
1443 DCHECK(layer);
1444 if (layer->visible() && layer->bounds().Contains(location)) {
1445 auto root_layer_iter = std::find(root_layer->children().begin(),
1446 root_layer->children().end(), layer);
1447 if (child_layer_iter > root_layer_iter) {
1448 // |child| is on top of the remaining layers, no need to continue.
1449 return true;
1450 }
1451
1452 // Event targeting uses the visible bounds of the View, which may differ
1453 // from the bounds of the layer. Verify the view hosting the layer
1454 // actually contains |location|. Use GetVisibleBounds(), which is
1455 // effectively what event targetting uses.
1456 gfx::Rect vis_bounds = view->GetVisibleBounds();
1457 gfx::Point point_in_view = location;
1458 View::ConvertPointToTarget(GetRootView(), view, &point_in_view);
1459 if (vis_bounds.Contains(point_in_view))
1460 return false;
1461 }
1462 }
1463 return true;
1464 }
1465
LayoutRootViewIfNecessary()1466 void Widget::LayoutRootViewIfNecessary() {
1467 if (root_view_ && root_view_->needs_layout())
1468 root_view_->Layout();
1469 }
1470
1471 ////////////////////////////////////////////////////////////////////////////////
1472 // Widget, ui::EventSource implementation:
GetEventSink()1473 ui::EventSink* Widget::GetEventSink() {
1474 return root_view_.get();
1475 }
1476
1477 ////////////////////////////////////////////////////////////////////////////////
1478 // Widget, FocusTraversable implementation:
1479
GetFocusSearch()1480 FocusSearch* Widget::GetFocusSearch() {
1481 return root_view_->GetFocusSearch();
1482 }
1483
GetFocusTraversableParent()1484 FocusTraversable* Widget::GetFocusTraversableParent() {
1485 // We are a proxy to the root view, so we should be bypassed when traversing
1486 // up and as a result this should not be called.
1487 NOTREACHED();
1488 return nullptr;
1489 }
1490
GetFocusTraversableParentView()1491 View* Widget::GetFocusTraversableParentView() {
1492 // We are a proxy to the root view, so we should be bypassed when traversing
1493 // up and as a result this should not be called.
1494 NOTREACHED();
1495 return nullptr;
1496 }
1497
1498 ////////////////////////////////////////////////////////////////////////////////
1499 // Widget, ui::NativeThemeObserver implementation:
1500
OnNativeThemeUpdated(ui::NativeTheme * observed_theme)1501 void Widget::OnNativeThemeUpdated(ui::NativeTheme* observed_theme) {
1502 TRACE_EVENT0("ui", "Widget::OnNativeThemeUpdated");
1503
1504 DCHECK(observer_manager_.IsObserving(observed_theme));
1505
1506 #if defined(OS_APPLE) || defined(OS_WIN)
1507 ui::NativeTheme* current_native_theme = observed_theme;
1508 #else
1509 ui::NativeTheme* current_native_theme = GetNativeTheme();
1510 #endif
1511 if (!observer_manager_.IsObserving(current_native_theme)) {
1512 observer_manager_.RemoveAll();
1513 observer_manager_.Add(current_native_theme);
1514 }
1515
1516 PropagateNativeThemeChanged();
1517 }
1518
1519 ////////////////////////////////////////////////////////////////////////////////
1520 // Widget, protected:
1521
PropagateNativeThemeChanged()1522 void Widget::PropagateNativeThemeChanged() {
1523 root_view_->PropagateThemeChanged();
1524 }
1525
CreateRootView()1526 internal::RootView* Widget::CreateRootView() {
1527 return new internal::RootView(this);
1528 }
1529
DestroyRootView()1530 void Widget::DestroyRootView() {
1531 ClearFocusFromWidget();
1532 NotifyWillRemoveView(root_view_.get());
1533 non_client_view_ = nullptr;
1534 // Remove all children before the unique_ptr reset so that
1535 // GetWidget()->GetRootView() doesn't return nullptr while the views hierarchy
1536 // is being torn down.
1537 root_view_->RemoveAllChildViews(true);
1538 root_view_.reset();
1539 }
1540
OnDragWillStart()1541 void Widget::OnDragWillStart() {}
1542
OnDragComplete()1543 void Widget::OnDragComplete() {}
1544
1545 ////////////////////////////////////////////////////////////////////////////////
1546 // Widget, private:
1547
SaveWindowPlacement()1548 void Widget::SaveWindowPlacement() {
1549 // The window delegate does the actual saving for us. It seems like (judging
1550 // by go/crash) that in some circumstances we can end up here after
1551 // WM_DESTROY, at which point the window delegate is likely gone. So just
1552 // bail.
1553 if (!widget_delegate_)
1554 return;
1555
1556 ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
1557 gfx::Rect bounds;
1558 native_widget_->GetWindowPlacement(&bounds, &show_state);
1559 widget_delegate_->SaveWindowPlacement(bounds, show_state);
1560 }
1561
SaveWindowPlacementIfInitialized()1562 void Widget::SaveWindowPlacementIfInitialized() {
1563 if (native_widget_initialized_)
1564 SaveWindowPlacement();
1565 }
1566
SetInitialBounds(const gfx::Rect & bounds)1567 void Widget::SetInitialBounds(const gfx::Rect& bounds) {
1568 if (!non_client_view_)
1569 return;
1570
1571 gfx::Rect saved_bounds;
1572 if (GetSavedWindowPlacement(&saved_bounds, &saved_show_state_)) {
1573 if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED) {
1574 // If we're going to maximize, wait until Show is invoked to set the
1575 // bounds. That way we avoid a noticeable resize.
1576 initial_restored_bounds_ = saved_bounds;
1577 } else if (!saved_bounds.IsEmpty()) {
1578 // If the saved bounds are valid, use them.
1579 SetBounds(saved_bounds);
1580 }
1581 } else {
1582 if (bounds.IsEmpty()) {
1583 if (bounds.origin().IsOrigin()) {
1584 // No initial bounds supplied, so size the window to its content and
1585 // center over its parent.
1586 CenterWindow(non_client_view_->GetPreferredSize());
1587 } else {
1588 // Use the preferred size and the supplied origin.
1589 gfx::Rect preferred_bounds(bounds);
1590 preferred_bounds.set_size(non_client_view_->GetPreferredSize());
1591 SetBoundsConstrained(preferred_bounds);
1592 }
1593 } else {
1594 // Use the supplied initial bounds.
1595 SetBoundsConstrained(bounds);
1596 }
1597 }
1598 }
1599
SetInitialBoundsForFramelessWindow(const gfx::Rect & bounds)1600 void Widget::SetInitialBoundsForFramelessWindow(const gfx::Rect& bounds) {
1601 if (bounds.IsEmpty()) {
1602 View* contents_view = GetContentsView();
1603 DCHECK(contents_view);
1604 // No initial bounds supplied, so size the window to its content and
1605 // center over its parent if preferred size is provided.
1606 gfx::Size size = contents_view->GetPreferredSize();
1607 if (!size.IsEmpty())
1608 native_widget_->CenterWindow(size);
1609 } else {
1610 // Use the supplied initial bounds.
1611 SetBounds(bounds);
1612 }
1613 }
1614
GetSavedWindowPlacement(gfx::Rect * bounds,ui::WindowShowState * show_state)1615 bool Widget::GetSavedWindowPlacement(gfx::Rect* bounds,
1616 ui::WindowShowState* show_state) {
1617 // First we obtain the window's saved show-style and store it. We need to do
1618 // this here, rather than in Show() because by the time Show() is called,
1619 // the window's size will have been reset (below) and the saved maximized
1620 // state will have been lost. Sadly there's no way to tell on Windows when
1621 // a window is restored from maximized state, so we can't more accurately
1622 // track maximized state independently of sizing information.
1623
1624 if (!widget_delegate_->GetSavedWindowPlacement(this, bounds, show_state))
1625 return false;
1626
1627 gfx::Size minimum_size = GetMinimumSize();
1628 // Make sure the bounds are at least the minimum size.
1629 if (bounds->width() < minimum_size.width())
1630 bounds->set_width(minimum_size.width());
1631
1632 if (bounds->height() < minimum_size.height())
1633 bounds->set_height(minimum_size.height());
1634 return true;
1635 }
1636
GetViewsWithLayers()1637 const View::Views& Widget::GetViewsWithLayers() {
1638 if (views_with_layers_dirty_) {
1639 views_with_layers_dirty_ = false;
1640 views_with_layers_.clear();
1641 BuildViewsWithLayers(GetRootView(), &views_with_layers_);
1642 }
1643 return views_with_layers_;
1644 }
1645
UnlockPaintAsActive()1646 void Widget::UnlockPaintAsActive() {
1647 const bool was_paint_as_active = ShouldPaintAsActive();
1648 DCHECK_GT(paint_as_active_refcount_, 0U);
1649 --paint_as_active_refcount_;
1650 if (ShouldPaintAsActive() != was_paint_as_active)
1651 paint_as_active_callbacks_.Notify();
1652 }
1653
ClearFocusFromWidget()1654 void Widget::ClearFocusFromWidget() {
1655 FocusManager* focus_manager = GetFocusManager();
1656 // We are being removed from a window hierarchy. Treat this as
1657 // the root_view_ being removed.
1658 if (focus_manager)
1659 focus_manager->ViewRemoved(root_view_.get());
1660 }
1661
1662 namespace internal {
1663
1664 ////////////////////////////////////////////////////////////////////////////////
1665 // internal::NativeWidgetPrivate, NativeWidget implementation:
1666
AsNativeWidgetPrivate()1667 internal::NativeWidgetPrivate* NativeWidgetPrivate::AsNativeWidgetPrivate() {
1668 return this;
1669 }
1670
1671 } // namespace internal
1672 } // namespace views
1673