1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of the QtWidgets module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 3 requirements
23 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24 **
25 ** GNU General Public License Usage
26 ** Alternatively, this file may be used under the terms of the GNU
27 ** General Public License version 2.0 or (at your option) the GNU General
28 ** Public license version 3 or any later version approved by the KDE Free
29 ** Qt Foundation. The licenses are as published by the Free Software
30 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31 ** included in the packaging of this file. Please review the following
32 ** information to ensure the GNU General Public License requirements will
33 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34 ** https://www.gnu.org/licenses/gpl-3.0.html.
35 **
36 ** $QT_END_LICENSE$
37 **
38 ****************************************************************************/
39
40 #include "private/qwindow_p.h"
41 #include "qwidgetwindow_p.h"
42 #include "qlayout.h"
43
44 #include "private/qwidget_p.h"
45 #include "private/qapplication_p.h"
46 #ifndef QT_NO_ACCESSIBILITY
47 #include <QtGui/qaccessible.h>
48 #endif
49 #include <private/qwidgetrepaintmanager_p.h>
50 #include <qpa/qwindowsysteminterface_p.h>
51 #include <qpa/qplatformtheme.h>
52 #include <qpa/qplatformwindow.h>
53 #include <private/qgesturemanager_p.h>
54 #include <private/qhighdpiscaling_p.h>
55
56 QT_BEGIN_NAMESPACE
57
58 Q_WIDGETS_EXPORT extern bool qt_tab_all_widgets();
59
60 Q_WIDGETS_EXPORT QWidget *qt_button_down = nullptr; // widget got last button-down
61
62 // popup control
63 QWidget *qt_popup_down = nullptr; // popup that contains the pressed widget
64 extern int openPopupCount;
65 bool qt_popup_down_closed = false; // qt_popup_down has been closed
66 bool qt_replay_popup_mouse_event = false;
67 extern bool qt_try_modal(QWidget *widget, QEvent::Type type);
68
69 class QWidgetWindowPrivate : public QWindowPrivate
70 {
71 Q_DECLARE_PUBLIC(QWidgetWindow)
72 public:
setVisible(bool visible)73 void setVisible(bool visible) override
74 {
75 Q_Q(QWidgetWindow);
76 if (QWidget *widget = q->widget()) {
77 // Check if the widget was already hidden, as this indicates it was done
78 // explicitly and not because the parent window in this case made it hidden.
79 // In which case do not automatically show the widget when the parent
80 // window is shown.
81 const bool wasHidden = widget->testAttribute(Qt::WA_WState_Hidden);
82 QWidgetPrivate::get(widget)->setVisible(visible);
83 if (!wasHidden)
84 widget->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
85 } else {
86 QWindowPrivate::setVisible(visible);
87 }
88 }
89
eventReceiver()90 QWindow *eventReceiver() override {
91 Q_Q(QWidgetWindow);
92 QWindow *w = q;
93 while (w->parent() && qobject_cast<QWidgetWindow *>(w) && qobject_cast<QWidgetWindow *>(w->parent())) {
94 w = w->parent();
95 }
96 return w;
97 }
98
clearFocusObject()99 void clearFocusObject() override
100 {
101 Q_Q(QWidgetWindow);
102 QWidget *widget = q->widget();
103 if (widget && widget->focusWidget())
104 widget->focusWidget()->clearFocus();
105 }
106
107 QRectF closestAcceptableGeometry(const QRectF &rect) const override;
108 #if QT_CONFIG(opengl)
109 QOpenGLContext *shareContext() const override;
110 #endif
111
processSafeAreaMarginsChanged()112 void processSafeAreaMarginsChanged() override
113 {
114 Q_Q(QWidgetWindow);
115 if (QWidget *widget = q->widget())
116 QWidgetPrivate::get(widget)->updateContentsRect();
117 }
118 bool allowClickThrough(const QPoint &) const override;
119 };
120
closestAcceptableGeometry(const QRectF & rect) const121 QRectF QWidgetWindowPrivate::closestAcceptableGeometry(const QRectF &rect) const
122 {
123 Q_Q(const QWidgetWindow);
124 const QWidget *widget = q->widget();
125 if (!widget || !widget->isWindow() || !widget->hasHeightForWidth())
126 return QRect();
127 const QSize oldSize = rect.size().toSize();
128 const QSize newSize = QLayout::closestAcceptableSize(widget, oldSize);
129 if (newSize == oldSize)
130 return QRectF();
131 const int dw = newSize.width() - oldSize.width();
132 const int dh = newSize.height() - oldSize.height();
133 QRectF result = rect;
134 const QRectF currentGeometry(widget->geometry());
135 const qreal topOffset = result.top() - currentGeometry.top();
136 const qreal bottomOffset = result.bottom() - currentGeometry.bottom();
137 if (qAbs(topOffset) > qAbs(bottomOffset))
138 result.setTop(result.top() - dh); // top edge drag
139 else
140 result.setBottom(result.bottom() + dh); // bottom edge drag
141 const qreal leftOffset = result.left() - currentGeometry.left();
142 const qreal rightOffset = result.right() - currentGeometry.right();
143 if (qAbs(leftOffset) > qAbs(rightOffset))
144 result.setLeft(result.left() - dw); // left edge drag
145 else
146 result.setRight(result.right() + dw); // right edge drag
147 return result;
148 }
149
150 #if QT_CONFIG(opengl)
shareContext() const151 QOpenGLContext *QWidgetWindowPrivate::shareContext() const
152 {
153 Q_Q(const QWidgetWindow);
154 const QWidgetPrivate *widgetPrivate = QWidgetPrivate::get(q->widget());
155 return widgetPrivate->shareContext();
156 }
157 #endif // opengl
158
QWidgetWindow(QWidget * widget)159 QWidgetWindow::QWidgetWindow(QWidget *widget)
160 : QWindow(*new QWidgetWindowPrivate(), nullptr)
161 , m_widget(widget)
162 {
163 updateObjectName();
164 // Enable QOpenGLWidget/QQuickWidget children if the platform plugin supports it,
165 // and the application developer has not explicitly disabled it.
166 if (QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::RasterGLSurface)
167 && !QCoreApplication::testAttribute(Qt::AA_ForceRasterWidgets)) {
168 setSurfaceType(QSurface::RasterGLSurface);
169 }
170 connect(widget, &QObject::objectNameChanged, this, &QWidgetWindow::updateObjectName);
171 connect(this, SIGNAL(screenChanged(QScreen*)), this, SLOT(handleScreenChange()));
172 }
173
~QWidgetWindow()174 QWidgetWindow::~QWidgetWindow()
175 {
176 }
177
178 #ifndef QT_NO_ACCESSIBILITY
accessibleRoot() const179 QAccessibleInterface *QWidgetWindow::accessibleRoot() const
180 {
181 if (m_widget)
182 return QAccessible::queryAccessibleInterface(m_widget);
183 return nullptr;
184 }
185 #endif
186
focusObject() const187 QObject *QWidgetWindow::focusObject() const
188 {
189 QWidget *windowWidget = m_widget;
190 if (!windowWidget)
191 return nullptr;
192
193 // A window can't have a focus object if it's being destroyed.
194 if (QWidgetPrivate::get(windowWidget)->data.in_destructor)
195 return nullptr;
196
197 QWidget *widget = windowWidget->focusWidget();
198
199 if (!widget)
200 widget = windowWidget;
201
202 QObject *focusObj = QWidgetPrivate::get(widget)->focusObject();
203 if (focusObj)
204 return focusObj;
205
206 return widget;
207 }
208
setNativeWindowVisibility(bool visible)209 void QWidgetWindow::setNativeWindowVisibility(bool visible)
210 {
211 Q_D(QWidgetWindow);
212 // Call base class setVisible() implementation to run the QWindow
213 // visibility logic. Don't call QWidgetWindowPrivate::setVisible()
214 // since that will recurse back into QWidget code.
215 d->QWindowPrivate::setVisible(visible);
216 }
217
shouldBePropagatedToWidget(QEvent * event)218 static inline bool shouldBePropagatedToWidget(QEvent *event)
219 {
220 switch (event->type()) {
221 // Handing show events to widgets would cause them to be triggered twice
222 case QEvent::Show:
223 case QEvent::Hide:
224 case QEvent::Timer:
225 case QEvent::DynamicPropertyChange:
226 case QEvent::ChildAdded:
227 case QEvent::ChildRemoved:
228 return false;
229 default:
230 return true;
231 }
232 }
233
allowClickThrough(const QPoint &) const234 bool QWidgetWindowPrivate::allowClickThrough(const QPoint &) const
235 {
236 return true;
237 }
238
event(QEvent * event)239 bool QWidgetWindow::event(QEvent *event)
240 {
241 if (!m_widget)
242 return QWindow::event(event);
243
244 if (m_widget->testAttribute(Qt::WA_DontShowOnScreen)) {
245 // \a event is uninteresting for QWidgetWindow, the event was probably
246 // generated before WA_DontShowOnScreen was set
247 if (!shouldBePropagatedToWidget(event))
248 return true;
249 return QCoreApplication::forwardEvent(m_widget, event);
250 }
251
252 switch (event->type()) {
253 case QEvent::Close: {
254 // The widget might be deleted in the close event handler.
255 QPointer<QObject> guard = this;
256 handleCloseEvent(static_cast<QCloseEvent *>(event));
257 if (guard)
258 QWindow::event(event);
259 return true;
260 }
261
262 case QEvent::Enter:
263 case QEvent::Leave:
264 handleEnterLeaveEvent(event);
265 return true;
266
267 // these should not be sent to QWidget, the corresponding events
268 // are sent by QApplicationPrivate::notifyActiveWindowChange()
269 case QEvent::FocusIn:
270 handleFocusInEvent(static_cast<QFocusEvent *>(event));
271 Q_FALLTHROUGH();
272 case QEvent::FocusOut: {
273 #ifndef QT_NO_ACCESSIBILITY
274 QAccessible::State state;
275 state.active = true;
276 QAccessibleStateChangeEvent ev(m_widget, state);
277 QAccessible::updateAccessibility(&ev);
278 #endif
279 return false; }
280
281 case QEvent::FocusAboutToChange:
282 if (QApplicationPrivate::focus_widget) {
283 if (QApplicationPrivate::focus_widget->testAttribute(Qt::WA_InputMethodEnabled))
284 QGuiApplication::inputMethod()->commit();
285
286 QGuiApplication::forwardEvent(QApplicationPrivate::focus_widget, event);
287 }
288 return true;
289
290 case QEvent::KeyPress:
291 case QEvent::KeyRelease:
292 case QEvent::ShortcutOverride:
293 handleKeyEvent(static_cast<QKeyEvent *>(event));
294 return true;
295
296 case QEvent::MouseMove:
297 case QEvent::MouseButtonPress:
298 case QEvent::MouseButtonRelease:
299 case QEvent::MouseButtonDblClick:
300 handleMouseEvent(static_cast<QMouseEvent *>(event));
301 return true;
302
303 case QEvent::NonClientAreaMouseMove:
304 case QEvent::NonClientAreaMouseButtonPress:
305 case QEvent::NonClientAreaMouseButtonRelease:
306 case QEvent::NonClientAreaMouseButtonDblClick:
307 handleNonClientAreaMouseEvent(static_cast<QMouseEvent *>(event));
308 return true;
309
310 case QEvent::TouchBegin:
311 case QEvent::TouchUpdate:
312 case QEvent::TouchEnd:
313 case QEvent::TouchCancel:
314 handleTouchEvent(static_cast<QTouchEvent *>(event));
315 return true;
316
317 case QEvent::Move:
318 handleMoveEvent(static_cast<QMoveEvent *>(event));
319 return true;
320
321 case QEvent::Resize:
322 handleResizeEvent(static_cast<QResizeEvent *>(event));
323 return true;
324
325 #if QT_CONFIG(wheelevent)
326 case QEvent::Wheel:
327 handleWheelEvent(static_cast<QWheelEvent *>(event));
328 return true;
329 #endif
330
331 #if QT_CONFIG(draganddrop)
332 case QEvent::DragEnter:
333 handleDragEnterEvent(static_cast<QDragEnterEvent *>(event));
334 return true;
335 case QEvent::DragMove:
336 handleDragMoveEvent(static_cast<QDragMoveEvent *>(event));
337 return true;
338 case QEvent::DragLeave:
339 handleDragLeaveEvent(static_cast<QDragLeaveEvent *>(event));
340 return true;
341 case QEvent::Drop:
342 handleDropEvent(static_cast<QDropEvent *>(event));
343 return true;
344 #endif
345
346 case QEvent::Expose:
347 handleExposeEvent(static_cast<QExposeEvent *>(event));
348 return true;
349
350 case QEvent::WindowStateChange:
351 QWindow::event(event); // Update QWindow::Visibility and emit signals.
352 handleWindowStateChangedEvent(static_cast<QWindowStateChangeEvent *>(event));
353 return true;
354
355 case QEvent::ThemeChange: {
356 QEvent widgetEvent(QEvent::ThemeChange);
357 QCoreApplication::forwardEvent(m_widget, &widgetEvent, event);
358 }
359 return true;
360
361 #if QT_CONFIG(tabletevent)
362 case QEvent::TabletPress:
363 case QEvent::TabletMove:
364 case QEvent::TabletRelease:
365 handleTabletEvent(static_cast<QTabletEvent *>(event));
366 return true;
367 #endif
368
369 #ifndef QT_NO_GESTURES
370 case QEvent::NativeGesture:
371 handleGestureEvent(static_cast<QNativeGestureEvent *>(event));
372 return true;
373 #endif
374
375 #ifndef QT_NO_CONTEXTMENU
376 case QEvent::ContextMenu:
377 handleContextMenuEvent(static_cast<QContextMenuEvent *>(event));
378 return true;
379 #endif // QT_NO_CONTEXTMENU
380
381 case QEvent::WindowBlocked:
382 qt_button_down = nullptr;
383 break;
384
385 case QEvent::UpdateRequest:
386 // This is not the same as an UpdateRequest for a QWidget. That just
387 // syncs the backing store while here we also must mark as dirty.
388 m_widget->repaint();
389 return true;
390
391 default:
392 break;
393 }
394
395 if (shouldBePropagatedToWidget(event) && QCoreApplication::forwardEvent(m_widget, event))
396 return true;
397
398 return QWindow::event(event);
399 }
400
401 QPointer<QWidget> qt_last_mouse_receiver = nullptr;
402
handleEnterLeaveEvent(QEvent * event)403 void QWidgetWindow::handleEnterLeaveEvent(QEvent *event)
404 {
405 #if !defined(Q_OS_MACOS) && !defined(Q_OS_IOS) // Cocoa tracks popups
406 // Ignore all enter/leave events from QPA if we are not on the first-level context menu.
407 // This prevents duplicated events on most platforms. Fake events will be delivered in
408 // QWidgetWindow::handleMouseEvent(QMouseEvent *). Make an exception whether the widget
409 // is already under mouse - let the mouse leave.
410 if (QApplicationPrivate::inPopupMode() && m_widget != QApplication::activePopupWidget() && !m_widget->underMouse())
411 return;
412 #endif
413 if (event->type() == QEvent::Leave) {
414 QWidget *enter = nullptr;
415 // Check from window system event queue if the next queued enter targets a window
416 // in the same window hierarchy (e.g. enter a child of this window). If so,
417 // remove the enter event from queue and handle both in single dispatch.
418 QWindowSystemInterfacePrivate::EnterEvent *systemEvent =
419 static_cast<QWindowSystemInterfacePrivate::EnterEvent *>
420 (QWindowSystemInterfacePrivate::peekWindowSystemEvent(QWindowSystemInterfacePrivate::Enter));
421 const QPointF globalPosF = systemEvent ? systemEvent->globalPos : QGuiApplicationPrivate::lastCursorPosition;
422 if (systemEvent) {
423 if (QWidgetWindow *enterWindow = qobject_cast<QWidgetWindow *>(systemEvent->enter))
424 {
425 QWindow *thisParent = this;
426 QWindow *enterParent = enterWindow;
427 while (thisParent->parent())
428 thisParent = thisParent->parent();
429 while (enterParent->parent())
430 enterParent = enterParent->parent();
431 if (thisParent == enterParent) {
432 QGuiApplicationPrivate::currentMouseWindow = enterWindow;
433 enter = enterWindow->widget();
434 QWindowSystemInterfacePrivate::removeWindowSystemEvent(systemEvent);
435 }
436 }
437 }
438 // Enter-leave between sibling widgets is ignored when there is a mousegrabber - this makes
439 // both native and non-native widgets work similarly.
440 // When mousegrabbing, leaves are only generated if leaving the parent window.
441 if (!enter || !QWidget::mouseGrabber()) {
442 // Preferred leave target is the last mouse receiver, unless it has native window,
443 // in which case it is assumed to receive it's own leave event when relevant.
444 QWidget *leave = m_widget;
445 if (qt_last_mouse_receiver && !qt_last_mouse_receiver->internalWinId())
446 leave = qt_last_mouse_receiver.data();
447 QApplicationPrivate::dispatchEnterLeave(enter, leave, globalPosF);
448 qt_last_mouse_receiver = enter;
449 }
450 } else {
451 const QEnterEvent *ee = static_cast<QEnterEvent *>(event);
452 QWidget *child = m_widget->childAt(ee->pos());
453 QWidget *receiver = child ? child : m_widget.data();
454 QWidget *leave = nullptr;
455 if (QApplicationPrivate::inPopupMode() && receiver == m_widget
456 && qt_last_mouse_receiver != m_widget) {
457 // This allows to deliver the leave event to the native widget
458 // action on first-level menu.
459 leave = qt_last_mouse_receiver;
460 }
461 QApplicationPrivate::dispatchEnterLeave(receiver, leave, ee->screenPos());
462 qt_last_mouse_receiver = receiver;
463 }
464 }
465
getFocusWidget(FocusWidgets fw)466 QWidget *QWidgetWindow::getFocusWidget(FocusWidgets fw)
467 {
468 QWidget *tlw = m_widget;
469 QWidget *w = tlw->nextInFocusChain();
470
471 QWidget *last = tlw;
472
473 uint focus_flag = qt_tab_all_widgets() ? Qt::TabFocus : Qt::StrongFocus;
474
475 while (w != tlw)
476 {
477 if (((w->focusPolicy() & focus_flag) == focus_flag)
478 && w->isVisibleTo(m_widget) && w->isEnabled())
479 {
480 last = w;
481 if (fw == FirstFocusWidget)
482 break;
483 }
484 w = w->nextInFocusChain();
485 }
486
487 return last;
488 }
489
handleFocusInEvent(QFocusEvent * e)490 void QWidgetWindow::handleFocusInEvent(QFocusEvent *e)
491 {
492 QWidget *focusWidget = nullptr;
493 if (e->reason() == Qt::BacktabFocusReason)
494 focusWidget = getFocusWidget(LastFocusWidget);
495 else if (e->reason() == Qt::TabFocusReason)
496 focusWidget = getFocusWidget(FirstFocusWidget);
497
498 if (focusWidget != nullptr)
499 focusWidget->setFocus();
500 }
501
handleNonClientAreaMouseEvent(QMouseEvent * e)502 void QWidgetWindow::handleNonClientAreaMouseEvent(QMouseEvent *e)
503 {
504 QApplication::forwardEvent(m_widget, e);
505 }
506
handleMouseEvent(QMouseEvent * event)507 void QWidgetWindow::handleMouseEvent(QMouseEvent *event)
508 {
509 static const QEvent::Type contextMenuTrigger =
510 QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::ContextMenuOnMouseRelease).toBool() ?
511 QEvent::MouseButtonRelease : QEvent::MouseButtonPress;
512 if (QApplicationPrivate::inPopupMode()) {
513 QPointer<QWidget> activePopupWidget = QApplication::activePopupWidget();
514 QPoint mapped = event->pos();
515 if (activePopupWidget != m_widget)
516 mapped = activePopupWidget->mapFromGlobal(event->globalPos());
517 bool releaseAfter = false;
518 QWidget *popupChild = activePopupWidget->childAt(mapped);
519
520 if (activePopupWidget != qt_popup_down) {
521 qt_button_down = nullptr;
522 qt_popup_down = nullptr;
523 }
524
525 switch (event->type()) {
526 case QEvent::MouseButtonPress:
527 case QEvent::MouseButtonDblClick:
528 qt_button_down = popupChild;
529 qt_popup_down = activePopupWidget;
530 qt_popup_down_closed = false;
531 break;
532 case QEvent::MouseButtonRelease:
533 releaseAfter = true;
534 break;
535 default:
536 break; // nothing for mouse move
537 }
538
539 int oldOpenPopupCount = openPopupCount;
540
541 if (activePopupWidget->isEnabled()) {
542 // deliver event
543 qt_replay_popup_mouse_event = false;
544 QPointer<QWidget> receiver = activePopupWidget;
545 QPoint widgetPos = mapped;
546 if (qt_button_down)
547 receiver = qt_button_down;
548 else if (popupChild)
549 receiver = popupChild;
550 if (receiver != activePopupWidget)
551 widgetPos = receiver->mapFromGlobal(event->globalPos());
552
553 #if !defined(Q_OS_MACOS) && !defined(Q_OS_IOS) // Cocoa tracks popups
554 const bool reallyUnderMouse = activePopupWidget->rect().contains(mapped);
555 const bool underMouse = activePopupWidget->underMouse();
556 if (underMouse != reallyUnderMouse) {
557 if (reallyUnderMouse) {
558 const QPoint receiverMapped = receiver->mapFromGlobal(event->screenPos().toPoint());
559 // Prevent negative mouse position on enter event - this event
560 // should be properly handled in "handleEnterLeaveEvent()".
561 if (receiverMapped.x() >= 0 && receiverMapped.y() >= 0) {
562 QApplicationPrivate::dispatchEnterLeave(receiver, nullptr, event->screenPos());
563 qt_last_mouse_receiver = receiver;
564 }
565 } else {
566 QApplicationPrivate::dispatchEnterLeave(nullptr, qt_last_mouse_receiver, event->screenPos());
567 qt_last_mouse_receiver = receiver;
568 receiver = activePopupWidget;
569 }
570 }
571 #endif
572 if ((event->type() != QEvent::MouseButtonPress)
573 || !(event->flags().testFlag(Qt::MouseEventCreatedDoubleClick))) {
574 // if the widget that was pressed is gone, then deliver move events without buttons
575 const auto buttons = event->type() == QEvent::MouseMove && qt_popup_down_closed
576 ? Qt::NoButton : event->buttons();
577 QMouseEvent e(event->type(), widgetPos, event->windowPos(), event->screenPos(),
578 event->button(), buttons, event->modifiers(), event->source());
579 e.setTimestamp(event->timestamp());
580 QApplicationPrivate::sendMouseEvent(receiver, &e, receiver, receiver->window(), &qt_button_down, qt_last_mouse_receiver);
581 qt_last_mouse_receiver = receiver;
582 }
583 } else {
584 // close disabled popups when a mouse button is pressed or released
585 switch (event->type()) {
586 case QEvent::MouseButtonPress:
587 case QEvent::MouseButtonDblClick:
588 case QEvent::MouseButtonRelease:
589 activePopupWidget->close();
590 break;
591 default:
592 break;
593 }
594 }
595
596 if (QApplication::activePopupWidget() != activePopupWidget
597 && qt_replay_popup_mouse_event
598 && QGuiApplicationPrivate::platformIntegration()->styleHint(QPlatformIntegration::ReplayMousePressOutsidePopup).toBool()) {
599 if (m_widget->windowType() != Qt::Popup)
600 qt_button_down = nullptr;
601 if (event->type() == QEvent::MouseButtonPress) {
602 // the popup disappeared, replay the mouse press event
603 QWidget *w = QApplication::widgetAt(event->globalPos());
604 if (w && !QApplicationPrivate::isBlockedByModal(w)) {
605 // activate window of the widget under mouse pointer
606 if (!w->isActiveWindow()) {
607 w->activateWindow();
608 w->window()->raise();
609 }
610
611 if (auto win = qt_widget_private(w)->windowHandle(QWidgetPrivate::WindowHandleMode::Closest)) {
612 const QRect globalGeometry = win->isTopLevel()
613 ? win->geometry()
614 : QRect(win->mapToGlobal(QPoint(0, 0)), win->size());
615 if (globalGeometry.contains(event->globalPos())) {
616 // Use postEvent() to ensure the local QEventLoop terminates when called from QMenu::exec()
617 const QPoint localPos = win->mapFromGlobal(event->globalPos());
618 QMouseEvent *e = new QMouseEvent(QEvent::MouseButtonPress, localPos, localPos, event->globalPos(),
619 event->button(), event->buttons(), event->modifiers(), event->source());
620 QCoreApplicationPrivate::setEventSpontaneous(e, true);
621 e->setTimestamp(event->timestamp());
622 QCoreApplication::postEvent(win, e);
623 }
624 }
625 }
626 }
627 qt_replay_popup_mouse_event = false;
628 #ifndef QT_NO_CONTEXTMENU
629 } else if (event->type() == contextMenuTrigger
630 && event->button() == Qt::RightButton
631 && (openPopupCount == oldOpenPopupCount)) {
632 QWidget *receiver = activePopupWidget;
633 if (qt_button_down)
634 receiver = qt_button_down;
635 else if(popupChild)
636 receiver = popupChild;
637 QContextMenuEvent e(QContextMenuEvent::Mouse, mapped, event->globalPos(), event->modifiers());
638 QApplication::forwardEvent(receiver, &e, event);
639 }
640 #else
641 Q_UNUSED(contextMenuTrigger)
642 Q_UNUSED(oldOpenPopupCount)
643 }
644 #endif
645
646 if (releaseAfter) {
647 qt_button_down = nullptr;
648 qt_popup_down_closed = false;
649 qt_popup_down = nullptr;
650 }
651 return;
652 }
653
654 qt_popup_down_closed = false;
655 // modal event handling
656 if (QApplicationPrivate::instance()->modalState() && !qt_try_modal(m_widget, event->type()))
657 return;
658
659 // which child should have it?
660 QWidget *widget = m_widget->childAt(event->pos());
661 QPoint mapped = event->pos();
662
663 if (!widget)
664 widget = m_widget;
665
666 const bool initialPress = event->buttons() == event->button();
667 if (event->type() == QEvent::MouseButtonPress && initialPress)
668 qt_button_down = widget;
669
670 QWidget *receiver = QApplicationPrivate::pickMouseReceiver(m_widget, event->windowPos().toPoint(), &mapped, event->type(), event->buttons(),
671 qt_button_down, widget);
672 if (!receiver)
673 return;
674
675 if ((event->type() != QEvent::MouseButtonPress)
676 || !(event->flags().testFlag(Qt::MouseEventCreatedDoubleClick))) {
677
678 // The preceding statement excludes MouseButtonPress events which caused
679 // creation of a MouseButtonDblClick event. QTBUG-25831
680 QMouseEvent translated(event->type(), mapped, event->windowPos(), event->screenPos(),
681 event->button(), event->buttons(), event->modifiers(), event->source());
682 translated.setTimestamp(event->timestamp());
683 QApplicationPrivate::sendMouseEvent(receiver, &translated, widget, m_widget,
684 &qt_button_down, qt_last_mouse_receiver);
685 event->setAccepted(translated.isAccepted());
686 }
687 #ifndef QT_NO_CONTEXTMENU
688 if (event->type() == contextMenuTrigger && event->button() == Qt::RightButton
689 && m_widget->rect().contains(event->pos())) {
690 QContextMenuEvent e(QContextMenuEvent::Mouse, mapped, event->globalPos(), event->modifiers());
691 QGuiApplication::forwardEvent(receiver, &e, event);
692 }
693 #endif
694 }
695
handleTouchEvent(QTouchEvent * event)696 void QWidgetWindow::handleTouchEvent(QTouchEvent *event)
697 {
698 if (event->type() == QEvent::TouchCancel) {
699 QApplicationPrivate::translateTouchCancel(event->device(), event->timestamp());
700 event->accept();
701 } else if (QApplicationPrivate::inPopupMode()) {
702 // Ignore touch events for popups. This will cause QGuiApplication to synthesise mouse
703 // events instead, which QWidgetWindow::handleMouseEvent will forward correctly:
704 event->ignore();
705 } else {
706 event->setAccepted(QApplicationPrivate::translateRawTouchEvent(m_widget, event->device(), event->touchPoints(), event->timestamp()));
707 }
708 }
709
handleKeyEvent(QKeyEvent * event)710 void QWidgetWindow::handleKeyEvent(QKeyEvent *event)
711 {
712 if (QApplicationPrivate::instance()->modalState() && !qt_try_modal(m_widget, event->type()))
713 return;
714
715 QObject *receiver = QWidget::keyboardGrabber();
716 if (!receiver && QApplicationPrivate::inPopupMode()) {
717 QWidget *popup = QApplication::activePopupWidget();
718 QWidget *popupFocusWidget = popup->focusWidget();
719 receiver = popupFocusWidget ? popupFocusWidget : popup;
720 }
721 if (!receiver)
722 receiver = focusObject();
723 QGuiApplication::forwardEvent(receiver, event);
724 }
725
updateSize()726 bool QWidgetWindow::updateSize()
727 {
728 bool changed = false;
729 if (m_widget->testAttribute(Qt::WA_OutsideWSRange))
730 return changed;
731 if (m_widget->data->crect.size() != geometry().size()) {
732 changed = true;
733 m_widget->data->crect.setSize(geometry().size());
734 }
735
736 updateMargins();
737 return changed;
738 }
739
updateMargins()740 void QWidgetWindow::updateMargins()
741 {
742 const QMargins margins = frameMargins();
743 QTLWExtra *te = m_widget->d_func()->topData();
744 te->posIncludesFrame= false;
745 te->frameStrut.setCoords(margins.left(), margins.top(), margins.right(), margins.bottom());
746 m_widget->data->fstrut_dirty = false;
747 }
748
sendScreenChangeRecursively(QWidget * widget)749 static void sendScreenChangeRecursively(QWidget *widget)
750 {
751 QEvent e(QEvent::ScreenChangeInternal);
752 QCoreApplication::sendEvent(widget, &e);
753 QWidgetPrivate *d = QWidgetPrivate::get(widget);
754 for (int i = 0; i < d->children.size(); ++i) {
755 QWidget *w = qobject_cast<QWidget *>(d->children.at(i));
756 if (w)
757 sendScreenChangeRecursively(w);
758 }
759 }
760
handleScreenChange()761 void QWidgetWindow::handleScreenChange()
762 {
763 // Send an event recursively to the widget and its children.
764 sendScreenChangeRecursively(m_widget);
765
766 // Invalidate the backing store buffer and repaint immediately.
767 if (screen())
768 repaintWindow();
769 }
770
repaintWindow()771 void QWidgetWindow::repaintWindow()
772 {
773 if (!m_widget->isVisible() || !m_widget->updatesEnabled() || !m_widget->rect().isValid())
774 return;
775
776 QTLWExtra *tlwExtra = m_widget->window()->d_func()->maybeTopData();
777 if (tlwExtra && tlwExtra->backingStore)
778 tlwExtra->repaintManager->markDirty(m_widget->rect(), m_widget,
779 QWidgetRepaintManager::UpdateNow, QWidgetRepaintManager::BufferInvalid);
780 }
781
782 // Store normal geometry used for saving application settings.
updateNormalGeometry()783 void QWidgetWindow::updateNormalGeometry()
784 {
785 QTLWExtra *tle = m_widget->d_func()->maybeTopData();
786 if (!tle)
787 return;
788 // Ask platform window, default to widget geometry.
789 QRect normalGeometry;
790 if (const QPlatformWindow *pw = handle())
791 normalGeometry = QHighDpi::fromNativePixels(pw->normalGeometry(), this);
792 if (!normalGeometry.isValid() && !(m_widget->windowState() & ~Qt::WindowActive))
793 normalGeometry = m_widget->geometry();
794 if (normalGeometry.isValid())
795 tle->normalGeometry = normalGeometry;
796 }
797
handleMoveEvent(QMoveEvent * event)798 void QWidgetWindow::handleMoveEvent(QMoveEvent *event)
799 {
800 if (m_widget->testAttribute(Qt::WA_OutsideWSRange))
801 return;
802
803 auto oldPosition = m_widget->data->crect.topLeft();
804 auto newPosition = geometry().topLeft();
805
806 if (!m_widget->isTopLevel()) {
807 if (auto *nativeParent = m_widget->nativeParentWidget())
808 newPosition = m_widget->parentWidget()->mapFrom(nativeParent, newPosition);
809 }
810
811 bool changed = newPosition != oldPosition;
812
813 if (changed)
814 m_widget->data->crect.moveTopLeft(newPosition);
815
816 updateMargins(); // FIXME: Only do when changed?
817
818 if (changed) {
819 QMoveEvent widgetEvent(newPosition, oldPosition);
820 QGuiApplication::forwardEvent(m_widget, &widgetEvent, event);
821 }
822 }
823
handleResizeEvent(QResizeEvent * event)824 void QWidgetWindow::handleResizeEvent(QResizeEvent *event)
825 {
826 auto oldRect = m_widget->rect();
827
828 if (updateSize()) {
829 QGuiApplication::forwardEvent(m_widget, event);
830
831 if (m_widget->d_func()->shouldPaintOnScreen()) {
832 QRegion dirtyRegion = m_widget->rect();
833 if (m_widget->testAttribute(Qt::WA_StaticContents))
834 dirtyRegion -= oldRect;
835 m_widget->d_func()->syncBackingStore(dirtyRegion);
836 } else {
837 m_widget->d_func()->syncBackingStore();
838 }
839 }
840 }
841
handleCloseEvent(QCloseEvent * event)842 void QWidgetWindow::handleCloseEvent(QCloseEvent *event)
843 {
844 bool is_closing = m_widget->d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);
845 event->setAccepted(is_closing);
846 }
847
848 #if QT_CONFIG(wheelevent)
849
handleWheelEvent(QWheelEvent * event)850 void QWidgetWindow::handleWheelEvent(QWheelEvent *event)
851 {
852 if (QApplicationPrivate::instance()->modalState() && !qt_try_modal(m_widget, event->type()))
853 return;
854
855 QWidget *rootWidget = m_widget;
856 QPoint pos = event->position().toPoint();
857
858 // Use proper popup window for wheel event. Some QPA sends the wheel
859 // event to the root menu, so redirect it to the proper popup window.
860 QWidget *activePopupWidget = QApplication::activePopupWidget();
861 if (activePopupWidget && activePopupWidget != m_widget) {
862 rootWidget = activePopupWidget;
863 pos = rootWidget->mapFromGlobal(event->globalPosition().toPoint());
864 }
865
866 // which child should have it?
867 QWidget *widget = rootWidget->childAt(pos);
868
869 if (!widget)
870 widget = rootWidget;
871
872 QPoint mapped = widget->mapFrom(rootWidget, pos);
873
874 #if QT_DEPRECATED_SINCE(5, 0)
875 QT_WARNING_PUSH
876 QT_WARNING_DISABLE_DEPRECATED
877 QWheelEvent translated(mapped, event->globalPos(), event->pixelDelta(), event->angleDelta(), event->delta(), event->orientation(), event->buttons(), event->modifiers(), event->phase(), event->source(), event->inverted());
878 QT_WARNING_POP
879 #else
880 QWheelEvent translated(QPointF(mapped), event->globalPosition(), event->pixelDelta(), event->angleDelta(),
881 event->buttons(), event->modifiers(), event->phase(), event->inverted(), event->source());
882 #endif
883 translated.setTimestamp(event->timestamp());
884 QGuiApplication::forwardEvent(widget, &translated, event);
885 }
886
887 #endif // QT_CONFIG(wheelevent)
888
889 #if QT_CONFIG(draganddrop)
890
findDnDTarget(QWidget * parent,const QPoint & pos)891 static QWidget *findDnDTarget(QWidget *parent, const QPoint &pos)
892 {
893 // Find a target widget under mouse that accepts drops (QTBUG-22987).
894 QWidget *widget = parent->childAt(pos);
895 if (!widget)
896 widget = parent;
897 for ( ; widget && !widget->isWindow() && !widget->acceptDrops(); widget = widget->parentWidget()) ;
898 if (widget && !widget->acceptDrops())
899 widget = nullptr;
900 return widget;
901 }
902
handleDragEnterEvent(QDragEnterEvent * event,QWidget * widget)903 void QWidgetWindow::handleDragEnterEvent(QDragEnterEvent *event, QWidget *widget)
904 {
905 Q_ASSERT(m_dragTarget == nullptr);
906 if (!widget)
907 widget = findDnDTarget(m_widget, event->pos());
908 if (!widget) {
909 event->ignore();
910 return;
911 }
912 m_dragTarget = widget;
913
914 const QPoint mapped = widget->mapFromGlobal(m_widget->mapToGlobal(event->pos()));
915 QDragEnterEvent translated(mapped, event->possibleActions(), event->mimeData(),
916 event->mouseButtons(), event->keyboardModifiers());
917 QGuiApplication::forwardEvent(m_dragTarget, &translated, event);
918 event->setAccepted(translated.isAccepted());
919 event->setDropAction(translated.dropAction());
920 }
921
handleDragMoveEvent(QDragMoveEvent * event)922 void QWidgetWindow::handleDragMoveEvent(QDragMoveEvent *event)
923 {
924 QPointer<QWidget> widget = findDnDTarget(m_widget, event->pos());
925 if (!widget) {
926 event->ignore();
927 if (m_dragTarget) { // Send DragLeave to previous
928 QDragLeaveEvent leaveEvent;
929 QGuiApplication::forwardEvent(m_dragTarget, &leaveEvent, event);
930 m_dragTarget = nullptr;
931 }
932 } else {
933 const QPoint mapped = widget->mapFromGlobal(m_widget->mapToGlobal(event->pos()));
934 QDragMoveEvent translated(mapped, event->possibleActions(), event->mimeData(),
935 event->mouseButtons(), event->keyboardModifiers());
936
937 if (widget == m_dragTarget) { // Target widget unchanged: Send DragMove
938 translated.setDropAction(event->dropAction());
939 translated.setAccepted(event->isAccepted());
940 QGuiApplication::forwardEvent(m_dragTarget, &translated, event);
941 } else {
942 if (m_dragTarget) { // Send DragLeave to previous
943 QDragLeaveEvent leaveEvent;
944 QGuiApplication::forwardEvent(m_dragTarget, &leaveEvent, event);
945 m_dragTarget = nullptr;
946 }
947 // widget might have been deleted when handling the leaveEvent
948 if (widget) {
949 // Send DragEnter to new widget.
950 handleDragEnterEvent(static_cast<QDragEnterEvent*>(event), widget);
951 // Handling 'DragEnter' should suffice for the application.
952 translated.setDropAction(event->dropAction());
953 translated.setAccepted(event->isAccepted());
954 // The drag enter event is always immediately followed by a drag move event,
955 // see QDragEnterEvent documentation.
956 if (m_dragTarget)
957 QGuiApplication::forwardEvent(m_dragTarget, &translated, event);
958 }
959 }
960 event->setAccepted(translated.isAccepted());
961 event->setDropAction(translated.dropAction());
962 }
963 }
964
handleDragLeaveEvent(QDragLeaveEvent * event)965 void QWidgetWindow::handleDragLeaveEvent(QDragLeaveEvent *event)
966 {
967 if (m_dragTarget)
968 QGuiApplication::forwardEvent(m_dragTarget, event);
969 m_dragTarget = nullptr;
970 }
971
handleDropEvent(QDropEvent * event)972 void QWidgetWindow::handleDropEvent(QDropEvent *event)
973 {
974 if (Q_UNLIKELY(m_dragTarget.isNull())) {
975 qWarning() << m_widget << ": No drag target set.";
976 event->ignore();
977 return;
978 }
979 const QPoint mapped = m_dragTarget->mapFromGlobal(m_widget->mapToGlobal(event->pos()));
980 QDropEvent translated(mapped, event->possibleActions(), event->mimeData(), event->mouseButtons(), event->keyboardModifiers());
981 QGuiApplication::forwardEvent(m_dragTarget, &translated, event);
982 event->setAccepted(translated.isAccepted());
983 event->setDropAction(translated.dropAction());
984 m_dragTarget = nullptr;
985 }
986
987 #endif // QT_CONFIG(draganddrop)
988
handleExposeEvent(QExposeEvent * event)989 void QWidgetWindow::handleExposeEvent(QExposeEvent *event)
990 {
991 QWidgetPrivate *wPriv = m_widget->d_func();
992 const bool exposed = isExposed();
993
994 if (wPriv->childrenHiddenByWState) {
995 // If widgets has been previously hidden by window state change event
996 // and they aren't yet shown...
997 if (exposed) {
998 // If the window becomes exposed...
999 if (!wPriv->childrenShownByExpose) {
1000 // ... and they haven't been shown by this function yet - show it.
1001 wPriv->showChildren(true);
1002 QShowEvent showEvent;
1003 QCoreApplication::forwardEvent(m_widget, &showEvent, event);
1004 wPriv->childrenShownByExpose = true;
1005 }
1006 } else {
1007 // If the window becomes not exposed...
1008 if (wPriv->childrenShownByExpose) {
1009 // ... and child widgets was previously shown by the expose event - hide widgets again.
1010 // This is a workaround, because sometimes when window is minimized programatically,
1011 // the QPA can notify that the window is exposed after changing window state to minimized
1012 // and then, the QPA can send next expose event with null exposed region (not exposed).
1013 wPriv->hideChildren(true);
1014 QHideEvent hideEvent;
1015 QCoreApplication::forwardEvent(m_widget, &hideEvent, event);
1016 wPriv->childrenShownByExpose = false;
1017 }
1018 }
1019 }
1020
1021 if (exposed) {
1022 // QTBUG-39220, QTBUG-58575: set all (potentially fully obscured parent widgets) mapped.
1023 m_widget->setAttribute(Qt::WA_Mapped);
1024 for (QWidget *p = m_widget->parentWidget(); p && !p->testAttribute(Qt::WA_Mapped); p = p->parentWidget())
1025 p->setAttribute(Qt::WA_Mapped);
1026 if (!event->region().isNull())
1027 wPriv->syncBackingStore(event->region());
1028 } else {
1029 m_widget->setAttribute(Qt::WA_Mapped, false);
1030 }
1031 }
1032
handleWindowStateChangedEvent(QWindowStateChangeEvent * event)1033 void QWidgetWindow::handleWindowStateChangedEvent(QWindowStateChangeEvent *event)
1034 {
1035 // QWindow does currently not know 'active'.
1036 Qt::WindowStates eventState = event->oldState();
1037 Qt::WindowStates widgetState = m_widget->windowState();
1038 Qt::WindowStates windowState = windowStates();
1039 if (widgetState & Qt::WindowActive)
1040 eventState |= Qt::WindowActive;
1041
1042 // Determine the new widget state, remember maximized/full screen
1043 // during minimized.
1044 if (windowState & Qt::WindowMinimized) {
1045 widgetState |= Qt::WindowMinimized;
1046 } else {
1047 widgetState = windowState | (widgetState & Qt::WindowActive);
1048 if (windowState) // Maximized or FullScreen
1049 updateNormalGeometry();
1050 }
1051
1052 // Sent event if the state changed (that is, it is not triggered by
1053 // QWidget::setWindowState(), which also sends an event to the widget).
1054 if (widgetState != Qt::WindowStates::Int(m_widget->data->window_state)) {
1055 m_widget->data->window_state = uint(widgetState);
1056 QWindowStateChangeEvent widgetEvent(eventState);
1057 QGuiApplication::forwardEvent(m_widget, &widgetEvent, event);
1058 }
1059 }
1060
1061 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
nativeEvent(const QByteArray & eventType,void * message,qintptr * result)1062 bool QWidgetWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)
1063 #else
1064 bool QWidgetWindow::nativeEvent(const QByteArray &eventType, void *message, long *result)
1065 #endif
1066 {
1067 return m_widget->nativeEvent(eventType, message, result);
1068 }
1069
1070 #if QT_CONFIG(tabletevent)
handleTabletEvent(QTabletEvent * event)1071 void QWidgetWindow::handleTabletEvent(QTabletEvent *event)
1072 {
1073 static QPointer<QWidget> qt_tablet_target = nullptr;
1074
1075 QWidget *widget = qt_tablet_target;
1076
1077 if (!widget) {
1078 widget = m_widget->childAt(event->pos());
1079 if (event->type() == QEvent::TabletPress) {
1080 if (!widget)
1081 widget = m_widget;
1082 qt_tablet_target = widget;
1083 }
1084 }
1085
1086 if (widget) {
1087 QPointF delta = event->globalPosF() - event->globalPos();
1088 QPointF mapped = widget->mapFromGlobal(event->globalPos()) + delta;
1089 QTabletEvent ev(event->type(), mapped, event->globalPosF(), event->deviceType(), event->pointerType(),
1090 event->pressure(), event->xTilt(), event->yTilt(), event->tangentialPressure(),
1091 event->rotation(), event->z(), event->modifiers(), event->uniqueId(), event->button(), event->buttons());
1092 ev.setTimestamp(event->timestamp());
1093 ev.setAccepted(false);
1094 QGuiApplication::forwardEvent(widget, &ev, event);
1095 event->setAccepted(ev.isAccepted());
1096 }
1097
1098 if (event->type() == QEvent::TabletRelease && event->buttons() == Qt::NoButton)
1099 qt_tablet_target = nullptr;
1100 }
1101 #endif // QT_CONFIG(tabletevent)
1102
1103 #ifndef QT_NO_GESTURES
handleGestureEvent(QNativeGestureEvent * e)1104 void QWidgetWindow::handleGestureEvent(QNativeGestureEvent *e)
1105 {
1106 // copy-pasted code to find correct widget follows:
1107 QObject *receiver = nullptr;
1108 if (QApplicationPrivate::inPopupMode()) {
1109 QWidget *popup = QApplication::activePopupWidget();
1110 QWidget *popupFocusWidget = popup->focusWidget();
1111 receiver = popupFocusWidget ? popupFocusWidget : popup;
1112 }
1113 if (!receiver)
1114 receiver = QApplication::widgetAt(e->globalPos());
1115 if (!receiver)
1116 receiver = m_widget; // last resort
1117
1118 QApplication::forwardEvent(receiver, e);
1119 }
1120 #endif // QT_NO_GESTURES
1121
1122 #ifndef QT_NO_CONTEXTMENU
handleContextMenuEvent(QContextMenuEvent * e)1123 void QWidgetWindow::handleContextMenuEvent(QContextMenuEvent *e)
1124 {
1125 // We are only interested in keyboard originating context menu events here,
1126 // mouse originated context menu events for widgets are generated in mouse handling methods.
1127 if (e->reason() != QContextMenuEvent::Keyboard)
1128 return;
1129
1130 QWidget *fw = QWidget::keyboardGrabber();
1131 if (!fw) {
1132 if (QApplication::activePopupWidget()) {
1133 fw = (QApplication::activePopupWidget()->focusWidget()
1134 ? QApplication::activePopupWidget()->focusWidget()
1135 : QApplication::activePopupWidget());
1136 } else if (QApplication::focusWidget()) {
1137 fw = QApplication::focusWidget();
1138 } else {
1139 fw = m_widget;
1140 }
1141 }
1142 if (fw && fw->isEnabled()) {
1143 QPoint pos = fw->inputMethodQuery(Qt::ImCursorRectangle).toRect().center();
1144 QContextMenuEvent widgetEvent(QContextMenuEvent::Keyboard, pos, fw->mapToGlobal(pos),
1145 e->modifiers());
1146 QGuiApplication::forwardEvent(fw, &widgetEvent, e);
1147 }
1148 }
1149 #endif // QT_NO_CONTEXTMENU
1150
updateObjectName()1151 void QWidgetWindow::updateObjectName()
1152 {
1153 QString name = m_widget->objectName();
1154 if (name.isEmpty())
1155 name = QString::fromUtf8(m_widget->metaObject()->className()) + QLatin1String("Class");
1156 name += QLatin1String("Window");
1157 setObjectName(name);
1158 }
1159
1160 QT_END_NAMESPACE
1161
1162 #include "moc_qwidgetwindow_p.cpp"
1163