qwidget.cpp

Go to the documentation of this file.

// Copyright (C) 2017 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qapplication.h"
#include "qapplication_p.h"
#include "qbrush.h"
#include "qcursor.h"
#include "private/qduplicatetracker_p.h"
#include "qevent.h"
#include "qlayout.h"
#if QT_CONFIG(menu)
#include "qmenu.h"
#endif
#include "qmetaobject.h"
#include "qpixmap.h"
#include "qpointer.h"
#include "qstack.h"
#include "qstyle.h"
#include "qstylefactory.h"
#include "qvariant.h"
#include "qwidget.h"
#include "qstyleoption.h"
#include "qstylehints.h"
#if QT_CONFIG(accessibility)
# include "qaccessible.h"
#endif
#include <qpa/qplatformwindow.h>
#include <qpa/qplatformwindow_p.h>
#include "private/qwidgetwindow_p.h"
#include "qpainter.h"
#if QT_CONFIG(tooltip)
#include "qtooltip.h"
#endif
#if QT_CONFIG(whatsthis)
#include "qwhatsthis.h"
#endif
#include "qdebug.h"
#include "private/qstylesheetstyle_p.h"
#include "private/qstyle_p.h"
#include "qfileinfo.h"
#include "qscopeguard.h"
#include <QtGui/private/qhighdpiscaling_p.h>
#include <QtGui/qinputmethod.h>
 
#if QT_CONFIG(graphicseffect)
#include <private/qgraphicseffect_p.h>
#endif
#include <qbackingstore.h>
#include <private/qwidgetrepaintmanager_p.h>
#include <private/qpaintengine_raster_p.h>
 
#include "qwidget_p.h"
#include <QtGui/private/qwindow_p.h>
#if QT_CONFIG(action)
#  include "QtGui/private/qaction_p.h"
#endif
#include "qlayout_p.h"
#if QT_CONFIG(graphicsview)
#include "QtWidgets/qgraphicsproxywidget.h"
#include "QtWidgets/qgraphicsscene.h"
#include "private/qgraphicsproxywidget_p.h"
#endif
#include "QtWidgets/qabstractscrollarea.h"
#include "private/qabstractscrollarea_p.h"
#include "private/qevent_p.h"
 
#include "private/qgesturemanager_p.h"
 
#ifdef QT_KEYPAD_NAVIGATION
#if QT_CONFIG(tabwidget)
#include "qtabwidget.h" // Needed in inTabWidget()
#endif
#endif // QT_KEYPAD_NAVIGATION
 
#include "qwindowcontainer_p.h"
 
#include <sstream>
 
QT_BEGIN_NAMESPACE
 
using namespace QNativeInterface::Private;
using namespace Qt::StringLiterals;
 
Q_LOGGING_CATEGORY(lcWidgetPainting, "qt.widgets.painting", QtWarningMsg);
Q_LOGGING_CATEGORY(lcWidgetShowHide, "qt.widgets.showhide", QtWarningMsg);
Q_STATIC_LOGGING_CATEGORY(lcWidgetWindow, "qt.widgets.window", QtWarningMsg);
Q_STATIC_LOGGING_CATEGORY(lcWidgetFocus, "qt.widgets.focus")
 
#ifndef QT_NO_DEBUG_STREAM
namespace {
    struct WidgetAttributes { const QWidget *widget; };
    QDebug operator<<(QDebug debug, const WidgetAttributes &attributes);
}
#endif
 
static inline bool qRectIntersects(const QRect &r1, const QRect &r2)
{
    return (qMax(r1.left(), r2.left()) <= qMin(r1.right(), r2.right()) &&
            qMax(r1.top(), r2.top()) <= qMin(r1.bottom(), r2.bottom()));
}
 
extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp
 
QWidgetPrivate::QWidgetPrivate(int version)
    : QObjectPrivate(version)
      , focus_next(nullptr)
      , focus_prev(nullptr)
      , focus_child(nullptr)
      , layout(nullptr)
      , needsFlush(nullptr)
      , redirectDev(nullptr)
      , widgetItem(nullptr)
      , extraPaintEngine(nullptr)
      , polished(nullptr)
      , graphicsEffect(nullptr)
#if !defined(QT_NO_IM)
      , imHints(Qt::ImhNone)
#endif
#if QT_CONFIG(tooltip)
      , toolTipDuration(-1)
#endif
      , directFontResolveMask(0)
      , inheritedFontResolveMask(0)
      , directPaletteResolveMask(0)
      , inheritedPaletteResolveMask(0)
      , leftmargin(0)
      , topmargin(0)
      , rightmargin(0)
      , bottommargin(0)
      , leftLayoutItemMargin(0)
      , topLayoutItemMargin(0)
      , rightLayoutItemMargin(0)
      , bottomLayoutItemMargin(0)
      , hd(nullptr)
      , size_policy(QSizePolicy::Preferred, QSizePolicy::Preferred)
      , fg_role(QPalette::NoRole)
      , bg_role(QPalette::NoRole)
      , dirtyOpaqueChildren(1)
      , isOpaque(0)
      , retainSizeWhenHiddenChanged(0)
      , inDirtyList(0)
      , isScrolled(0)
      , isMoved(0)
      , usesDoubleBufferedGLContext(0)
      , mustHaveWindowHandle(0)
      , renderToTexture(0)
      , textureChildSeen(0)
#ifndef QT_NO_IM
      , inheritsInputMethodHints(0)
#endif
      , renderToTextureReallyDirty(1)
      , usesRhiFlush(0)
      , childrenHiddenByWState(0)
      , childrenShownByExpose(0)
#if defined(Q_OS_WIN)
      , noPaintOnScreen(0)
#endif
{
    if (Q_UNLIKELY(!qApp)) {
        qFatal("QWidget: Must construct a QApplication before a QWidget");
        return;
    }
 
#ifdef QT_BUILD_INTERNAL
    // Don't check the version parameter in internal builds.
    // This allows incompatible versions to be loaded, possibly for testing.
    Q_UNUSED(version);
#else
    if (Q_UNLIKELY(version != QObjectPrivateVersion))
        qFatal("Cannot mix incompatible Qt library (version 0x%x) with this library (version 0x%x)",
                version, QObjectPrivateVersion);
#endif
 
    willBeWidget = true; // used in QObject's ctor
    memset(high_attributes, 0, sizeof(high_attributes));
 
#ifdef QWIDGET_EXTRA_DEBUG
    static int count = 0;
    qDebug() << "widgets" << ++count;
#endif
}
 
 
QWidgetPrivate::~QWidgetPrivate()
{
    if (widgetItem)
        widgetItem->wid = nullptr;
 
    if (extra)
        deleteExtra();
}
 
void QWidgetPrivate::scrollChildren(int dx, int dy)
{
    Q_Q(QWidget);
    if (q->children().size() > 0) {        // scroll children
        QPoint pd(dx, dy);
        QObjectList childObjects = q->children();
        for (int i = 0; i < childObjects.size(); ++i) { // move all children
            QWidget *w = qobject_cast<QWidget*>(childObjects.at(i));
            if (w && !w->isWindow()) {
                QPoint oldp = w->pos();
                QRect  r(w->pos() + pd, w->size());
                w->data->crect = r;
                if (w->testAttribute(Qt::WA_WState_Created))
                    w->d_func()->setWSGeometry();
                w->d_func()->setDirtyOpaqueRegion();
                QMoveEvent e(r.topLeft(), oldp);
                QCoreApplication::sendEvent(w, &e);
            }
        }
    }
}
 
void QWidgetPrivate::setWSGeometry()
{
    Q_Q(QWidget);
    if (QWindow *window = q->windowHandle())
        window->setGeometry(data.crect);
}
 
void QWidgetPrivate::updateWidgetTransform(QEvent *event)
{
    Q_Q(QWidget);
    if (q == QGuiApplication::focusObject() || event->type() == QEvent::FocusIn) {
        QTransform t;
        QPoint p = q->mapTo(q->topLevelWidget(), QPoint(0,0));
        t.translate(p.x(), p.y());
        QGuiApplication::inputMethod()->setInputItemTransform(t);
        QGuiApplication::inputMethod()->setInputItemRectangle(q->rect());
        QGuiApplication::inputMethod()->update(Qt::ImInputItemClipRectangle);
    }
}
 
#ifdef QT_KEYPAD_NAVIGATION
QPointer<QWidget> QWidgetPrivate::editingWidget;
 
bool QWidget::hasEditFocus() const
{
    const QWidget* w = this;
    while (w->d_func()->extra && w->d_func()->extra->focus_proxy)
        w = w->d_func()->extra->focus_proxy;
    return QWidgetPrivate::editingWidget == w;
}
 
void QWidget::setEditFocus(bool on)
{
    QWidget *f = this;
    while (f->d_func()->extra && f->d_func()->extra->focus_proxy)
        f = f->d_func()->extra->focus_proxy;
 
    if (QWidgetPrivate::editingWidget && QWidgetPrivate::editingWidget != f)
        QWidgetPrivate::editingWidget->setEditFocus(false);
 
    if (on && !f->hasFocus())
        f->setFocus();
 
    if ((!on && !QWidgetPrivate::editingWidget)
        || (on && QWidgetPrivate::editingWidget == f)) {
        return;
    }
 
    if (!on && QWidgetPrivate::editingWidget == f) {
        QWidgetPrivate::editingWidget = 0;
        QEvent event(QEvent::LeaveEditFocus);
        QCoreApplication::sendEvent(f, &event);
        QCoreApplication::sendEvent(f->style(), &event);
    } else if (on) {
        QWidgetPrivate::editingWidget = f;
        QEvent event(QEvent::EnterEditFocus);
        QCoreApplication::sendEvent(f, &event);
        QCoreApplication::sendEvent(f->style(), &event);
    }
}
#endif
 
bool QWidget::autoFillBackground() const
{
    Q_D(const QWidget);
    return d->extra && d->extra->autoFillBackground;
}
 
void QWidget::setAutoFillBackground(bool enabled)
{
    Q_D(QWidget);
    if (!d->extra)
        d->createExtra();
    if (d->extra->autoFillBackground == enabled)
        return;
 
    d->extra->autoFillBackground = enabled;
    d->updateIsOpaque();
    update();
    d->updateIsOpaque();
}
 
QWidgetMapper *QWidgetPrivate::mapper = nullptr;          // widget with wid
QWidgetSet *QWidgetPrivate::allWidgets = nullptr;         // widgets with no wid
 
 
/*****************************************************************************
  QWidget member functions
 *****************************************************************************/
 
/*
    Widget state flags:
  \list
  \li Qt::WA_WState_Created The widget has a valid winId().
  \li Qt::WA_WState_Visible The widget is currently visible.
  \li Qt::WA_WState_Hidden The widget is hidden, i.e. it won't
  become visible unless you call show() on it. Qt::WA_WState_Hidden
  implies !Qt::WA_WState_Visible.
  \li Qt::WA_WState_CompressKeys Compress keyboard events.
  \li Qt::WA_WState_BlockUpdates Repaints and updates are disabled.
  \li Qt::WA_WState_InPaintEvent Currently processing a paint event.
  \li Qt::WA_WState_Reparented The widget has been reparented.
  \li Qt::WA_WState_ConfigPending A configuration (resize/move) event is pending.
  \endlist
*/
 
struct QWidgetExceptionCleaner
{
    /* this cleans up when the constructor throws an exception */
    static inline void cleanup(QWidget *that, QWidgetPrivate *d)
    {
#ifdef QT_NO_EXCEPTIONS
        Q_UNUSED(that);
        Q_UNUSED(d);
#else
        QWidgetPrivate::allWidgets->remove(that);
        d->removeFromFocusChain();
#endif
    }
};
 
QWidget::QWidget(QWidget *parent, Qt::WindowFlags f)
    : QObject(*new QWidgetPrivate, nullptr), QPaintDevice()
{
    QT_TRY {
        d_func()->init(parent, f);
    } QT_CATCH(...) {
        QWidgetExceptionCleaner::cleanup(this, d_func());
        QT_RETHROW;
    }
}
 
 
QWidget::QWidget(QWidgetPrivate &dd, QWidget* parent, Qt::WindowFlags f)
    : QObject(dd, nullptr), QPaintDevice()
{
    Q_D(QWidget);
    QT_TRY {
        d->init(parent, f);
    } QT_CATCH(...) {
        QWidgetExceptionCleaner::cleanup(this, d_func());
        QT_RETHROW;
    }
}
 
int QWidget::devType() const
{
    return QInternal::Widget;
}
 
 
//### w is a "this" ptr, passed as a param because QWorkspace needs special logic
void QWidgetPrivate::adjustFlags(Qt::WindowFlags &flags, QWidget *w)
{
    bool customize =  (flags & (Qt::CustomizeWindowHint
            | Qt::FramelessWindowHint
            | Qt::WindowTitleHint
            | Qt::WindowSystemMenuHint
            | Qt::WindowMinimizeButtonHint
            | Qt::WindowMaximizeButtonHint
            | Qt::WindowCloseButtonHint
            | Qt::WindowContextHelpButtonHint));
 
    uint type = (flags & Qt::WindowType_Mask);
 
    if ((type == Qt::Widget || type == Qt::SubWindow) && w && !w->parent()) {
        type = Qt::Window;
        flags |= Qt::Window;
    }
 
    if (flags & Qt::CustomizeWindowHint) {
        // modify window flags to make them consistent.
        // Only enable this on non-Mac platforms. Since the old way of doing this would
        // interpret WindowSystemMenuHint as a close button and we can't change that behavior
        // we can't just add this in.
        if ((flags & (Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint | Qt::WindowContextHelpButtonHint))
#  ifdef Q_OS_WIN
            && type != Qt::Dialog // QTBUG-2027, allow for menu-less dialogs.
#  endif
           ) {
            flags |= Qt::WindowSystemMenuHint;
            flags |= Qt::WindowTitleHint;
            flags &= ~Qt::FramelessWindowHint;
        }
    } else if (customize && !(flags & Qt::FramelessWindowHint)) {
        // if any of the window hints that affect the titlebar are set
        // and the window is supposed to have frame, we add a titlebar
        // and system menu by default.
        flags |= Qt::WindowSystemMenuHint;
        flags |= Qt::WindowTitleHint;
    }
    if (!customize) { // don't modify window flags if the user explicitly set them.
        flags |= Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint;
        if (type != Qt::Dialog && type != Qt::Sheet && type != Qt::Tool)
            flags |= Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint | Qt::WindowFullscreenButtonHint;
    }
    if (w->testAttribute(Qt::WA_TransparentForMouseEvents))
        flags |= Qt::WindowTransparentForInput;
}
 
void QWidgetPrivate::init(QWidget *parentWidget, Qt::WindowFlags f)
{
    Q_Q(QWidget);
    isWidget = true;
    wasWidget = true;
 
    Q_ASSERT_X(q != parentWidget, Q_FUNC_INFO, "Cannot parent a QWidget to itself");
 
    if (Q_UNLIKELY(!qobject_cast<QApplication *>(QCoreApplication::instance())))
        qFatal("QWidget: Cannot create a QWidget without QApplication");
 
    Q_ASSERT(allWidgets);
    if (allWidgets)
        allWidgets->insert(q);
 
    q->data = &data;
 
#if QT_CONFIG(thread)
    if (!parent) {
        Q_ASSERT_X(q->thread() == qApp->thread(), "QWidget",
                   "Widgets must be created in the GUI thread.");
    }
#endif
 
    data.fstrut_dirty = true;
 
    data.winid = 0;
    data.widget_attributes = 0;
    data.window_flags = f;
    data.window_state = 0;
    data.focus_policy = 0;
    data.context_menu_policy = Qt::DefaultContextMenu;
    data.window_modality = Qt::NonModal;
 
    data.sizehint_forced = 0;
    data.is_closing = false;
    data.in_show = 0;
    data.in_set_window_state = 0;
    data.in_destructor = false;
 
    // Widgets with Qt::MSWindowsOwnDC (typically QGLWidget) must have a window handle.
    if (f & Qt::MSWindowsOwnDC) {
        mustHaveWindowHandle = 1;
        q->setAttribute(Qt::WA_NativeWindow);
    }
 
    q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()
    adjustQuitOnCloseAttribute();
 
    q->setAttribute(Qt::WA_ContentsMarginsRespectsSafeArea);
    q->setAttribute(Qt::WA_WState_Hidden);
 
    //give potential windows a bigger "pre-initial" size; create() will give them a new size later
    data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,640,480);
    initFocusChain();
 
    if ((f & Qt::WindowType_Mask) == Qt::Desktop)
        q->create();
    else if (parentWidget)
        q->setParent(parentWidget, data.window_flags);
    else {
        adjustFlags(data.window_flags, q);
        resolveLayoutDirection();
        // opaque system background?
        const QBrush &background = q->palette().brush(QPalette::Window);
        setOpaque(q->isWindow() && background.style() != Qt::NoBrush && background.isOpaque());
    }
    data.fnt = QFont(data.fnt, q);
 
    q->setAttribute(Qt::WA_PendingMoveEvent);
    q->setAttribute(Qt::WA_PendingResizeEvent);
 
    if (++QWidgetPrivate::instanceCounter > QWidgetPrivate::maxInstances)
        QWidgetPrivate::maxInstances = QWidgetPrivate::instanceCounter;
 
    QEvent e(QEvent::Create);
    QCoreApplication::sendEvent(q, &e);
    QCoreApplication::postEvent(q, new QEvent(QEvent::PolishRequest));
 
    extraPaintEngine = nullptr;
}
 
void QWidgetPrivate::createRecursively()
{
    Q_Q(QWidget);
    q->create(0, true, true);
    for (int i = 0; i < children.size(); ++i) {
        QWidget *child = qobject_cast<QWidget *>(children.at(i));
        if (child && !child->isHidden() && !child->isWindow() && !child->testAttribute(Qt::WA_WState_Created))
            child->d_func()->createRecursively();
    }
}
 
QRhi *QWidgetPrivate::rhi() const
{
    Q_Q(const QWidget);
    if (auto *backingStore = q->backingStore()) {
        auto *window = windowHandle(WindowHandleMode::Closest);
        return backingStore->handle()->rhi(window);
    } else {
        return nullptr;
    }
}
 
QWidget *QWidgetPrivate::closestParentWidgetWithWindowHandle() const
{
    Q_Q(const QWidget);
    QWidget *parent = q->parentWidget();
    while (parent && !parent->windowHandle())
        parent = parent->parentWidget();
    return parent;
}
 
QWindow *QWidgetPrivate::windowHandle(WindowHandleMode mode) const
{
    if (mode == WindowHandleMode::Direct || mode == WindowHandleMode::Closest) {
        if (QTLWExtra *x = maybeTopData()) {
            if (x->window != nullptr || mode == WindowHandleMode::Direct)
                return x->window;
        }
    }
    if (mode == WindowHandleMode::Closest) {
        // FIXME: Use closestParentWidgetWithWindowHandle instead
        if (auto nativeParent = q_func()->nativeParentWidget()) {
            if (auto window = nativeParent->windowHandle())
                return window;
        }
    }
    if (mode == WindowHandleMode::TopLevel || mode == WindowHandleMode::Closest) {
        if (auto topLevel = q_func()->topLevelWidget()) {
            if (auto window = topLevel ->windowHandle())
                return window;
        }
    }
    return nullptr;
}
 
QWindow *QWidgetPrivate::_q_closestWindowHandle() const
{
    return windowHandle(QWidgetPrivate::WindowHandleMode::Closest);
}
 
QScreen *QWidgetPrivate::associatedScreen() const
{
#if QT_CONFIG(graphicsview)
    // embedded widgets never have a screen associated, let QWidget::screen fall back to toplevel
    if (nearestGraphicsProxyWidget(q_func()))
        return nullptr;
#endif
    if (auto window = windowHandle(WindowHandleMode::Closest))
        return window->screen();
    return nullptr;
}
 
// finds the first rhiconfig in the hierarchy that has enable==true
static bool q_evaluateRhiConfigRecursive(const QWidget *w, QPlatformBackingStoreRhiConfig *outConfig, QSurface::SurfaceType *outType)
{
    QPlatformBackingStoreRhiConfig config = QWidgetPrivate::get(w)->rhiConfig();
    if (config.isEnabled()) {
        if (outConfig)
            *outConfig = config;
        if (outType)
            *outType = QBackingStoreRhiSupport::surfaceTypeForConfig(config);
        return true;
    }
    for (const QObject *child : w->children()) {
        if (const QWidget *childWidget = qobject_cast<const QWidget *>(child)) {
            if (q_evaluateRhiConfigRecursive(childWidget, outConfig, outType)) {
                static bool optOut = qEnvironmentVariableIsSet("QT_WIDGETS_NO_CHILD_RHI");
                // Native child widgets should not trigger RHI for its parent
                // hierarchy, but will still flush the native child using RHI.
                if (!optOut && childWidget->testAttribute(Qt::WA_NativeWindow))
                    continue;
 
                return true;
            }
        }
    }
    return false;
}
 
bool q_evaluateRhiConfig(const QWidget *w, QPlatformBackingStoreRhiConfig *outConfig, QSurface::SurfaceType *outType)
{
    // First, check env.vars. or other means that force the usage of rhi-based
    // flushing with a specific graphics API. This takes precedence over what
    // the widgets themselves declare. This is global, applying to all
    // top-levels.
    if (QBackingStoreRhiSupport::checkForceRhi(outConfig, outType)) {
        qCDebug(lcWidgetPainting) << "Tree with root" << w << "evaluated to forced flushing with QRhi";
        return true;
    }
 
    // Otherwise, check the widget hierarchy to see if there is a child (or
    // ourselves) that declare the need for rhi-based composition.
    if (q_evaluateRhiConfigRecursive(w, outConfig, outType)) {
        qCDebug(lcWidgetPainting) << "Tree with root" << w << "evaluates to flushing with QRhi";
        return true;
    }
 
    return false;
}
 
// ### fixme: Qt 6: Remove parameter window from QWidget::create()
 
void QWidget::create(WId window, bool initializeWindow, bool destroyOldWindow)
{
    Q_UNUSED(initializeWindow);
    Q_UNUSED(destroyOldWindow);
 
    Q_D(QWidget);
    if (Q_UNLIKELY(window))
        qWarning("QWidget::create(): Parameter 'window' does not have any effect.");
    if (testAttribute(Qt::WA_WState_Created) && window == 0 && internalWinId())
        return;
 
    if (d->data.in_destructor)
        return;
 
    Qt::WindowType type = windowType();
    Qt::WindowFlags &flags = data->window_flags;
 
    if ((type == Qt::Widget || type == Qt::SubWindow) && !parentWidget()) {
        type = Qt::Window;
        flags |= Qt::Window;
    }
 
    if (QWidget *parent = parentWidget()) {
        if (type & Qt::Window) {
            if (!parent->testAttribute(Qt::WA_WState_Created))
                parent->createWinId();
        } else if (testAttribute(Qt::WA_NativeWindow) && !parent->internalWinId()
                   && !testAttribute(Qt::WA_DontCreateNativeAncestors)) {
            // We're about to create a native child widget that doesn't have a native parent;
            // enforce a native handle for the parent unless the Qt::WA_DontCreateNativeAncestors
            // attribute is set.
            d->createWinId();
            // Nothing more to do.
            Q_ASSERT(testAttribute(Qt::WA_WState_Created));
            Q_ASSERT(internalWinId());
            return;
        }
    }
 
 
    static const bool paintOnScreenEnv = qEnvironmentVariableIntValue("QT_ONSCREEN_PAINT") > 0;
    if (paintOnScreenEnv)
        setAttribute(Qt::WA_PaintOnScreen);
 
    if (QApplicationPrivate::testAttribute(Qt::AA_NativeWindows))
        setAttribute(Qt::WA_NativeWindow);
 
    d->updateIsOpaque();
 
    setAttribute(Qt::WA_WState_Created);                        // set created flag
    d->create();
 
    // A real toplevel window needs a paint manager
    if (isWindow() && windowType() != Qt::Desktop)
        d->topData()->repaintManager.reset(new QWidgetRepaintManager(this));
 
    d->setModal_sys();
 
    if (!isWindow() && parentWidget() && parentWidget()->testAttribute(Qt::WA_DropSiteRegistered))
        setAttribute(Qt::WA_DropSiteRegistered, true);
 
    // need to force the resting of the icon after changing parents
    if (testAttribute(Qt::WA_SetWindowIcon))
        d->setWindowIcon_sys();
 
    if (isWindow() && !d->topData()->iconText.isEmpty())
        d->setWindowIconText_helper(d->topData()->iconText);
    if (isWindow() && !d->topData()->caption.isEmpty())
        d->setWindowTitle_helper(d->topData()->caption);
    if (isWindow() && !d->topData()->filePath.isEmpty())
        d->setWindowFilePath_helper(d->topData()->filePath);
    if (windowType() != Qt::Desktop) {
        d->updateSystemBackground();
 
        if (isWindow() && !testAttribute(Qt::WA_SetWindowIcon))
            d->setWindowIcon_sys();
    }
 
    // Frame strut update needed in cases where there are native widgets such as QGLWidget,
    // as those force native window creation on their ancestors before they are shown.
    // If the strut is not updated, any subsequent move of the top level window before show
    // will cause window frame to be ignored when positioning the window.
    // Note that this only helps on platforms that handle window creation synchronously.
    d->updateFrameStrut();
}
 
void q_createNativeChildrenAndSetParent(const QWidget *parentWidget)
{
    QObjectList children = parentWidget->children();
    for (int i = 0; i < children.size(); i++) {
        if (children.at(i)->isWidgetType()) {
            const QWidget *childWidget = qobject_cast<const QWidget *>(children.at(i));
            if (childWidget) { // should not be necessary
                if (childWidget->testAttribute(Qt::WA_NativeWindow)) {
                    if (!childWidget->internalWinId())
                        childWidget->winId();
                    if (childWidget->windowHandle()) {
                        if (childWidget->isWindow()) {
                            childWidget->windowHandle()->setTransientParent(parentWidget->window()->windowHandle());
                        } else {
                            childWidget->windowHandle()->setParent(childWidget->nativeParentWidget()->windowHandle());
                        }
                    }
                } else {
                    q_createNativeChildrenAndSetParent(childWidget);
                }
            }
        }
    }
 
}
 
void QWidgetPrivate::create()
{
    Q_Q(QWidget);
 
    if (!q->testAttribute(Qt::WA_NativeWindow) && !q->isWindow())
        return; // we only care about real toplevels
 
    QWidgetWindow *win = topData()->window;
    // topData() ensures the extra is created but does not ensure 'window' is non-null
    // in case the extra was already valid.
    if (!win) {
        createTLSysExtra();
        Q_ASSERT(topData()->window);
        win = topData()->window;
    }
 
    const auto dynamicPropertyNames = q->dynamicPropertyNames();
    for (const QByteArray &propertyName : dynamicPropertyNames) {
        if (!qstrncmp(propertyName, "_q_platform_", 12))
            win->setProperty(propertyName, q->property(propertyName));
    }
 
    Qt::WindowFlags &flags = data.window_flags;
 
#if defined(QT_PLATFORM_UIKIT)
    if (q->testAttribute(Qt::WA_ContentsMarginsRespectsSafeArea))
        flags |= Qt::MaximizeUsingFullscreenGeometryHint;
#endif
 
    if (q->testAttribute(Qt::WA_ShowWithoutActivating))
        win->setProperty("_q_showWithoutActivating", QVariant(true));
    if (q->testAttribute(Qt::WA_MacAlwaysShowToolWindow))
        win->setProperty("_q_macAlwaysShowToolWindow", QVariant(true));
    win->setFlags(flags);
    fixPosIncludesFrame();
    if (q->testAttribute(Qt::WA_Moved)
        || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::WindowManagement))
        win->setGeometry(q->geometry());
    else
        win->resize(q->size());
    if (win->isTopLevel()) {
        QScreen *targetScreen = topData()->initialScreen;
        topData()->initialScreen = nullptr;
        if (!targetScreen) {
            targetScreen = q->windowType() != Qt::Desktop
                ? q->screen() : nullptr;
        }
        win->setScreen(targetScreen);
    }
 
    QSurfaceFormat format = win->requestedFormat();
    if ((flags & Qt::Window) && win->surfaceType() != QSurface::OpenGLSurface
            && q->testAttribute(Qt::WA_TranslucentBackground)) {
        format.setAlphaBufferSize(8);
    }
    win->setFormat(format);
 
    if (QWidget *nativeParent = q->nativeParentWidget()) {
        if (nativeParent->windowHandle()) {
            if (flags & Qt::Window) {
                win->setTransientParent(nativeParent->window()->windowHandle());
                win->setParent(nullptr);
            } else {
                win->setTransientParent(nullptr);
                win->setParent(nativeParent->windowHandle());
            }
        }
    }
 
    qt_window_private(win)->positionPolicy = topData()->posIncludesFrame ?
        QWindowPrivate::WindowFrameInclusive : QWindowPrivate::WindowFrameExclusive;
 
    if (q->windowType() != Qt::Desktop || q->testAttribute(Qt::WA_NativeWindow)) {
        win->create();
        // Enable nonclient-area events for QDockWidget and other NonClientArea-mouse event processing.
        if (QPlatformWindow *platformWindow = win->handle())
            platformWindow->setFrameStrutEventsEnabled(true);
    }
 
    data.window_flags = win->flags();
 
#if QT_CONFIG(xcb)
    if (!topData()->role.isNull()) {
        if (auto *xcbWindow = dynamic_cast<QXcbWindow*>(win->handle()))
            xcbWindow->setWindowRole(topData()->role);
    }
#endif
 
    QBackingStore *store = q->backingStore();
    usesRhiFlush = false;
 
    if (q->windowType() == Qt::Desktop) {
        q->setAttribute(Qt::WA_PaintOnScreen, true);
    } else {
        if (!store && q->isWindow())
            q->setBackingStore(new QBackingStore(win));
 
        QPlatformBackingStoreRhiConfig rhiConfig;
        usesRhiFlush = q_evaluateRhiConfig(q, &rhiConfig, nullptr);
        if (usesRhiFlush && q->backingStore()) {
            // Trigger creation of support infrastructure up front,
            // now that we have a specific RHI configuration.
            q->backingStore()->handle()->createRhi(win, rhiConfig);
        }
    }
 
    setWindowModified_helper();
 
    if (win->handle()) {
        WId id = win->winId();
        // See the QPlatformWindow::winId() documentation
        Q_ASSERT(id != WId(0));
        setWinId(id);
    }
    setNetWmWindowTypes(true); // do nothing if none of WA_X11NetWmWindowType* is set
 
    // Check children and create windows for them if necessary
    q_createNativeChildrenAndSetParent(q);
 
    if (extra && !extra->mask.isEmpty())
        setMask_sys(extra->mask);
 
    if (data.crect.width() == 0 || data.crect.height() == 0) {
        q->setAttribute(Qt::WA_OutsideWSRange, true);
    } else if (q->isVisible()) {
        // If widget is already shown, set window visible, too
        win->setNativeWindowVisibility(true);
    }
}
 
#ifdef Q_OS_WIN
static const char activeXNativeParentHandleProperty[] = "_q_embedded_native_parent_handle";
#endif
 
void QWidgetPrivate::createTLSysExtra()
{
    Q_Q(QWidget);
    if (!extra->topextra->window && (q->testAttribute(Qt::WA_NativeWindow) || q->isWindow())) {
        extra->topextra->window = new QWidgetWindow(q);
        if (extra->minw || extra->minh)
            extra->topextra->window->setMinimumSize(QSize(extra->minw, extra->minh));
        if (extra->maxw != QWIDGETSIZE_MAX || extra->maxh != QWIDGETSIZE_MAX)
            extra->topextra->window->setMaximumSize(QSize(extra->maxw, extra->maxh));
        if (extra->topextra->opacity != 255 && q->isWindow())
            extra->topextra->window->setOpacity(qreal(extra->topextra->opacity) / qreal(255));
 
        const bool isTipLabel = q->inherits("QTipLabel");
        const bool isAlphaWidget = !isTipLabel && q->inherits("QAlphaWidget");
#ifdef Q_OS_WIN
        // Pass on native parent handle for Widget embedded into Active X.
        const QVariant activeXNativeParentHandle = q->property(activeXNativeParentHandleProperty);
        if (activeXNativeParentHandle.isValid())
            extra->topextra->window->setProperty(activeXNativeParentHandleProperty, activeXNativeParentHandle);
        if (isTipLabel || isAlphaWidget)
            extra->topextra->window->setProperty("_q_windowsDropShadow", QVariant(true));
#endif
        if (isTipLabel || isAlphaWidget || q->inherits("QRollEffect"))
            qt_window_private(extra->topextra->window)->setAutomaticPositionAndResizeEnabled(false);
 
        updateIsTranslucent();
    }
 
}
 
QWidget::~QWidget()
{
    Q_D(QWidget);
    d->data.in_destructor = true;
 
#if defined (QT_CHECK_STATE)
    if (Q_UNLIKELY(paintingActive()))
        qWarning("QWidget: %s (%s) deleted while being painted", className(), name());
#endif
 
#ifndef QT_NO_GESTURES
    if (QGestureManager *manager = QGestureManager::instance(QGestureManager::DontForceCreation)) {
        // \forall Qt::GestureType type : ungrabGesture(type) (inlined)
        for (auto it = d->gestureContext.keyBegin(), end = d->gestureContext.keyEnd(); it != end; ++it)
            manager->cleanupCachedGestures(this, *it);
    }
    d->gestureContext.clear();
#endif
 
#ifndef QT_NO_ACTION
    // remove all actions from this widget
    for (auto action : std::as_const(d->actions)) {
        QActionPrivate *apriv = action->d_func();
        apriv->associatedObjects.removeAll(this);
    }
    d->actions.clear();
#endif
 
#ifndef QT_NO_SHORTCUT
    // Remove all shortcuts grabbed by this
    // widget, unless application is closing
    if (!QApplicationPrivate::is_app_closing && testAttribute(Qt::WA_GrabbedShortcut))
        QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(0, this, QKeySequence());
#endif
 
    // delete layout while we still are a valid widget
    delete d->layout;
    d->layout = nullptr;
 
    // Remove this from focus list
    d->removeFromFocusChain(QWidgetPrivate::FocusChainRemovalRule::AssertConsistency);
 
    QT_TRY {
#if QT_CONFIG(graphicsview)
        const QWidget* w = this;
        while (w->d_func()->extra && w->d_func()->extra->focus_proxy)
            w = w->d_func()->extra->focus_proxy;
        QWidget *window = w->window();
        QWExtra *e = window ? window->d_func()->extra.get() : nullptr ;
        if (!e || !e->proxyWidget || (w->parentWidget() && w->parentWidget()->d_func()->focus_child == this))
#endif
        clearFocus();
    } QT_CATCH(...) {
        // swallow this problem because we are in a destructor
    }
 
    d->setDirtyOpaqueRegion();
 
    if (isWindow() && isVisible() && internalWinId()) {
        QT_TRY {
            d->close();
        } QT_CATCH(...) {
            // if we're out of memory, at least hide the window.
            QT_TRY {
                hide();
            } QT_CATCH(...) {
                // and if that also doesn't work, then give up
            }
        }
    } else if (isVisible()) {
        qApp->d_func()->sendSyntheticEnterLeave(this);
    }
 
    if (QWidgetRepaintManager *repaintManager = d->maybeRepaintManager()) {
        repaintManager->removeDirtyWidget(this);
        if (testAttribute(Qt::WA_StaticContents))
            repaintManager->removeStaticWidget(this);
    }
 
    delete d->needsFlush;
    d->needsFlush = nullptr;
 
    // The next 20 lines are duplicated from QObject, but required here
    // since QWidget deletes is children itself
    bool blocked = d->blockSig;
    d->blockSig = 0; // unblock signals so we always emit destroyed()
 
    if (d->isSignalConnected(0)) {
        QT_TRY {
            emit destroyed(this);
        } QT_CATCH(...) {
            // all the signal/slots connections are still in place - if we don't
            // quit now, we will crash pretty soon.
            qWarning("Detected an unexpected exception in ~QWidget while emitting destroyed().");
            QT_RETHROW;
        }
    }
 
    if (d->declarativeData) {
        d->wasDeleted = true; // needed, so that destroying the declarative data does the right thing
        if (QAbstractDeclarativeData::destroyed)
            QAbstractDeclarativeData::destroyed(d->declarativeData, this);
        d->declarativeData = nullptr;                 // don't activate again in ~QObject
        d->wasDeleted = false;
    }
 
    d->blockSig = blocked;
 
    if (!d->children.isEmpty())
        d->deleteChildren();
 
    QCoreApplication::removePostedEvents(this);
 
    QT_TRY {
        destroy();                                        // platform-dependent cleanup
    } QT_CATCH(...) {
        // if this fails we can't do anything about it but at least we are not allowed to throw.
    }
    --QWidgetPrivate::instanceCounter;
 
    if (QWidgetPrivate::allWidgets) // might have been deleted by ~QApplication
        QWidgetPrivate::allWidgets->remove(this);
 
    QT_TRY {
        QEvent e(QEvent::Destroy);
        QCoreApplication::sendEvent(this, &e);
    } QT_CATCH(const std::exception&) {
        // if this fails we can't do anything about it but at least we are not allowed to throw.
    }
 
#if QT_CONFIG(graphicseffect)
    delete d->graphicsEffect;
#endif
 
    d->isWidget = false;
}
 
int QWidgetPrivate::instanceCounter = 0;  // Current number of widget instances
int QWidgetPrivate::maxInstances = 0;     // Maximum number of widget instances
 
void QWidgetPrivate::setWinId(WId id)                // set widget identifier
{
    Q_Q(QWidget);
    if (mapper && data.winid) {
        mapper->remove(data.winid);
    }
 
    const WId oldWinId = data.winid;
 
    data.winid = id;
    if (mapper && id) {
        mapper->insert(data.winid, q);
    }
 
    if (oldWinId != id) {
        QEvent e(QEvent::WinIdChange);
        QCoreApplication::sendEvent(q, &e);
    }
}
 
void QWidgetPrivate::createTLExtra()
{
    if (!extra)
        createExtra();
    if (!extra->topextra) {
        extra->topextra = std::make_unique<QTLWExtra>();
        QTLWExtra* x = extra->topextra.get();
        x->backingStore = nullptr;
        x->sharedPainter = nullptr;
        x->incw = x->inch = 0;
        x->basew = x->baseh = 0;
        x->frameStrut.setCoords(0, 0, 0, 0);
        x->normalGeometry = QRect(0,0,-1,-1);
        x->savedFlags = { };
        x->opacity = 255;
        x->posIncludesFrame = 0;
        x->sizeAdjusted = false;
        x->embedded = 0;
        x->window = nullptr;
        x->initialScreen = nullptr;
 
#ifdef QWIDGET_EXTRA_DEBUG
        static int count = 0;
        qDebug() << "tlextra" << ++count;
#endif
    }
}
 
void QWidgetPrivate::createExtra()
{
    if (!extra) {                                // if not exists
        extra = std::make_unique<QWExtra>();
        extra->glContext = nullptr;
#if QT_CONFIG(graphicsview)
        extra->proxyWidget = nullptr;
#endif
        extra->minw = 0;
        extra->minh = 0;
        extra->maxw = QWIDGETSIZE_MAX;
        extra->maxh = QWIDGETSIZE_MAX;
        extra->customDpiX = 0;
        extra->customDpiY = 0;
        extra->explicitMinSize = 0;
        extra->explicitMaxSize = 0;
        extra->autoFillBackground = 0;
        extra->nativeChildrenForced = 0;
        extra->inRenderWithPainter = 0;
        extra->hasWindowContainer = false;
        extra->hasMask = 0;
        createSysExtra();
#ifdef QWIDGET_EXTRA_DEBUG
        static int count = 0;
        qDebug() << "extra" << ++count;
#endif
    }
}
 
void QWidgetPrivate::createSysExtra()
{
}
 
void QWidgetPrivate::deleteExtra()
{
    if (extra) {                                // if exists
        deleteSysExtra();
#ifndef QT_NO_STYLE_STYLESHEET
        // dereference the stylesheet style
        if (QStyleSheetStyle *proxy = qt_styleSheet(extra->style))
            proxy->deref();
#endif
        if (extra->topextra)
            deleteTLSysExtra();
 
        // extra->xic destroyed in QWidget::destroy()
        extra.reset();
    }
}
 
void QWidgetPrivate::deleteSysExtra()
{
}
 
void QWidgetPrivate::deleteTLSysExtra()
{
    Q_Q(QWidget);
    if (extra && extra->topextra) {
        if (extra->hasWindowContainer)
            QWindowContainer::toplevelAboutToBeDestroyed(q);
 
        delete extra->topextra->window;
        extra->topextra->window = nullptr;
    }
}
 
/*
  Returns \c region of widgets above this which overlap with
  \a rect, which is in parent's coordinate system (same as crect).
*/
 
QRegion QWidgetPrivate::overlappedRegion(const QRect &rect, bool breakAfterFirst) const
{
    Q_Q(const QWidget);
 
    const QWidget *w = q;
    QRect r = rect;
    QPoint p;
    QRegion region;
    while (w) {
        if (w->isWindow())
            break;
        QWidgetPrivate *pd = w->parentWidget()->d_func();
        bool above = false;
        for (int i = 0; i < pd->children.size(); ++i) {
            QWidget *sibling = qobject_cast<QWidget *>(pd->children.at(i));
            if (!sibling || !sibling->isVisible() || sibling->isWindow())
                continue;
            if (!above) {
                above = (sibling == w);
                continue;
            }
 
            const QRect siblingRect = sibling->d_func()->effectiveRectFor(sibling->data->crect);
            if (qRectIntersects(siblingRect, r)) {
                const auto &siblingExtra = sibling->d_func()->extra;
                if (siblingExtra && siblingExtra->hasMask && !sibling->d_func()->graphicsEffect
                    && !siblingExtra->mask.translated(sibling->data->crect.topLeft()).intersects(r)) {
                    continue;
                }
                region += siblingRect.translated(-p);
                if (breakAfterFirst)
                    break;
            }
        }
        w = w->parentWidget();
        r.translate(pd->data.crect.topLeft());
        p += pd->data.crect.topLeft();
    }
    return region;
}
 
void QWidgetPrivate::syncBackingStore()
{
    if (shouldPaintOnScreen()) {
        paintOnScreen(dirty);
        dirty = QRegion();
    } else if (QWidgetRepaintManager *repaintManager = maybeRepaintManager()) {
        repaintManager->sync();
    }
}
 
void QWidgetPrivate::syncBackingStore(const QRegion &region)
{
    if (shouldPaintOnScreen())
        paintOnScreen(region);
    else if (QWidgetRepaintManager *repaintManager = maybeRepaintManager()) {
        repaintManager->sync(q_func(), region);
    }
}
 
void QWidgetPrivate::paintOnScreen(const QRegion &rgn)
{
    if (data.in_destructor)
        return;
 
    if (shouldDiscardSyncRequest())
        return;
 
    Q_Q(QWidget);
    if (q->testAttribute(Qt::WA_StaticContents)) {
        if (!extra)
            createExtra();
        extra->staticContentsSize = data.crect.size();
    }
 
    QPaintEngine *engine = q->paintEngine();
 
    // QGLWidget does not support partial updates if:
    // 1) The context is double buffered
    // 2) The context is single buffered and auto-fill background is enabled.
    const bool noPartialUpdateSupport = (engine && (engine->type() == QPaintEngine::OpenGL
                                                || engine->type() == QPaintEngine::OpenGL2))
                                        && (usesDoubleBufferedGLContext || q->autoFillBackground());
    QRegion toBePainted(noPartialUpdateSupport ? q->rect() : rgn);
 
    toBePainted &= clipRect();
    clipToEffectiveMask(toBePainted);
    if (toBePainted.isEmpty())
        return; // Nothing to repaint.
 
    drawWidget(q, toBePainted, QPoint(), QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawPaintOnScreen, nullptr);
 
    if (Q_UNLIKELY(q->paintingActive()))
        qWarning("QWidget::repaint: It is dangerous to leave painters active on a widget outside of the PaintEvent");
}
 
void QWidgetPrivate::setUpdatesEnabled_helper(bool enable)
{
    Q_Q(QWidget);
 
    if (enable && !q->isWindow() && q->parentWidget() && !q->parentWidget()->updatesEnabled())
        return; // nothing we can do
 
    if (enable != q->testAttribute(Qt::WA_UpdatesDisabled))
        return; // nothing to do
 
    q->setAttribute(Qt::WA_UpdatesDisabled, !enable);
    if (enable)
        q->update();
 
    Qt::WidgetAttribute attribute = enable ? Qt::WA_ForceUpdatesDisabled : Qt::WA_UpdatesDisabled;
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(children.at(i));
        if (w && !w->isWindow() && !w->testAttribute(attribute))
            w->d_func()->setUpdatesEnabled_helper(enable);
    }
}
 
void QWidgetPrivate::propagatePaletteChange()
{
    Q_Q(QWidget);
    // Propagate a new inherited mask to all children.
#if QT_CONFIG(graphicsview)
    if (!q->parentWidget() && extra && extra->proxyWidget) {
        QGraphicsProxyWidget *p = extra->proxyWidget;
        inheritedPaletteResolveMask = p->d_func()->inheritedPaletteResolveMask | p->palette().resolveMask();
    } else
#endif // QT_CONFIG(graphicsview)
        if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
        inheritedPaletteResolveMask = 0;
    }
 
    directPaletteResolveMask = data.pal.resolveMask();
    auto mask = directPaletteResolveMask | inheritedPaletteResolveMask;
 
    const bool useStyleSheetPropagationInWidgetStyles =
        QCoreApplication::testAttribute(Qt::AA_UseStyleSheetPropagationInWidgetStyles);
 
    QEvent pc(QEvent::PaletteChange);
    QCoreApplication::sendEvent(q, &pc);
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget*>(children.at(i));
        if (w && (!w->testAttribute(Qt::WA_StyleSheet) || useStyleSheetPropagationInWidgetStyles)
            && (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))) {
            QWidgetPrivate *wd = w->d_func();
            wd->inheritedPaletteResolveMask = mask;
            wd->resolvePalette();
        }
    }
}
 
/*
  Returns the widget's clipping rectangle.
*/
QRect QWidgetPrivate::clipRect() const
{
    Q_Q(const QWidget);
    const QWidget * w = q;
    if (!w->isVisible())
        return QRect();
    QRect r = effectiveRectFor(q->rect());
    int ox = 0;
    int oy = 0;
    while (w
            && w->isVisible()
            && !w->isWindow()
            && w->parentWidget()) {
        ox -= w->x();
        oy -= w->y();
        w = w->parentWidget();
        r &= QRect(ox, oy, w->width(), w->height());
    }
    return r;
}
 
/*
  Returns the widget's clipping region (without siblings).
*/
QRegion QWidgetPrivate::clipRegion() const
{
    Q_Q(const QWidget);
    if (!q->isVisible())
        return QRegion();
    QRegion r(q->rect());
    const QWidget * w = q;
    const QWidget *ignoreUpTo;
    int ox = 0;
    int oy = 0;
    while (w
           && w->isVisible()
           && !w->isWindow()
           && w->parentWidget()) {
        ox -= w->x();
        oy -= w->y();
        ignoreUpTo = w;
        w = w->parentWidget();
        r &= QRegion(ox, oy, w->width(), w->height());
 
        int i = 0;
        while(w->d_func()->children.at(i++) != static_cast<const QObject *>(ignoreUpTo))
            ;
        for ( ; i < w->d_func()->children.size(); ++i) {
            if (QWidget *sibling = qobject_cast<QWidget *>(w->d_func()->children.at(i))) {
                if (sibling->isVisible() && !sibling->isWindow()) {
                    QRect siblingRect(ox+sibling->x(), oy+sibling->y(),
                                      sibling->width(), sibling->height());
                    if (qRectIntersects(siblingRect, q->rect()))
                        r -= QRegion(siblingRect);
                }
            }
        }
    }
    return r;
}
 
void QWidgetPrivate::setSystemClip(QPaintEngine *paintEngine, qreal devicePixelRatio, const QRegion &region)
{
// Transform the system clip region from device-independent pixels to device pixels
    QTransform scaleTransform;
    scaleTransform.scale(devicePixelRatio, devicePixelRatio);
 
    paintEngine->d_func()->baseSystemClip = region;
    paintEngine->d_func()->setSystemTransform(scaleTransform);
 
}
 
#if QT_CONFIG(graphicseffect)
void QWidgetPrivate::invalidateGraphicsEffectsRecursively()
{
    Q_Q(QWidget);
    QWidget *w = q;
    do {
        if (w->graphicsEffect()) {
            QWidgetEffectSourcePrivate *sourced =
                static_cast<QWidgetEffectSourcePrivate *>(w->graphicsEffect()->source()->d_func());
            if (!sourced->updateDueToGraphicsEffect)
                w->graphicsEffect()->source()->d_func()->invalidateCache();
        }
        w = w->parentWidget();
    } while (w);
}
#endif // QT_CONFIG(graphicseffect)
 
void QWidgetPrivate::setDirtyOpaqueRegion()
{
    Q_Q(QWidget);
 
    dirtyOpaqueChildren = true;
 
#if QT_CONFIG(graphicseffect)
    invalidateGraphicsEffectsRecursively();
#endif // QT_CONFIG(graphicseffect)
 
    if (q->isWindow())
        return;
 
    QWidget *parent = q->parentWidget();
    if (!parent)
        return;
 
    // TODO: instead of setting dirtyflag, manipulate the dirtyregion directly?
    QWidgetPrivate *pd = parent->d_func();
    if (!pd->dirtyOpaqueChildren)
        pd->setDirtyOpaqueRegion();
}
 
const QRegion &QWidgetPrivate::getOpaqueChildren() const
{
    if (!dirtyOpaqueChildren)
        return opaqueChildren;
 
    QWidgetPrivate *that = const_cast<QWidgetPrivate*>(this);
    that->opaqueChildren = QRegion();
 
    for (int i = 0; i < children.size(); ++i) {
        QWidget *child = qobject_cast<QWidget *>(children.at(i));
        if (!child || !child->isVisible() || child->isWindow())
            continue;
 
        const QPoint offset = child->geometry().topLeft();
        QWidgetPrivate *childd = child->d_func();
        QRegion r = childd->isOpaque ? child->rect() : childd->getOpaqueChildren();
        if (childd->extra && childd->extra->hasMask)
            r &= childd->extra->mask;
        if (r.isEmpty())
            continue;
        r.translate(offset);
        that->opaqueChildren += r;
    }
 
    that->opaqueChildren &= q_func()->rect();
    that->dirtyOpaqueChildren = false;
 
    return that->opaqueChildren;
}
 
void QWidgetPrivate::subtractOpaqueChildren(QRegion &source, const QRect &clipRect) const
{
    if (children.isEmpty() || clipRect.isEmpty())
        return;
 
    const QRegion &r = getOpaqueChildren();
    if (!r.isEmpty())
        source -= (r & clipRect);
}
 
//subtract any relatives that are higher up than me --- this is too expensive !!!
void QWidgetPrivate::subtractOpaqueSiblings(QRegion &sourceRegion, bool *hasDirtySiblingsAbove,
                                            bool alsoNonOpaque) const
{
    Q_Q(const QWidget);
    static int disableSubtractOpaqueSiblings = qEnvironmentVariableIntValue("QT_NO_SUBTRACTOPAQUESIBLINGS");
    if (disableSubtractOpaqueSiblings || q->isWindow())
        return;
 
    QRect clipBoundingRect;
    bool dirtyClipBoundingRect = true;
 
    QRegion parentClip;
    bool dirtyParentClip = true;
 
    QPoint parentOffset = data.crect.topLeft();
 
    const QWidget *w = q;
 
    while (w) {
        if (w->isWindow())
            break;
        QWidgetPrivate *pd = w->parentWidget()->d_func();
        const int myIndex = pd->children.indexOf(const_cast<QWidget *>(w));
        const QRect widgetGeometry = w->d_func()->effectiveRectFor(w->data->crect);
        for (int i = myIndex + 1; i < pd->children.size(); ++i) {
            QWidget *sibling = qobject_cast<QWidget *>(pd->children.at(i));
            if (!sibling || !sibling->isVisible() || sibling->isWindow())
                continue;
 
            const QRect siblingGeometry = sibling->d_func()->effectiveRectFor(sibling->data->crect);
            if (!qRectIntersects(siblingGeometry, widgetGeometry))
                continue;
 
            if (dirtyClipBoundingRect) {
                clipBoundingRect = sourceRegion.boundingRect();
                dirtyClipBoundingRect = false;
            }
 
            if (!qRectIntersects(siblingGeometry, clipBoundingRect.translated(parentOffset)))
                continue;
 
            if (dirtyParentClip) {
                parentClip = sourceRegion.translated(parentOffset);
                dirtyParentClip = false;
            }
 
            const QPoint siblingPos(sibling->data->crect.topLeft());
            const QRect siblingClipRect(sibling->d_func()->clipRect());
            QRegion siblingDirty(parentClip);
            siblingDirty &= (siblingClipRect.translated(siblingPos));
            const bool hasMask = sibling->d_func()->extra && sibling->d_func()->extra->hasMask
                                 && !sibling->d_func()->graphicsEffect;
            if (hasMask)
                siblingDirty &= sibling->d_func()->extra->mask.translated(siblingPos);
            if (siblingDirty.isEmpty())
                continue;
 
            if (sibling->d_func()->isOpaque || alsoNonOpaque) {
                if (hasMask) {
                    siblingDirty.translate(-parentOffset);
                    sourceRegion -= siblingDirty;
                } else {
                    sourceRegion -= siblingGeometry.translated(-parentOffset);
                }
            } else {
                if (hasDirtySiblingsAbove)
                    *hasDirtySiblingsAbove = true;
                if (sibling->d_func()->children.isEmpty())
                    continue;
                QRegion opaqueSiblingChildren(sibling->d_func()->getOpaqueChildren());
                opaqueSiblingChildren.translate(-parentOffset + siblingPos);
                sourceRegion -= opaqueSiblingChildren;
            }
            if (sourceRegion.isEmpty())
                return;
 
            dirtyClipBoundingRect = true;
            dirtyParentClip = true;
        }
 
        w = w->parentWidget();
        parentOffset += pd->data.crect.topLeft();
        dirtyParentClip = true;
    }
}
 
void QWidgetPrivate::clipToEffectiveMask(QRegion &region) const
{
    Q_Q(const QWidget);
 
    const QWidget *w = q;
    QPoint offset;
 
#if QT_CONFIG(graphicseffect)
    if (graphicsEffect) {
        w = q->parentWidget();
        offset -= data.crect.topLeft();
    }
#endif // QT_CONFIG(graphicseffect)
 
    while (w) {
        const QWidgetPrivate *wd = w->d_func();
        if (wd->extra && wd->extra->hasMask)
            region &= (w != q) ? wd->extra->mask.translated(offset) : wd->extra->mask;
        if (w->isWindow())
            return;
        offset -= wd->data.crect.topLeft();
        w = w->parentWidget();
    }
}
 
bool QWidgetPrivate::shouldPaintOnScreen() const
{
#if defined(QT_NO_BACKINGSTORE)
    return true;
#else
    Q_Q(const QWidget);
    if (q->testAttribute(Qt::WA_PaintOnScreen)
            || (!q->isWindow() && q->window()->testAttribute(Qt::WA_PaintOnScreen))) {
        return true;
    }
 
    return false;
#endif
}
 
void QWidgetPrivate::updateIsOpaque()
{
    // hw: todo: only needed if opacity actually changed
    setDirtyOpaqueRegion();
 
#if QT_CONFIG(graphicseffect)
    if (graphicsEffect) {
        // ### We should probably add QGraphicsEffect::isOpaque at some point.
        setOpaque(false);
        return;
    }
#endif // QT_CONFIG(graphicseffect)
 
    Q_Q(QWidget);
    if (q->testAttribute(Qt::WA_OpaquePaintEvent) || q->testAttribute(Qt::WA_PaintOnScreen)) {
        setOpaque(true);
        return;
    }
 
    const QPalette &pal = q->palette();
 
    if (q->autoFillBackground()) {
        const QBrush &autoFillBrush = pal.brush(q->backgroundRole());
        if (autoFillBrush.style() != Qt::NoBrush && autoFillBrush.isOpaque()) {
            setOpaque(true);
            return;
        }
    }
 
    if (q->isWindow() && !q->testAttribute(Qt::WA_NoSystemBackground)) {
        const QBrush &windowBrush = q->palette().brush(QPalette::Window);
        if (windowBrush.style() != Qt::NoBrush && windowBrush.isOpaque()) {
            setOpaque(true);
            return;
        }
    }
    setOpaque(false);
}
 
void QWidgetPrivate::setOpaque(bool opaque)
{
    if (isOpaque != opaque) {
        isOpaque = opaque;
        updateIsTranslucent();
    }
}
 
void QWidgetPrivate::updateIsTranslucent()
{
    Q_Q(QWidget);
    if (QWindow *window = q->windowHandle()) {
        QSurfaceFormat format = window->format();
        const int oldAlpha = format.alphaBufferSize();
        const int newAlpha = q->testAttribute(Qt::WA_TranslucentBackground) ? 8 : -1;
        if (oldAlpha != newAlpha) {
            // QTBUG-85714: Do this only when the QWindow has not yet been create()'ed yet.
            //
            // If that is not the case, then the setFormat() is not just futile
            // but downright dangerous. Futile because the format matters only
            // when creating the native window, no point in changing it
            // afterwards. Dangerous because a QOpenGLContext or something else
            // may eventually query the QWindow's format(), in order to ensure
            // compatibility (in terms of native concepts such as pixel format,
            // EGLConfig, etc.), and if we change it here, then the returned
            // format does not describe reality anymore. (reality being the
            // settings with which the native resource was created).
            //
            // Whereas if one does a destroy()-create() then this all here
            // won't matter because the format is updated in
            // QWidgetPrivate::create() again.
            //
            if (!window->handle()) {
                format.setAlphaBufferSize(newAlpha);
                window->setFormat(format);
            }
        }
    }
}
 
static inline void fillRegion(QPainter *painter, const QRegion &rgn, const QBrush &brush)
{
    Q_ASSERT(painter);
 
    if (brush.style() == Qt::TexturePattern) {
        const QRect rect(rgn.boundingRect());
        painter->setClipRegion(rgn);
        painter->drawTiledPixmap(rect, brush.texture(), rect.topLeft());
    } else if (brush.gradient()
               && (brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode
                   || brush.gradient()->coordinateMode() == QGradient::ObjectMode)) {
        painter->save();
        painter->setClipRegion(rgn);
        painter->fillRect(0, 0, painter->device()->width(), painter->device()->height(), brush);
        painter->restore();
    } else {
        for (const QRect &rect : rgn)
            painter->fillRect(rect, brush);
    }
}
 
bool QWidgetPrivate::updateBrushOrigin(QPainter *painter, const QBrush &brush) const
{
#if QT_CONFIG(scrollarea)
    Q_Q(const QWidget);
    //If we are painting the viewport of a scrollarea, we must apply an offset to the brush in case we are drawing a texture
    if (brush.style() == Qt::NoBrush || brush.style() == Qt::SolidPattern)
        return false;
    QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(parent);
    if (scrollArea && scrollArea->viewport() == q) {
        QObjectData *scrollPrivate = static_cast<QWidget *>(scrollArea)->d_ptr.data();
        QAbstractScrollAreaPrivate *priv = static_cast<QAbstractScrollAreaPrivate *>(scrollPrivate);
        painter->setBrushOrigin(-priv->contentsOffset());
    }
#endif // QT_CONFIG(scrollarea)
    return true;
}
 
void QWidgetPrivate::paintBackground(QPainter *painter, const QRegion &rgn, DrawWidgetFlags flags) const
{
    Q_Q(const QWidget);
 
    bool brushOriginSet = false;
    const QBrush autoFillBrush = q->palette().brush(q->backgroundRole());
 
    if ((flags & DrawAsRoot) && !(q->autoFillBackground() && autoFillBrush.isOpaque())) {
        const QBrush bg = q->palette().brush(QPalette::Window);
        if (!brushOriginSet)
            brushOriginSet = updateBrushOrigin(painter, bg);
        if (!(flags & DontSetCompositionMode)) {
            //copy alpha straight in
            QPainter::CompositionMode oldMode = painter->compositionMode();
            painter->setCompositionMode(QPainter::CompositionMode_Source);
            fillRegion(painter, rgn, bg);
            painter->setCompositionMode(oldMode);
        } else {
            fillRegion(painter, rgn, bg);
        }
    }
 
    if (q->autoFillBackground()) {
        if (!brushOriginSet)
            brushOriginSet = updateBrushOrigin(painter, autoFillBrush);
        fillRegion(painter, rgn, autoFillBrush);
    }
 
    if (q->testAttribute(Qt::WA_StyledBackground)) {
        painter->setClipRegion(rgn);
        QStyleOption opt;
        opt.initFrom(q);
        q->style()->drawPrimitive(QStyle::PE_Widget, &opt, painter, q);
    }
}
 
/*
  \internal
  This function is called when a widget is hidden or destroyed.
  It resets some application global pointers that should only refer active,
  visible widgets.
*/
 
extern QWidget *qt_button_down;
 
void QWidgetPrivate::deactivateWidgetCleanup()
{
    Q_Q(QWidget);
    // If this was the active application window, reset it
    if (QApplication::activeWindow() == q)
        QApplicationPrivate::setActiveWindow(nullptr);
    // If the is the active mouse press widget, reset it
    if (q == qt_button_down)
        qt_button_down = nullptr;
}
 
 
QWidget *QWidget::find(WId id)
{
    return QWidgetPrivate::mapper ? QWidgetPrivate::mapper->value(id, 0) : nullptr;
}
 
 
 
WId QWidget::winId() const
{
    if (!data->in_destructor
        && (!testAttribute(Qt::WA_WState_Created) || !internalWinId()))
    {
        QWidget *that = const_cast<QWidget*>(this);
        that->setAttribute(Qt::WA_NativeWindow);
        that->d_func()->createWinId();
        return that->data->winid;
    }
    return data->winid;
}
 
void QWidgetPrivate::createWinId()
{
    Q_Q(QWidget);
 
    const bool forceNativeWindow = q->testAttribute(Qt::WA_NativeWindow);
    if (!q->testAttribute(Qt::WA_WState_Created) || (forceNativeWindow && !q->internalWinId())) {
        if (!q->isWindow()) {
            QWidget *parent = q->parentWidget();
            QWidgetPrivate *pd = parent->d_func();
            if (forceNativeWindow && !q->testAttribute(Qt::WA_DontCreateNativeAncestors))
                parent->setAttribute(Qt::WA_NativeWindow);
            if (!parent->internalWinId()) {
                pd->createWinId();
            }
 
            for (int i = 0; i < pd->children.size(); ++i) {
                QWidget *w = qobject_cast<QWidget *>(pd->children.at(i));
                if (w && !w->isWindow() && (!w->testAttribute(Qt::WA_WState_Created)
                                            || (!w->internalWinId() && w->testAttribute(Qt::WA_NativeWindow)))) {
                    w->create();
                }
            }
        } else {
            q->create();
        }
    }
}
 
bool QWidgetPrivate::setScreenForPoint(const QPoint &pos)
{
    Q_Q(QWidget);
    if (!q->isWindow())
        return false;
    // Find the screen for pos and make the widget understand it is on that screen.
    return setScreen(QGuiApplication::screenAt(pos));
}
 
bool QWidgetPrivate::setScreen(QScreen *screen)
{
    Q_Q(QWidget);
    if (!screen || !q->isWindow())
        return false;
    const QScreen *currentScreen = windowHandle() ? windowHandle()->screen() : nullptr;
    if (currentScreen != screen) {
        topData()->initialScreen = screen;
        if (windowHandle())
            windowHandle()->setScreen(screen);
        return true;
    }
    return false;
}
 
void QWidget::createWinId()
{
    Q_D(QWidget);
    d->createWinId();
}
 
WId QWidget::effectiveWinId() const
{
    const WId id = internalWinId();
    if (id || !testAttribute(Qt::WA_WState_Created))
        return id;
    if (const QWidget *realParent = nativeParentWidget())
        return realParent->internalWinId();
    return 0;
}
 
QWindow *QWidget::windowHandle() const
{
    Q_D(const QWidget);
    return d->windowHandle();
}
 
QScreen *QWidget::screen() const
{
    Q_D(const QWidget);
    if (auto associatedScreen = d->associatedScreen())
        return associatedScreen;
    if (auto topLevel = window()) {
        if (auto topData = qt_widget_private(topLevel)->topData()) {
            if (topData->initialScreen)
                return topData->initialScreen;
        }
        if (auto screenByPos = QGuiApplication::screenAt(topLevel->geometry().center()))
            return screenByPos;
    }
    return QGuiApplication::primaryScreen();
}
 
void QWidget::setScreen(QScreen *screen)
{
    Q_D(QWidget);
    d->setScreen(screen);
}
 
#ifndef QT_NO_STYLE_STYLESHEET
 
QString QWidget::styleSheet() const
{
    Q_D(const QWidget);
    if (!d->extra)
        return QString();
    return d->extra->styleSheet;
}
 
void QWidget::setStyleSheet(const QString& styleSheet)
{
    Q_D(QWidget);
    if (data->in_destructor)
        return;
    d->createExtra();
 
    QStyleSheetStyle *proxy = qt_styleSheet(d->extra->style);
    d->extra->styleSheet = styleSheet;
    if (styleSheet.isEmpty()) { // stylesheet removed
        if (!proxy)
            return;
 
        d->inheritStyle();
        return;
    }
 
    if (proxy) { // style sheet update
        bool repolish = d->polished;
        if (!repolish) {
            const auto childWidgets = findChildren<QWidget*>();
            for (auto child : childWidgets) {
                repolish = child->d_func()->polished;
                if (repolish)
                    break;
            }
        }
        if (repolish)
            proxy->repolish(this);
        return;
    }
 
    if (testAttribute(Qt::WA_SetStyle)) {
        d->setStyle_helper(new QStyleSheetStyle(d->extra->style), true);
    } else {
        d->setStyle_helper(new QStyleSheetStyle(nullptr), true);
    }
}
 
#endif // QT_NO_STYLE_STYLESHEET
 
QStyle *QWidget::style() const
{
    Q_D(const QWidget);
 
    if (d->extra && d->extra->style)
        return d->extra->style;
    return QApplication::style();
}
 
void QWidget::setStyle(QStyle *style)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_SetStyle, style != nullptr);
    d->createExtra();
#ifndef QT_NO_STYLE_STYLESHEET
    if (QStyleSheetStyle *styleSheetStyle = qt_styleSheet(style)) {
        //if for some reason someone try to set a QStyleSheetStyle, ref it
        //(this may happen for example in QButtonDialogBox which propagates its style)
        styleSheetStyle->ref();
        d->setStyle_helper(style, false);
    } else if (qt_styleSheet(d->extra->style) || !qApp->styleSheet().isEmpty()) {
        // if we have an application stylesheet or have a proxy already, propagate
        d->setStyle_helper(new QStyleSheetStyle(style), true);
    } else
#endif
        d->setStyle_helper(style, false);
}
 
void QWidgetPrivate::setStyle_helper(QStyle *newStyle, bool propagate)
{
    Q_Q(QWidget);
    QStyle *oldStyle = q->style();
 
    createExtra();
 
#ifndef QT_NO_STYLE_STYLESHEET
    QPointer<QStyle> origStyle = extra->style;
#endif
    extra->style = newStyle;
 
    // repolish
    if (polished && q->windowType() != Qt::Desktop) {
        oldStyle->unpolish(q);
        q->style()->polish(q);
    }
 
    if (propagate) {
        // We copy the list because the order may be modified
        const QObjectList childrenList = children;
        for (int i = 0; i < childrenList.size(); ++i) {
            QWidget *c = qobject_cast<QWidget*>(childrenList.at(i));
            if (c)
                c->d_func()->inheritStyle();
        }
    }
 
#ifndef QT_NO_STYLE_STYLESHEET
    if (!qt_styleSheet(newStyle)) {
        if (const QStyleSheetStyle* cssStyle = qt_styleSheet(origStyle)) {
            cssStyle->clearWidgetFont(q);
        }
    }
#endif
 
    QEvent e(QEvent::StyleChange);
    QCoreApplication::sendEvent(q, &e);
 
#ifndef QT_NO_STYLE_STYLESHEET
    // dereference the old stylesheet style
    if (QStyleSheetStyle *proxy = qt_styleSheet(origStyle))
        proxy->deref();
#endif
}
 
// Inherits style from the current parent and propagates it as necessary
void QWidgetPrivate::inheritStyle()
{
#ifndef QT_NO_STYLE_STYLESHEET
    Q_Q(QWidget);
 
    QStyle *extraStyle = extra ? (QStyle*)extra->style : nullptr;
 
    QStyleSheetStyle *proxy = qt_styleSheet(extraStyle);
 
    if (!q->styleSheet().isEmpty()) {
        Q_ASSERT(proxy);
        proxy->repolish(q);
        return;
    }
 
    QStyle *origStyle = proxy ? proxy->base : extraStyle;
    QWidget *parent = q->parentWidget();
    QStyle *parentStyle = (parent && parent->d_func()->extra) ? (QStyle*)parent->d_func()->extra->style : nullptr;
    // If we have stylesheet on app or parent has stylesheet style, we need
    // to be running a proxy
    if (!qApp->styleSheet().isEmpty() || qt_styleSheet(parentStyle)) {
        QStyle *newStyle = parentStyle;
        if (q->testAttribute(Qt::WA_SetStyle) && qt_styleSheet(origStyle) == nullptr)
            newStyle = new QStyleSheetStyle(origStyle);
        else if (auto *styleSheetStyle = qt_styleSheet(origStyle))
            newStyle = styleSheetStyle;
        else if (QStyleSheetStyle *newProxy = qt_styleSheet(parentStyle))
            newProxy->ref();
 
        setStyle_helper(newStyle, true);
        return;
    }
 
    // So, we have no stylesheet on parent/app and we have an empty stylesheet
    // we just need our original style back
    if (origStyle == extraStyle) // is it any different?
        return;
 
    // We could have inherited the proxy from our parent (which has a custom style)
    // In such a case we need to start following the application style (i.e revert
    // the propagation behavior of QStyleSheetStyle)
    if (!q->testAttribute(Qt::WA_SetStyle))
        origStyle = nullptr;
 
    setStyle_helper(origStyle, true);
#endif // QT_NO_STYLE_STYLESHEET
}
 
 
Qt::WindowModality QWidget::windowModality() const
{
    return static_cast<Qt::WindowModality>(data->window_modality);
}
 
void QWidget::setWindowModality(Qt::WindowModality windowModality)
{
    data->window_modality = windowModality;
    // setModal_sys() will be called by setAttribute()
    setAttribute(Qt::WA_ShowModal, (data->window_modality != Qt::NonModal));
    setAttribute(Qt::WA_SetWindowModality, true);
}
 
void QWidgetPrivate::setModal_sys()
{
    Q_Q(QWidget);
    if (q->windowHandle())
        q->windowHandle()->setModality(q->windowModality());
}
 
bool QWidget::isMinimized() const
{ return data->window_state & Qt::WindowMinimized; }
 
void QWidget::showMinimized()
{
    bool isMin = isMinimized();
    if (isMin && isVisible())
        return;
 
    ensurePolished();
 
    if (!isMin)
        setWindowState((windowState() & ~Qt::WindowActive) | Qt::WindowMinimized);
    setVisible(true);
}
 
bool QWidget::isMaximized() const
{ return data->window_state & Qt::WindowMaximized; }
 
 
 
Qt::WindowStates QWidget::windowState() const
{
    return Qt::WindowStates(data->window_state);
}
 
void QWidget::overrideWindowState(Qt::WindowStates newstate)
{
    QWindowStateChangeEvent e(Qt::WindowStates(data->window_state), true);
    data->window_state  = newstate;
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidget::setWindowState(Qt::WindowStates newstate)
{
    Q_D(QWidget);
    Qt::WindowStates oldstate = windowState();
    if (newstate.testFlag(Qt::WindowMinimized)) // QTBUG-46763
       newstate.setFlag(Qt::WindowActive, false);
    if (oldstate == newstate)
        return;
    if (isWindow() && !testAttribute(Qt::WA_WState_Created))
        create();
 
    data->window_state = newstate;
    data->in_set_window_state = 1;
    if (isWindow()) {
        // Ensure the initial size is valid, since we store it as normalGeometry below.
        if (!testAttribute(Qt::WA_Resized) && !isVisible())
            adjustSize();
 
        d->createTLExtra();
        if (!(oldstate & (Qt::WindowMinimized | Qt::WindowMaximized | Qt::WindowFullScreen)))
            d->topData()->normalGeometry = geometry();
 
        Q_ASSERT(windowHandle());
        windowHandle()->setWindowStates(newstate & ~Qt::WindowActive);
    }
    data->in_set_window_state = 0;
 
    if (newstate & Qt::WindowActive)
        activateWindow();
 
    QWindowStateChangeEvent e(oldstate);
    QCoreApplication::sendEvent(this, &e);
}
 
bool QWidget::isFullScreen() const
{ return data->window_state & Qt::WindowFullScreen; }
 
void QWidget::showFullScreen()
{
    ensurePolished();
 
    setWindowState((windowState() & ~(Qt::WindowMinimized | Qt::WindowMaximized))
                   | Qt::WindowFullScreen);
    setVisible(true);
#if !defined Q_OS_QNX // On QNX this window will be activated anyway from libscreen
                      // activating it here before libscreen activates it causes problems
    activateWindow();
#endif
}
 
void QWidget::showMaximized()
{
    ensurePolished();
 
    setWindowState((windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen))
                   | Qt::WindowMaximized);
    setVisible(true);
}
 
void QWidget::showNormal()
{
    ensurePolished();
 
    setWindowState(windowState() & ~(Qt::WindowMinimized
                                     | Qt::WindowMaximized
                                     | Qt::WindowFullScreen));
    setVisible(true);
}
 
bool QWidget::isEnabledTo(const QWidget *ancestor) const
{
    const QWidget * w = this;
    while (!w->testAttribute(Qt::WA_ForceDisabled)
            && !w->isWindow()
            && w->parentWidget()
            && w->parentWidget() != ancestor)
        w = w->parentWidget();
    return !w->testAttribute(Qt::WA_ForceDisabled);
}
 
#ifndef QT_NO_ACTION
void QWidget::addAction(QAction *action)
{
    insertAction(nullptr, action);
}
 
void QWidget::addActions(const QList<QAction *> &actions)
{
    for(int i = 0; i < actions.size(); i++)
        insertAction(nullptr, actions.at(i));
}
 
void QWidget::insertAction(QAction *before, QAction *action)
{
    if (Q_UNLIKELY(!action)) {
        qWarning("QWidget::insertAction: Attempt to insert null action");
        return;
    }
 
    Q_D(QWidget);
    if (d->actions.contains(action))
        removeAction(action);
 
    int pos = d->actions.indexOf(before);
    if (pos < 0) {
        before = nullptr;
        pos = d->actions.size();
    }
    d->actions.insert(pos, action);
 
    QActionPrivate *apriv = action->d_func();
    apriv->associatedObjects.append(this);
 
    QActionEvent e(QEvent::ActionAdded, action, before);
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidget::insertActions(QAction *before, const QList<QAction*> &actions)
{
    for(int i = 0; i < actions.size(); ++i)
        insertAction(before, actions.at(i));
}
 
void QWidget::removeAction(QAction *action)
{
    if (!action)
        return;
 
    Q_D(QWidget);
 
    QActionPrivate *apriv = action->d_func();
    apriv->associatedObjects.removeAll(this);
 
    if (d->actions.removeAll(action)) {
        QActionEvent e(QEvent::ActionRemoved, action);
        QCoreApplication::sendEvent(this, &e);
    }
}
 
QList<QAction*> QWidget::actions() const
{
    Q_D(const QWidget);
    return d->actions;
}
 
QAction *QWidget::addAction(const QString &text)
{
    QAction *ret = new QAction(text, this);
    addAction(ret);
    return ret;
}
 
QAction *QWidget::addAction(const QIcon &icon, const QString &text)
{
    QAction *ret = new QAction(icon, text, this);
    addAction(ret);
    return ret;
}
 
#if QT_CONFIG(shortcut)
QAction *QWidget::addAction(const QString &text, const QKeySequence &shortcut)
{
    QAction *ret = addAction(text);
    ret->setShortcut(shortcut);
    return ret;
}
 
QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut)
{
    QAction *ret = addAction(icon, text);
    ret->setShortcut(shortcut);
    return ret;
}
#endif
 
QAction *QWidget::addAction(const QString &text, const QObject *receiver, const char* member,
                            Qt::ConnectionType type)
{
    QAction *action = addAction(text);
    QObject::connect(action, SIGNAL(triggered(bool)), receiver, member, type);
    return action;
}
 
QAction *QWidget::addAction(const QIcon &icon, const QString &text,
                            const QObject *receiver, const char* member,
                            Qt::ConnectionType type)
{
    QAction *action = addAction(icon, text);
    QObject::connect(action, SIGNAL(triggered(bool)), receiver, member, type);
    return action;
}
 
#if QT_CONFIG(shortcut)
QAction *QWidget::addAction(const QString &text, const QKeySequence &shortcut,
                            const QObject *receiver, const char* member,
                            Qt::ConnectionType type)
{
    QAction *action = addAction(text, receiver, member, type);
    action->setShortcut(shortcut);
    return action;
}
 
QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut,
                            const QObject *receiver, const char* member,
                            Qt::ConnectionType type)
{
    QAction *action = addAction(icon, text, receiver, member, type);
    action->setShortcut(shortcut);
    return action;
}
#endif // QT_CONFIG(shortcut)
 
#endif // QT_NO_ACTION
 
void QWidget::setEnabled(bool enable)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_ForceDisabled, !enable);
    d->setEnabled_helper(enable);
}
 
void QWidgetPrivate::setEnabled_helper(bool enable)
{
    Q_Q(QWidget);
 
    if (enable && !q->isWindow() && q->parentWidget() && !q->parentWidget()->isEnabled())
        return; // nothing we can do
 
    if (enable != q->testAttribute(Qt::WA_Disabled))
        return; // nothing to do
 
    q->setAttribute(Qt::WA_Disabled, !enable);
    updateSystemBackground();
 
    if (!enable && q->window()->focusWidget() == q) {
        bool parentIsEnabled = (!q->parentWidget() || q->parentWidget()->isEnabled());
        if (!parentIsEnabled || !q->focusNextChild())
            q->clearFocus();
    }
 
    Qt::WidgetAttribute attribute = enable ? Qt::WA_ForceDisabled : Qt::WA_Disabled;
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(children.at(i));
        if (w && !w->testAttribute(attribute))
            w->d_func()->setEnabled_helper(enable);
    }
#ifndef QT_NO_CURSOR
    if (q->testAttribute(Qt::WA_SetCursor) || q->isWindow()) {
        // enforce the windows behavior of clearing the cursor on
        // disabled widgets
        qt_qpa_set_cursor(q, false);
    }
#endif
#ifndef QT_NO_IM
    if (q->testAttribute(Qt::WA_InputMethodEnabled) && q->hasFocus()) {
        QWidget *focusWidget = effectiveFocusWidget();
 
        if (enable) {
            if (focusWidget->testAttribute(Qt::WA_InputMethodEnabled))
                QGuiApplication::inputMethod()->update(Qt::ImEnabled);
        } else {
            QGuiApplication::inputMethod()->commit();
            QGuiApplication::inputMethod()->update(Qt::ImEnabled);
        }
    }
#endif //QT_NO_IM
    QEvent e(QEvent::EnabledChange);
    QCoreApplication::sendEvent(q, &e);
}
 
bool QWidget::acceptDrops() const
{
    return testAttribute(Qt::WA_AcceptDrops);
}
 
void QWidget::setAcceptDrops(bool on)
{
    setAttribute(Qt::WA_AcceptDrops, on);
 
}
 
void QWidget::setDisabled(bool disable)
{
    setEnabled(!disable);
}
 
QRect QWidget::frameGeometry() const
{
    Q_D(const QWidget);
    if (isWindow() && ! (windowType() == Qt::Popup)) {
        QRect fs = d->frameStrut();
        return QRect(data->crect.x() - fs.left(),
                     data->crect.y() - fs.top(),
                     data->crect.width() + fs.left() + fs.right(),
                     data->crect.height() + fs.top() + fs.bottom());
    }
    return data->crect;
}
 
int QWidget::x() const
{
    Q_D(const QWidget);
    if (isWindow() && ! (windowType() == Qt::Popup))
        return data->crect.x() - d->frameStrut().left();
    return data->crect.x();
}
 
int QWidget::y() const
{
    Q_D(const QWidget);
    if (isWindow() && ! (windowType() == Qt::Popup))
        return data->crect.y() - d->frameStrut().top();
    return data->crect.y();
}
 
QPoint QWidget::pos() const
{
    Q_D(const QWidget);
    QPoint result = data->crect.topLeft();
    if (isWindow() && ! (windowType() == Qt::Popup))
        if (!d->maybeTopData() || !d->maybeTopData()->posIncludesFrame)
            result -= d->frameStrut().topLeft();
    return result;
}
 
QRect QWidget::normalGeometry() const
{
    Q_D(const QWidget);
    if (!isWindow())
        return QRect();
 
    if (!isMaximized() && !isFullScreen())
        return geometry();
 
    return d->topData()->normalGeometry;
}
 
 
QRect QWidget::childrenRect() const
{
    Q_D(const QWidget);
    QRect r(0, 0, 0, 0);
    for (int i = 0; i < d->children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(d->children.at(i));
        if (w && !w->isWindow() && !w->isHidden())
            r |= w->geometry();
    }
    return r;
}
 
QRegion QWidget::childrenRegion() const
{
    Q_D(const QWidget);
    QRegion r;
    for (int i = 0; i < d->children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(d->children.at(i));
        if (w && !w->isWindow() && !w->isHidden()) {
            QRegion mask = w->mask();
            if (mask.isEmpty())
                r |= w->geometry();
            else
                r |= mask.translated(w->pos());
        }
    }
    return r;
}
 
 
QSize QWidget::minimumSize() const
{
    Q_D(const QWidget);
    return d->extra ? QSize(d->extra->minw, d->extra->minh) : QSize(0, 0);
}
 
QSize QWidget::maximumSize() const
{
    Q_D(const QWidget);
    return d->extra ? QSize(d->extra->maxw, d->extra->maxh)
                 : QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
}
 
 
QSize QWidget::sizeIncrement() const
{
    Q_D(const QWidget);
    return (d->extra && d->extra->topextra)
        ? QSize(d->extra->topextra->incw, d->extra->topextra->inch)
        : QSize(0, 0);
}
 
QSize QWidget::baseSize() const
{
    Q_D(const QWidget);
    return (d->extra && d->extra->topextra)
        ? QSize(d->extra->topextra->basew, d->extra->topextra->baseh)
        : QSize(0, 0);
}
 
bool QWidgetPrivate::setMinimumSize_helper(int &minw, int &minh)
{
    Q_Q(QWidget);
 
    int mw = minw, mh = minh;
    if (mw == QWIDGETSIZE_MAX)
        mw = 0;
    if (mh == QWIDGETSIZE_MAX)
        mh = 0;
    if (Q_UNLIKELY(minw > QWIDGETSIZE_MAX || minh > QWIDGETSIZE_MAX)) {
        qWarning("QWidget::setMinimumSize: (%s/%s) "
                "The largest allowed size is (%d,%d)",
                 q->objectName().toLocal8Bit().data(), q->metaObject()->className(), QWIDGETSIZE_MAX,
                QWIDGETSIZE_MAX);
        minw = mw = qMin<int>(minw, QWIDGETSIZE_MAX);
        minh = mh = qMin<int>(minh, QWIDGETSIZE_MAX);
    }
    if (Q_UNLIKELY(minw < 0 || minh < 0)) {
        qWarning("QWidget::setMinimumSize: (%s/%s) Negative sizes (%d,%d) "
                "are not possible",
                q->objectName().toLocal8Bit().data(), q->metaObject()->className(), minw, minh);
        minw = mw = qMax(minw, 0);
        minh = mh = qMax(minh, 0);
    }
    createExtra();
    if (extra->minw == mw && extra->minh == mh)
        return false;
    extra->minw = mw;
    extra->minh = mh;
    extra->explicitMinSize = (mw ? Qt::Horizontal : 0) | (mh ? Qt::Vertical : 0);
    return true;
}
 
void QWidgetPrivate::setConstraints_sys()
{
    Q_Q(QWidget);
    if (extra && q->windowHandle()) {
        QWindow *win = q->windowHandle();
        QWindowPrivate *winp = qt_window_private(win);
 
        winp->minimumSize = QSize(extra->minw, extra->minh);
        winp->maximumSize = QSize(extra->maxw, extra->maxh);
 
        if (extra->topextra) {
            winp->baseSize = QSize(extra->topextra->basew, extra->topextra->baseh);
            winp->sizeIncrement = QSize(extra->topextra->incw, extra->topextra->inch);
        }
 
        if (winp->platformWindow) {
            fixPosIncludesFrame();
            winp->platformWindow->propagateSizeHints();
        }
    }
}
 
void QWidget::setMinimumSize(int minw, int minh)
{
    Q_D(QWidget);
    if (!d->setMinimumSize_helper(minw, minh))
        return;
 
    if (isWindow())
        d->setConstraints_sys();
    if (minw > width() || minh > height()) {
        bool resized = testAttribute(Qt::WA_Resized);
        bool maximized = isMaximized();
        resize(qMax(minw,width()), qMax(minh,height()));
        setAttribute(Qt::WA_Resized, resized); //not a user resize
        if (maximized)
            data->window_state = data->window_state | Qt::WindowMaximized;
    }
#if QT_CONFIG(graphicsview)
    if (d->extra) {
        if (d->extra->proxyWidget)
            d->extra->proxyWidget->setMinimumSize(minw, minh);
    }
#endif
    d->updateGeometry_helper(d->extra->minw == d->extra->maxw && d->extra->minh == d->extra->maxh);
}
 
bool QWidgetPrivate::setMaximumSize_helper(int &maxw, int &maxh)
{
    Q_Q(QWidget);
    if (Q_UNLIKELY(maxw > QWIDGETSIZE_MAX || maxh > QWIDGETSIZE_MAX)) {
        qWarning("QWidget::setMaximumSize: (%s/%s) "
                "The largest allowed size is (%d,%d)",
                 q->objectName().toLocal8Bit().data(), q->metaObject()->className(), QWIDGETSIZE_MAX,
                QWIDGETSIZE_MAX);
        maxw = qMin<int>(maxw, QWIDGETSIZE_MAX);
        maxh = qMin<int>(maxh, QWIDGETSIZE_MAX);
    }
    if (Q_UNLIKELY(maxw < 0 || maxh < 0)) {
        qWarning("QWidget::setMaximumSize: (%s/%s) Negative sizes (%d,%d) "
                "are not possible",
                q->objectName().toLocal8Bit().data(), q->metaObject()->className(), maxw, maxh);
        maxw = qMax(maxw, 0);
        maxh = qMax(maxh, 0);
    }
    createExtra();
    if (extra->maxw == maxw && extra->maxh == maxh)
        return false;
    extra->maxw = maxw;
    extra->maxh = maxh;
    extra->explicitMaxSize = (maxw != QWIDGETSIZE_MAX ? Qt::Horizontal : 0) |
                             (maxh != QWIDGETSIZE_MAX ? Qt::Vertical : 0);
    return true;
}
 
void QWidget::setMaximumSize(int maxw, int maxh)
{
    Q_D(QWidget);
    if (!d->setMaximumSize_helper(maxw, maxh))
        return;
 
    if (isWindow())
        d->setConstraints_sys();
    if (maxw < width() || maxh < height()) {
        bool resized = testAttribute(Qt::WA_Resized);
        resize(qMin(maxw,width()), qMin(maxh,height()));
        setAttribute(Qt::WA_Resized, resized); //not a user resize
    }
 
#if QT_CONFIG(graphicsview)
    if (d->extra) {
        if (d->extra->proxyWidget)
            d->extra->proxyWidget->setMaximumSize(maxw, maxh);
    }
#endif
 
    d->updateGeometry_helper(d->extra->minw == d->extra->maxw && d->extra->minh == d->extra->maxh);
}
 
void QWidget::setSizeIncrement(int w, int h)
{
    Q_D(QWidget);
    d->createTLExtra();
    QTLWExtra* x = d->topData();
    if (x->incw == w && x->inch == h)
        return;
    x->incw = w;
    x->inch = h;
    if (isWindow())
        d->setConstraints_sys();
}
 
void QWidget::setBaseSize(int basew, int baseh)
{
    Q_D(QWidget);
    d->createTLExtra();
    QTLWExtra* x = d->topData();
    if (x->basew == basew && x->baseh == baseh)
        return;
    x->basew = basew;
    x->baseh = baseh;
    if (isWindow())
        d->setConstraints_sys();
}
 
void QWidget::setFixedSize(const QSize & s)
{
    setFixedSize(s.width(), s.height());
}
 
 
void QWidget::setFixedSize(int w, int h)
{
    Q_D(QWidget);
    bool minSizeSet = d->setMinimumSize_helper(w, h);
    bool maxSizeSet = d->setMaximumSize_helper(w, h);
    if (!minSizeSet && !maxSizeSet)
        return;
 
    if (isWindow())
        d->setConstraints_sys();
    else
        d->updateGeometry_helper(true);
 
    if (w != QWIDGETSIZE_MAX || h != QWIDGETSIZE_MAX)
        resize(w, h);
}
 
void QWidget::setMinimumWidth(int w)
{
    Q_D(QWidget);
    d->createExtra();
    uint expl = d->extra->explicitMinSize | (w ? Qt::Horizontal : 0);
    setMinimumSize(w, minimumSize().height());
    d->extra->explicitMinSize = expl;
}
 
void QWidget::setMinimumHeight(int h)
{
    Q_D(QWidget);
    d->createExtra();
    uint expl = d->extra->explicitMinSize | (h ? Qt::Vertical : 0);
    setMinimumSize(minimumSize().width(), h);
    d->extra->explicitMinSize = expl;
}
 
void QWidget::setMaximumWidth(int w)
{
    Q_D(QWidget);
    d->createExtra();
    uint expl = d->extra->explicitMaxSize | (w == QWIDGETSIZE_MAX ? 0 : Qt::Horizontal);
    setMaximumSize(w, maximumSize().height());
    d->extra->explicitMaxSize = expl;
}
 
void QWidget::setMaximumHeight(int h)
{
    Q_D(QWidget);
    d->createExtra();
    uint expl = d->extra->explicitMaxSize | (h == QWIDGETSIZE_MAX ? 0 : Qt::Vertical);
    setMaximumSize(maximumSize().width(), h);
    d->extra->explicitMaxSize = expl;
}
 
void QWidget::setFixedWidth(int w)
{
    Q_D(QWidget);
    d->createExtra();
    uint explMin = d->extra->explicitMinSize | Qt::Horizontal;
    uint explMax = d->extra->explicitMaxSize | Qt::Horizontal;
    setMinimumSize(w, minimumSize().height());
    setMaximumSize(w, maximumSize().height());
    d->extra->explicitMinSize = explMin;
    d->extra->explicitMaxSize = explMax;
}
 
 
void QWidget::setFixedHeight(int h)
{
    Q_D(QWidget);
    d->createExtra();
    uint explMin = d->extra->explicitMinSize | Qt::Vertical;
    uint explMax = d->extra->explicitMaxSize | Qt::Vertical;
    setMinimumSize(minimumSize().width(), h);
    setMaximumSize(maximumSize().width(), h);
    d->extra->explicitMinSize = explMin;
    d->extra->explicitMaxSize = explMax;
}
 
 
QPointF QWidget::mapTo(const QWidget *parent, const QPointF &pos) const
{
    QPointF p = pos;
    if (parent) {
        const QWidget * w = this;
        while (w != parent) {
            Q_ASSERT_X(w, "QWidget::mapTo(const QWidget *parent, const QPointF &pos)",
                       "parent must be in parent hierarchy");
            p = w->mapToParent(p);
            w = w->parentWidget();
        }
    }
    return p;
}
 
QPoint QWidget::mapTo(const QWidget *parent, const QPoint &pos) const
{
    return mapTo(parent, QPointF(pos)).toPoint();
}
 
QPointF QWidget::mapFrom(const QWidget *parent, const QPointF &pos) const
{
    QPointF p(pos);
    if (parent) {
        const QWidget * w = this;
        while (w != parent) {
            Q_ASSERT_X(w, "QWidget::mapFrom(const QWidget *parent, const QPoint &pos)",
                       "parent must be in parent hierarchy");
 
            p = w->mapFromParent(p);
            w = w->parentWidget();
        }
    }
    return p;
}
 
QPoint QWidget::mapFrom(const QWidget *parent, const QPoint &pos) const
{
    return mapFrom(parent, QPointF(pos)).toPoint();
}
 
QPointF QWidget::mapToParent(const QPointF &pos) const
{
    return pos + QPointF(data->crect.topLeft());
}
 
QPoint QWidget::mapToParent(const QPoint &pos) const
{
    return pos + data->crect.topLeft();
}
 
QPointF QWidget::mapFromParent(const QPointF &pos) const
{
    return pos - QPointF(data->crect.topLeft());
}
 
QPoint QWidget::mapFromParent(const QPoint &pos) const
{
    return pos - data->crect.topLeft();
}
 
 
QWidget *QWidget::window() const
{
    QWidget *w = const_cast<QWidget *>(this);
    QWidget *p = w->parentWidget();
    while (!w->isWindow() && p) {
        w = p;
        p = p->parentWidget();
    }
    return w;
}
 
QWidget *QWidget::nativeParentWidget() const
{
    QWidget *parent = parentWidget();
    while (parent && !parent->internalWinId())
        parent = parent->parentWidget();
    return parent;
}
 
QPalette::ColorRole QWidget::backgroundRole() const
{
 
    const QWidget *w = this;
    do {
        QPalette::ColorRole role = w->d_func()->bg_role;
        if (role != QPalette::NoRole)
            return role;
        if (w->isWindow() || w->windowType() == Qt::SubWindow)
            break;
        w = w->parentWidget();
    } while (w);
    return QPalette::Window;
}
 
void QWidget::setBackgroundRole(QPalette::ColorRole role)
{
    Q_D(QWidget);
    d->bg_role = role;
    d->updateSystemBackground();
    d->propagatePaletteChange();
    d->updateIsOpaque();
}
 
QPalette::ColorRole QWidget::foregroundRole() const
{
    Q_D(const QWidget);
    QPalette::ColorRole rl = QPalette::ColorRole(d->fg_role);
    if (rl != QPalette::NoRole)
        return rl;
    QPalette::ColorRole role = QPalette::WindowText;
    switch (backgroundRole()) {
    case QPalette::Button:
        role = QPalette::ButtonText;
        break;
    case QPalette::Base:
        role = QPalette::Text;
        break;
    case QPalette::Dark:
    case QPalette::Shadow:
        role = QPalette::Light;
        break;
    case QPalette::Highlight:
        role = QPalette::HighlightedText;
        break;
    case QPalette::ToolTipBase:
        role = QPalette::ToolTipText;
        break;
    default:
        ;
    }
    return role;
}
 
void QWidget::setForegroundRole(QPalette::ColorRole role)
{
    Q_D(QWidget);
    d->fg_role = role;
    d->updateSystemBackground();
    d->propagatePaletteChange();
}
 
const QPalette &QWidget::palette() const
{
    if (!isEnabled()) {
        data->pal.setCurrentColorGroup(QPalette::Disabled);
    } else if ((!isVisible() || isActiveWindow())
#if defined(Q_OS_WIN)
        && !QApplicationPrivate::isBlockedByModal(const_cast<QWidget *>(this))
#endif
        ) {
        data->pal.setCurrentColorGroup(QPalette::Active);
    } else {
        data->pal.setCurrentColorGroup(QPalette::Inactive);
    }
    return data->pal;
}
 
void QWidget::setPalette(const QPalette &palette)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_SetPalette, palette.resolveMask() != 0);
 
    // Determine which palette is inherited from this widget's ancestors and
    // QApplication::palette, resolve this against \a palette (attributes from
    // the inherited palette are copied over this widget's palette). Then
    // propagate this palette to this widget's children.
    QPalette naturalPalette = d->naturalWidgetPalette(d->inheritedPaletteResolveMask);
    QPalette resolvedPalette = palette.resolve(naturalPalette);
    d->setPalette_helper(resolvedPalette);
}
 
QPalette QWidgetPrivate::naturalWidgetPalette(QPalette::ResolveMask inheritedMask) const
{
    Q_Q(const QWidget);
 
    const bool useStyleSheetPropagationInWidgetStyles =
        QCoreApplication::testAttribute(Qt::AA_UseStyleSheetPropagationInWidgetStyles);
 
    QPalette naturalPalette = QApplication::palette(q);
    if ((!q->testAttribute(Qt::WA_StyleSheet) || useStyleSheetPropagationInWidgetStyles)
        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
#if QT_CONFIG(graphicsview)
            || (extra && extra->proxyWidget)
#endif // QT_CONFIG(graphicsview)
            )) {
        if (QWidget *p = q->parentWidget()) {
            if (!p->testAttribute(Qt::WA_StyleSheet) || useStyleSheetPropagationInWidgetStyles) {
                if (!naturalPalette.isCopyOf(QGuiApplication::palette())) {
                    QPalette inheritedPalette = p->palette();
                    inheritedPalette.setResolveMask(inheritedMask);
                    naturalPalette = inheritedPalette.resolve(naturalPalette);
                } else {
                    naturalPalette = p->palette();
                }
            }
        }
#if QT_CONFIG(graphicsview)
        else if (extra && extra->proxyWidget) {
            QPalette inheritedPalette = extra->proxyWidget->palette();
            inheritedPalette.setResolveMask(inheritedMask);
            naturalPalette = inheritedPalette.resolve(naturalPalette);
        }
#endif // QT_CONFIG(graphicsview)
    }
    naturalPalette.setResolveMask(0);
    return naturalPalette;
}
void QWidgetPrivate::resolvePalette()
{
    QPalette naturalPalette = naturalWidgetPalette(inheritedPaletteResolveMask);
    QPalette resolvedPalette = data.pal.resolve(naturalPalette);
    setPalette_helper(resolvedPalette);
}
 
void QWidgetPrivate::setPalette_helper(const QPalette &palette)
{
    Q_Q(QWidget);
    if (data.pal == palette && data.pal.resolveMask() == palette.resolveMask())
        return;
    data.pal = palette;
    updateSystemBackground();
    propagatePaletteChange();
    updateIsOpaque();
    q->update();
    updateIsOpaque();
}
 
void QWidgetPrivate::updateSystemBackground()
{
}
 
void QWidget::setFont(const QFont &font)
{
    Q_D(QWidget);
 
#ifndef QT_NO_STYLE_STYLESHEET
    const QStyleSheetStyle* style;
    if (d->extra && (style = qt_styleSheet(d->extra->style)))
        style->saveWidgetFont(this, font);
#endif
 
    setAttribute(Qt::WA_SetFont, font.resolveMask() != 0);
 
    // Determine which font is inherited from this widget's ancestors and
    // QApplication::font, resolve this against \a font (attributes from the
    // inherited font are copied over). Then propagate this font to this
    // widget's children.
    QFont naturalFont = d->naturalWidgetFont(d->inheritedFontResolveMask);
    QFont resolvedFont = font.resolve(naturalFont);
    d->setFont_helper(resolvedFont);
}
 
/*
    \internal
 
    Returns the font that the widget \a w inherits from its ancestors and
    QApplication::font. \a inheritedMask is the combination of the widget's
    ancestors font request masks (i.e., which attributes from the parent
    widget's font are implicitly imposed on this widget by the user). Note
    that this font does not take into account the font set on \a w itself.
 
    ### Stylesheet has a different font propagation mechanism. When a stylesheet
        is applied, fonts are not propagated anymore
*/
QFont QWidgetPrivate::naturalWidgetFont(uint inheritedMask) const
{
    Q_Q(const QWidget);
 
    const bool useStyleSheetPropagationInWidgetStyles =
        QCoreApplication::testAttribute(Qt::AA_UseStyleSheetPropagationInWidgetStyles);
 
    QFont naturalFont = QApplication::font(q);
    if ((!q->testAttribute(Qt::WA_StyleSheet) || useStyleSheetPropagationInWidgetStyles)
        && (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
#if QT_CONFIG(graphicsview)
            || (extra && extra->proxyWidget)
#endif // QT_CONFIG(graphicsview)
            )) {
        if (QWidget *p = q->parentWidget()) {
            if (!p->testAttribute(Qt::WA_StyleSheet) || useStyleSheetPropagationInWidgetStyles) {
                if (!naturalFont.isCopyOf(QApplication::font())) {
                    if (inheritedMask != 0) {
                        QFont inheritedFont = p->font();
                        inheritedFont.setResolveMask(inheritedMask);
                        naturalFont = inheritedFont.resolve(naturalFont);
                    } // else nothing to do (naturalFont = naturalFont)
                } else {
                    naturalFont = p->font();
                }
            }
        }
#if QT_CONFIG(graphicsview)
        else if (extra && extra->proxyWidget) {
            if (inheritedMask != 0) {
                QFont inheritedFont = extra->proxyWidget->font();
                inheritedFont.setResolveMask(inheritedMask);
                naturalFont = inheritedFont.resolve(naturalFont);
            } // else nothing to do (naturalFont = naturalFont)
        }
#endif // QT_CONFIG(graphicsview)
    }
    naturalFont.setResolveMask(0);
    return naturalFont;
}
 
QFont QWidgetPrivate::localFont() const
{
    QFont localfont = data.fnt;
    localfont.setResolveMask(directFontResolveMask);
    return localfont;
}
 
void QWidgetPrivate::resolveFont()
{
    QFont naturalFont = naturalWidgetFont(inheritedFontResolveMask);
    QFont resolvedFont = localFont().resolve(naturalFont);
    setFont_helper(resolvedFont);
}
 
void QWidgetPrivate::updateFont(const QFont &font)
{
    Q_Q(QWidget);
#ifndef QT_NO_STYLE_STYLESHEET
    const QStyleSheetStyle* cssStyle;
    cssStyle = extra ? qt_styleSheet(extra->style) : nullptr;
    const bool useStyleSheetPropagationInWidgetStyles =
        QCoreApplication::testAttribute(Qt::AA_UseStyleSheetPropagationInWidgetStyles);
#endif
 
    data.fnt = QFont(font, q);
 
    // Combine new mask with natural mask and propagate to children.
#if QT_CONFIG(graphicsview)
    if (!q->parentWidget() && extra && extra->proxyWidget) {
        QGraphicsProxyWidget *p = extra->proxyWidget;
        inheritedFontResolveMask = p->d_func()->inheritedFontResolveMask | p->font().resolveMask();
    } else
#endif // QT_CONFIG(graphicsview)
    if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
        inheritedFontResolveMask = 0;
    }
    uint newMask = data.fnt.resolveMask() | inheritedFontResolveMask;
    // Set the font as also having resolved inherited traits, so the result of reading QWidget::font()
    // isn't all weak information, but save the original mask to be able to let new changes on the
    // parent widget font propagate correctly.
    directFontResolveMask = data.fnt.resolveMask();
    data.fnt.setResolveMask(newMask);
 
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget*>(children.at(i));
        if (w) {
            if (0) {
#ifndef QT_NO_STYLE_STYLESHEET
            } else if (!useStyleSheetPropagationInWidgetStyles && w->testAttribute(Qt::WA_StyleSheet)) {
                // Style sheets follow a different font propagation scheme.
                if (cssStyle)
                    cssStyle->updateStyleSheetFont(w);
#endif
            } else if ((!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))) {
                // Propagate font changes.
                QWidgetPrivate *wd = w->d_func();
                wd->inheritedFontResolveMask = newMask;
                wd->resolveFont();
            }
        }
    }
 
#ifndef QT_NO_STYLE_STYLESHEET
    if (!useStyleSheetPropagationInWidgetStyles && cssStyle) {
        cssStyle->updateStyleSheetFont(q);
    }
#endif
 
    QEvent e(QEvent::FontChange);
    QCoreApplication::sendEvent(q, &e);
}
 
void QWidgetPrivate::setLayoutDirection_helper(Qt::LayoutDirection direction)
{
    Q_Q(QWidget);
 
    if ( (direction == Qt::RightToLeft) == q->testAttribute(Qt::WA_RightToLeft))
        return;
    q->setAttribute(Qt::WA_RightToLeft, (direction == Qt::RightToLeft));
    if (!children.isEmpty()) {
        for (int i = 0; i < children.size(); ++i) {
            QWidget *w = qobject_cast<QWidget*>(children.at(i));
            if (w && !w->isWindow() && !w->testAttribute(Qt::WA_SetLayoutDirection))
                w->d_func()->setLayoutDirection_helper(direction);
        }
    }
    QEvent e(QEvent::LayoutDirectionChange);
    QCoreApplication::sendEvent(q, &e);
}
 
void QWidgetPrivate::resolveLayoutDirection()
{
    Q_Q(const QWidget);
    if (!q->testAttribute(Qt::WA_SetLayoutDirection))
        setLayoutDirection_helper(q->isWindow() ? QGuiApplication::layoutDirection() : q->parentWidget()->layoutDirection());
}
 
void QWidget::setLayoutDirection(Qt::LayoutDirection direction)
{
    Q_D(QWidget);
 
    if (direction == Qt::LayoutDirectionAuto) {
        unsetLayoutDirection();
        return;
    }
 
    setAttribute(Qt::WA_SetLayoutDirection);
    d->setLayoutDirection_helper(direction);
}
 
Qt::LayoutDirection QWidget::layoutDirection() const
{
    return testAttribute(Qt::WA_RightToLeft) ? Qt::RightToLeft : Qt::LeftToRight;
}
 
void QWidget::unsetLayoutDirection()
{
    Q_D(QWidget);
    setAttribute(Qt::WA_SetLayoutDirection, false);
    d->resolveLayoutDirection();
}
 
#ifndef QT_NO_CURSOR
QCursor QWidget::cursor() const
{
    Q_D(const QWidget);
    if (testAttribute(Qt::WA_SetCursor))
        return (d->extra && d->extra->curs)
            ? *d->extra->curs
            : QCursor(Qt::ArrowCursor);
    if (isWindow() || !parentWidget())
        return QCursor(Qt::ArrowCursor);
    return parentWidget()->cursor();
}
 
void QWidget::setCursor(const QCursor &cursor)
{
    Q_D(QWidget);
    if (cursor.shape() != Qt::ArrowCursor
        || (d->extra && d->extra->curs))
    {
        d->createExtra();
        d->extra->curs = std::make_unique<QCursor>(cursor);
    }
    setAttribute(Qt::WA_SetCursor);
    d->setCursor_sys(cursor);
 
    QEvent event(QEvent::CursorChange);
    QCoreApplication::sendEvent(this, &event);
}
 
void QWidgetPrivate::setCursor_sys(const QCursor &cursor)
{
    Q_UNUSED(cursor);
    Q_Q(QWidget);
    qt_qpa_set_cursor(q, false);
}
 
void QWidget::unsetCursor()
{
    Q_D(QWidget);
    if (d->extra)
        d->extra->curs.reset();
    if (!isWindow())
        setAttribute(Qt::WA_SetCursor, false);
    d->unsetCursor_sys();
 
    QEvent event(QEvent::CursorChange);
    QCoreApplication::sendEvent(this, &event);
}
 
void QWidgetPrivate::unsetCursor_sys()
{
    Q_Q(QWidget);
    qt_qpa_set_cursor(q, false);
}
 
static inline void applyCursor(QWidget *w, const QCursor &c)
{
    if (QWindow *window = w->windowHandle())
        window->setCursor(c);
}
 
static inline void unsetCursor(QWidget *w)
{
    if (QWindow *window = w->windowHandle())
        window->unsetCursor();
}
 
void qt_qpa_set_cursor(QWidget *w, bool force)
{
    if (!w->testAttribute(Qt::WA_WState_Created))
        return;
 
    static QPointer<QWidget> lastUnderMouse = nullptr;
    if (force) {
        lastUnderMouse = w;
    } else if (lastUnderMouse) {
        const WId lastWinId = lastUnderMouse->effectiveWinId();
        const WId winId = w->effectiveWinId();
        if (lastWinId && lastWinId == winId)
            w = lastUnderMouse;
    } else if (!w->internalWinId()) {
        return; // The mouse is not under this widget, and it's not native, so don't change it.
    }
 
    while (!w->internalWinId() && w->parentWidget() && !w->isWindow()
           && !w->testAttribute(Qt::WA_SetCursor))
        w = w->parentWidget();
 
    QWidget *nativeParent = w;
    if (!w->internalWinId())
        nativeParent = w->nativeParentWidget();
    if (!nativeParent || !nativeParent->internalWinId())
        return;
 
    if (w->isWindow() || w->testAttribute(Qt::WA_SetCursor)) {
        if (w->isEnabled())
            applyCursor(nativeParent, w->cursor());
        else
            // Enforce the windows behavior of clearing the cursor on
            // disabled widgets.
            unsetCursor(nativeParent);
    } else {
        unsetCursor(nativeParent);
    }
}
#endif
 
void QWidget::render(QPaintDevice *target, const QPoint &targetOffset,
                     const QRegion &sourceRegion, RenderFlags renderFlags)
{
    QPainter p(target);
    render(&p, targetOffset, sourceRegion, renderFlags);
}
 
void QWidget::render(QPainter *painter, const QPoint &targetOffset,
                     const QRegion &sourceRegion, RenderFlags renderFlags)
{
    if (Q_UNLIKELY(!painter)) {
        qWarning("QWidget::render: Null pointer to painter");
        return;
    }
 
    if (Q_UNLIKELY(!painter->isActive())) {
        qWarning("QWidget::render: Cannot render with an inactive painter");
        return;
    }
 
    const qreal opacity = painter->opacity();
    if (qFuzzyIsNull(opacity))
        return; // Fully transparent.
 
    Q_D(QWidget);
    const bool inRenderWithPainter = d->extra && d->extra->inRenderWithPainter;
    const QRegion toBePainted = !inRenderWithPainter ? d->prepareToRender(sourceRegion, renderFlags)
                                                     : sourceRegion;
    if (toBePainted.isEmpty())
        return;
 
    if (!d->extra)
        d->createExtra();
    d->extra->inRenderWithPainter = true;
 
    QPaintEngine *engine = painter->paintEngine();
    Q_ASSERT(engine);
    QPaintEnginePrivate *enginePriv = engine->d_func();
    Q_ASSERT(enginePriv);
    QPaintDevice *target = engine->paintDevice();
    Q_ASSERT(target);
 
    // Render via a pixmap when dealing with non-opaque painters or printers.
    if (!inRenderWithPainter && (opacity < 1.0 || (target->devType() == QInternal::Printer))) {
        d->render_helper(painter, targetOffset, toBePainted, renderFlags);
        d->extra->inRenderWithPainter = inRenderWithPainter;
        return;
    }
 
    // Set new shared painter.
    QPainter *oldPainter = d->sharedPainter();
    d->setSharedPainter(painter);
 
    // Save current system clip, viewport and transform,
    const QTransform oldTransform = enginePriv->systemTransform;
    const QRegion oldSystemClip = enginePriv->systemClip;
    const QRegion oldBaseClip = enginePriv->baseSystemClip;
    const QRegion oldSystemViewport = enginePriv->systemViewport;
    const Qt::LayoutDirection oldLayoutDirection = painter->layoutDirection();
 
    // This ensures that all painting triggered by render() is clipped to the current engine clip.
    if (painter->hasClipping()) {
        const QRegion painterClip = painter->deviceTransform().map(painter->clipRegion());
        enginePriv->setSystemViewport(oldSystemClip.isEmpty() ? painterClip : oldSystemClip & painterClip);
    } else {
        enginePriv->setSystemViewport(oldSystemClip);
    }
    painter->setLayoutDirection(layoutDirection());
 
    d->render(target, targetOffset, toBePainted, renderFlags);
 
    // Restore system clip, viewport and transform.
    enginePriv->baseSystemClip = oldBaseClip;
    enginePriv->setSystemTransformAndViewport(oldTransform, oldSystemViewport);
    enginePriv->systemStateChanged();
    painter->setLayoutDirection(oldLayoutDirection);
 
    // Restore shared painter.
    d->setSharedPainter(oldPainter);
 
    d->extra->inRenderWithPainter = inRenderWithPainter;
}
 
static void sendResizeEvents(QWidget *target)
{
    QResizeEvent e(target->size(), QSize());
    QCoreApplication::sendEvent(target, &e);
 
    const QObjectList children = target->children();
    for (int i = 0; i < children.size(); ++i) {
        if (!children.at(i)->isWidgetType())
            continue;
        QWidget *child = static_cast<QWidget*>(children.at(i));
        if (!child->isWindow() && child->testAttribute(Qt::WA_PendingResizeEvent))
            sendResizeEvents(child);
    }
}
 
QPixmap QWidget::grab(const QRect &rectangle)
{
    Q_D(QWidget);
    if (testAttribute(Qt::WA_PendingResizeEvent) || !testAttribute(Qt::WA_WState_Created))
        sendResizeEvents(this);
 
    const QWidget::RenderFlags renderFlags = QWidget::DrawWindowBackground | QWidget::DrawChildren | QWidget::IgnoreMask;
 
    const bool oldDirtyOpaqueChildren =  d->dirtyOpaqueChildren;
    QRect r(rectangle);
    if (r.width() < 0 || r.height() < 0) {
        // For grabbing widgets that haven't been shown yet,
        // we trigger the layouting mechanism to determine the widget's size.
        r = d->prepareToRender(QRegion(), renderFlags).boundingRect();
        r.setTopLeft(rectangle.topLeft());
    }
 
    if (!r.intersects(rect()))
        return QPixmap();
 
    const qreal dpr = devicePixelRatio();
    QPixmap res((QSizeF(r.size()) * dpr).toSize());
    res.setDevicePixelRatio(dpr);
    if (!d->isOpaque)
        res.fill(Qt::transparent);
    d->render(&res, QPoint(), QRegion(r), renderFlags);
 
    d->dirtyOpaqueChildren = oldDirtyOpaqueChildren;
    return res;
}
 
#if QT_CONFIG(graphicseffect)
QGraphicsEffect *QWidget::graphicsEffect() const
{
    Q_D(const QWidget);
    return d->graphicsEffect;
}
#endif // QT_CONFIG(graphicseffect)
 
#if QT_CONFIG(graphicseffect)
void QWidget::setGraphicsEffect(QGraphicsEffect *effect)
{
    Q_D(QWidget);
    if (d->graphicsEffect == effect)
        return;
 
    if (d->graphicsEffect) {
        d->invalidateBackingStore(rect());
        delete d->graphicsEffect;
        d->graphicsEffect = nullptr;
    }
 
    if (effect) {
        // Set new effect.
        QGraphicsEffectSourcePrivate *sourced = new QWidgetEffectSourcePrivate(this);
        QGraphicsEffectSource *source = new QGraphicsEffectSource(*sourced);
        d->graphicsEffect = effect;
        effect->d_func()->setGraphicsEffectSource(source);
        update();
    }
 
    d->updateIsOpaque();
}
#endif // QT_CONFIG(graphicseffect)
 
bool QWidgetPrivate::isAboutToShow() const
{
    if (data.in_show)
        return true;
 
    Q_Q(const QWidget);
    if (q->isHidden())
        return false;
 
    // The widget will be shown if any of its ancestors are about to show.
    QWidget *parent = q->parentWidget();
    return parent ? parent->d_func()->isAboutToShow() : false;
}
 
QRegion QWidgetPrivate::prepareToRender(const QRegion &region, QWidget::RenderFlags renderFlags)
{
    Q_Q(QWidget);
    const bool isVisible = q->isVisible();
 
    // Make sure the widget is laid out correctly.
    if (!isVisible && !isAboutToShow()) {
        QWidget *topLevel = q->window();
        (void)topLevel->d_func()->topData(); // Make sure we at least have top-data.
        topLevel->ensurePolished();
 
        // Invalidate the layout of hidden ancestors (incl. myself) and pretend
        // they're not explicitly hidden.
        QWidget *widget = q;
        QWidgetList hiddenWidgets;
        while (widget) {
            if (widget->isHidden()) {
                widget->setAttribute(Qt::WA_WState_Hidden, false);
                hiddenWidgets.append(widget);
                if (!widget->isWindow() && widget->parentWidget()->d_func()->layout)
                    widget->d_func()->updateGeometry_helper(true);
            }
            widget = widget->parentWidget();
        }
 
        // Activate top-level layout.
        if (topLevel->d_func()->layout)
            topLevel->d_func()->layout->activate();
 
        // Adjust size if necessary.
        QTLWExtra *topLevelExtra = topLevel->d_func()->maybeTopData();
        if (topLevelExtra && !topLevelExtra->sizeAdjusted
            && !topLevel->testAttribute(Qt::WA_Resized)) {
            topLevel->adjustSize();
            topLevel->setAttribute(Qt::WA_Resized, false);
        }
 
        // Activate child layouts.
        topLevel->d_func()->activateChildLayoutsRecursively();
 
        // We're not cheating with WA_WState_Hidden anymore.
        for (int i = 0; i < hiddenWidgets.size(); ++i) {
            QWidget *widget = hiddenWidgets.at(i);
            widget->setAttribute(Qt::WA_WState_Hidden);
            if (!widget->isWindow() && widget->parentWidget()->d_func()->layout)
                widget->parentWidget()->d_func()->layout->invalidate();
        }
    } else if (isVisible) {
        q->window()->d_func()->sendPendingMoveAndResizeEvents(true, true);
    }
 
    // Calculate the region to be painted.
    QRegion toBePainted = !region.isEmpty() ? region : QRegion(q->rect());
    if (!(renderFlags & QWidget::IgnoreMask) && extra && extra->hasMask)
        toBePainted &= extra->mask;
    return toBePainted;
}
 
void QWidgetPrivate::render_helper(QPainter *painter, const QPoint &targetOffset, const QRegion &toBePainted,
                                   QWidget::RenderFlags renderFlags)
{
    Q_ASSERT(painter);
    Q_ASSERT(!toBePainted.isEmpty());
 
    Q_Q(QWidget);
    const QTransform originalTransform = painter->worldTransform();
    const bool useDeviceCoordinates = originalTransform.isScaling();
    if (!useDeviceCoordinates) {
        // Render via a pixmap.
        const QRect rect = toBePainted.boundingRect();
        const QSize size = rect.size();
        if (size.isNull())
            return;
 
        const qreal pixmapDevicePixelRatio = painter->device()->devicePixelRatio();
        QPixmap pixmap(size * pixmapDevicePixelRatio);
        pixmap.setDevicePixelRatio(pixmapDevicePixelRatio);
 
        if (!(renderFlags & QWidget::DrawWindowBackground) || !isOpaque)
            pixmap.fill(Qt::transparent);
        q->render(&pixmap, QPoint(), toBePainted, renderFlags);
 
        const bool restore = !(painter->renderHints() & QPainter::SmoothPixmapTransform);
        painter->setRenderHints(QPainter::SmoothPixmapTransform, true);
 
        painter->drawPixmap(targetOffset, pixmap);
 
        if (restore)
            painter->setRenderHints(QPainter::SmoothPixmapTransform, false);
 
    } else {
        // Render via a pixmap in device coordinates (to avoid pixmap scaling).
        QTransform transform = originalTransform;
        transform.translate(targetOffset.x(), targetOffset.y());
 
        QPaintDevice *device = painter->device();
        Q_ASSERT(device);
 
        // Calculate device rect.
        const QRectF rect(toBePainted.boundingRect());
        QRect deviceRect = transform.mapRect(QRectF(0, 0, rect.width(), rect.height())).toAlignedRect();
        deviceRect &= QRect(0, 0, device->width(), device->height());
 
        QPixmap pixmap(deviceRect.size());
        pixmap.fill(Qt::transparent);
 
        // Create a pixmap device coordinate painter.
        QPainter pixmapPainter(&pixmap);
        pixmapPainter.setRenderHints(painter->renderHints());
        transform *= QTransform::fromTranslate(-deviceRect.x(), -deviceRect.y());
        pixmapPainter.setTransform(transform);
 
        q->render(&pixmapPainter, QPoint(), toBePainted, renderFlags);
        pixmapPainter.end();
 
        // And then draw the pixmap.
        painter->setTransform(QTransform());
        painter->drawPixmap(deviceRect.topLeft(), pixmap);
        painter->setTransform(originalTransform);
    }
}
 
void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QPoint &offset, DrawWidgetFlags flags,
                                QPainter *sharedPainter, QWidgetRepaintManager *repaintManager)
{
    if (rgn.isEmpty())
        return;
 
    Q_Q(QWidget);
 
    qCInfo(lcWidgetPainting) << "Drawing" << rgn << "of" << q << "at" << offset
        << "into paint device" << pdev << "with" << flags;
 
    const bool asRoot = flags & DrawAsRoot;
    bool onScreen = shouldPaintOnScreen();
 
#if QT_CONFIG(graphicseffect)
    if (graphicsEffect && graphicsEffect->isEnabled()) {
        QGraphicsEffectSource *source = graphicsEffect->d_func()->source;
        QWidgetEffectSourcePrivate *sourced = static_cast<QWidgetEffectSourcePrivate *>
                                                         (source->d_func());
        if (!sourced->context) {
            const QRegion effectRgn((flags & UseEffectRegionBounds) ? rgn.boundingRect() : rgn);
            QWidgetPaintContext context(pdev, effectRgn, offset, flags, sharedPainter, repaintManager);
            sourced->context = &context;
            if (!sharedPainter) {
                setSystemClip(pdev->paintEngine(), pdev->devicePixelRatio(), effectRgn.translated(offset));
                QPainter p(pdev);
                p.translate(offset);
                context.painter = &p;
                graphicsEffect->draw(&p);
                setSystemClip(pdev->paintEngine(), 1, QRegion());
            } else {
                context.painter = sharedPainter;
                if (sharedPainter->worldTransform() != sourced->lastEffectTransform) {
                    sourced->invalidateCache();
                    sourced->lastEffectTransform = sharedPainter->worldTransform();
                }
                sharedPainter->save();
                sharedPainter->translate(offset);
                setSystemClip(sharedPainter->paintEngine(), sharedPainter->device()->devicePixelRatio(), effectRgn.translated(offset));
                graphicsEffect->draw(sharedPainter);
                setSystemClip(sharedPainter->paintEngine(), 1, QRegion());
                sharedPainter->restore();
            }
            sourced->context = nullptr;
 
            if (repaintManager)
                repaintManager->markNeedsFlush(q, effectRgn, offset);
 
            return;
        }
    }
#endif // QT_CONFIG(graphicseffect)
    flags = flags & ~UseEffectRegionBounds;
 
    const bool alsoOnScreen = flags & DrawPaintOnScreen;
    const bool recursive = flags & DrawRecursive;
    const bool alsoInvisible = flags & DrawInvisible;
 
    Q_ASSERT(sharedPainter ? sharedPainter->isActive() : true);
 
    QRegion toBePainted(rgn);
    if (asRoot && !alsoInvisible)
        toBePainted &= clipRect(); //(rgn & visibleRegion());
    if (!(flags & DontSubtractOpaqueChildren))
        subtractOpaqueChildren(toBePainted, q->rect());
 
    if (!toBePainted.isEmpty()) {
        if (!onScreen || alsoOnScreen) {
            //update the "in paint event" flag
            if (Q_UNLIKELY(q->testAttribute(Qt::WA_WState_InPaintEvent)))
                qWarning("QWidget::repaint: Recursive repaint detected");
            q->setAttribute(Qt::WA_WState_InPaintEvent);
 
            //clip away the new area
            QPaintEngine *paintEngine = pdev->paintEngine();
            if (paintEngine) {
                setRedirected(pdev, -offset);
 
                if (sharedPainter)
                    setSystemClip(pdev->paintEngine(), pdev->devicePixelRatio(), toBePainted);
                else
                    paintEngine->d_func()->systemRect = q->data->crect;
 
                //paint the background
                if ((asRoot || q->autoFillBackground() || onScreen || q->testAttribute(Qt::WA_StyledBackground))
                    && !q->testAttribute(Qt::WA_OpaquePaintEvent) && !q->testAttribute(Qt::WA_NoSystemBackground)) {
                    beginBackingStorePainting();
                    QPainter p(q);
                    p.setRenderHint(QPainter::SmoothPixmapTransform);
                    paintBackground(&p, toBePainted, (asRoot || onScreen) ? (flags | DrawAsRoot) : DrawWidgetFlags());
                    endBackingStorePainting();
                }
 
                if (!sharedPainter)
                    setSystemClip(pdev->paintEngine(), pdev->devicePixelRatio(), toBePainted.translated(offset));
 
                if (!onScreen && !asRoot && !isOpaque && q->testAttribute(Qt::WA_TintedBackground)) {
                    beginBackingStorePainting();
                    QPainter p(q);
                    QColor tint = q->palette().window().color();
                    tint.setAlphaF(.6f);
                    p.fillRect(toBePainted.boundingRect(), tint);
                    endBackingStorePainting();
                }
            }
 
#if 0
            qDebug() << "painting" << q << "opaque ==" << isOpaque();
            qDebug() << "clipping to" << toBePainted << "location == " << offset
                     << "geometry ==" << QRect(q->mapTo(q->window(), QPoint(0, 0)), q->size());
#endif
 
            bool skipPaintEvent = false;
            if (renderToTexture) {
                // This widget renders into a texture which is composed later. We just need to
                // punch a hole in the backingstore, so the texture will be visible.
                beginBackingStorePainting();
                if (!q->testAttribute(Qt::WA_AlwaysStackOnTop) && repaintManager) {
                    QPainter p(q);
                    p.setCompositionMode(QPainter::CompositionMode_Source);
                    p.fillRect(q->rect(), Qt::transparent);
                } else if (!repaintManager) {
                    // We are not drawing to a backingstore: fall back to QImage
                    QImage img = grabFramebuffer();
                    // grabFramebuffer() always sets the format to RGB32
                    // regardless of whether it is transparent or not.
                    if (img.format() == QImage::Format_RGB32)
                        img.reinterpretAsFormat(QImage::Format_ARGB32_Premultiplied);
                    QPainter p(q);
                    p.drawImage(q->rect(), img);
                    skipPaintEvent = true;
                }
                endBackingStorePainting();
                if (renderToTextureReallyDirty)
                    renderToTextureReallyDirty = 0;
                else
                    skipPaintEvent = true;
            }
 
            if (!skipPaintEvent) {
                //actually send the paint event
                sendPaintEvent(toBePainted);
            }
 
            if (repaintManager)
                repaintManager->markNeedsFlush(q, toBePainted, offset);
 
            //restore
            if (paintEngine) {
                restoreRedirected();
                if (!sharedPainter)
                    paintEngine->d_func()->systemRect = QRect();
                else
                    paintEngine->d_func()->currentClipDevice = nullptr;
 
                setSystemClip(pdev->paintEngine(), 1, QRegion());
            }
            q->setAttribute(Qt::WA_WState_InPaintEvent, false);
            if (Q_UNLIKELY(q->paintingActive()))
                qWarning("QWidget::repaint: It is dangerous to leave painters active on a widget outside of the PaintEvent");
 
            if (paintEngine && paintEngine->autoDestruct()) {
                delete paintEngine;
            }
        } else if (q->isWindow()) {
            QPaintEngine *engine = pdev->paintEngine();
            if (engine) {
                QPainter p(pdev);
                p.setClipRegion(toBePainted);
                const QBrush bg = q->palette().brush(QPalette::Window);
                if (bg.style() == Qt::TexturePattern)
                    p.drawTiledPixmap(q->rect(), bg.texture());
                else
                    p.fillRect(q->rect(), bg);
 
                if (engine->autoDestruct())
                    delete engine;
            }
        }
    }
 
    if (recursive && !children.isEmpty()) {
        paintSiblingsRecursive(pdev, children, children.size() - 1, rgn, offset, flags & ~DrawAsRoot,
                               sharedPainter, repaintManager);
    }
}
 
void QWidgetPrivate::sendPaintEvent(const QRegion &toBePainted)
{
    Q_Q(QWidget);
    QPaintEvent e(toBePainted);
    QCoreApplication::sendSpontaneousEvent(q, &e);
 
    if (renderToTexture)
        resolveSamples();
}
 
void QWidgetPrivate::render(QPaintDevice *target, const QPoint &targetOffset,
                            const QRegion &sourceRegion, QWidget::RenderFlags renderFlags)
{
    if (Q_UNLIKELY(!target)) {
        qWarning("QWidget::render: null pointer to paint device");
        return;
    }
 
    const bool inRenderWithPainter = extra && extra->inRenderWithPainter;
    QRegion paintRegion = !inRenderWithPainter
                          ? prepareToRender(sourceRegion, renderFlags)
                          : sourceRegion;
    if (paintRegion.isEmpty())
        return;
 
    QPainter *oldSharedPainter = inRenderWithPainter ? sharedPainter() : nullptr;
 
    // Use the target's shared painter if set (typically set when doing
    // "other->render(widget);" in the widget's paintEvent.
    if (target->devType() == QInternal::Widget) {
        QWidgetPrivate *targetPrivate = static_cast<QWidget *>(target)->d_func();
        if (targetPrivate->extra && targetPrivate->extra->inRenderWithPainter) {
            QPainter *targetPainter = targetPrivate->sharedPainter();
            if (targetPainter && targetPainter->isActive())
                setSharedPainter(targetPainter);
        }
    }
 
    // Use the target's redirected device if set and adjust offset and paint
    // region accordingly. This is typically the case when people call render
    // from the paintEvent.
    QPoint offset = targetOffset;
    offset -= paintRegion.boundingRect().topLeft();
    QPoint redirectionOffset;
    QPaintDevice *redirected = nullptr;
 
    if (target->devType() == QInternal::Widget)
        redirected = static_cast<QWidget *>(target)->d_func()->redirected(&redirectionOffset);
 
    if (redirected) {
        target = redirected;
        offset -= redirectionOffset;
    }
 
    if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
        if (QPaintEngine *targetEngine = target->paintEngine()) {
            const QRegion targetSystemClip = targetEngine->systemClip();
            if (!targetSystemClip.isEmpty())
                paintRegion &= targetSystemClip.translated(-offset);
        }
    }
 
    // Set backingstore flags.
    DrawWidgetFlags flags = DrawPaintOnScreen | DrawInvisible;
    if (renderFlags & QWidget::DrawWindowBackground)
        flags |= DrawAsRoot;
 
    if (renderFlags & QWidget::DrawChildren)
        flags |= DrawRecursive;
    else
        flags |= DontSubtractOpaqueChildren;
 
    flags |= DontSetCompositionMode;
 
    // Render via backingstore.
    drawWidget(target, paintRegion, offset, flags, sharedPainter());
 
    // Restore shared painter.
    if (oldSharedPainter)
        setSharedPainter(oldSharedPainter);
}
 
void QWidgetPrivate::paintSiblingsRecursive(QPaintDevice *pdev, const QObjectList& siblings, int index, const QRegion &rgn,
                                            const QPoint &offset, DrawWidgetFlags flags
                                            , QPainter *sharedPainter, QWidgetRepaintManager *repaintManager)
{
    QWidget *w = nullptr;
    QRect boundingRect;
    bool dirtyBoundingRect = true;
    const bool exludeOpaqueChildren = (flags & DontDrawOpaqueChildren);
    const bool excludeNativeChildren = (flags & DontDrawNativeChildren);
 
    do {
        QWidget *x =  qobject_cast<QWidget*>(siblings.at(index));
        if (x && !(exludeOpaqueChildren && x->d_func()->isOpaque) && !x->isHidden() && !x->isWindow()
            && !(excludeNativeChildren && x->internalWinId())) {
            if (dirtyBoundingRect) {
                boundingRect = rgn.boundingRect();
                dirtyBoundingRect = false;
            }
 
            if (qRectIntersects(boundingRect, x->d_func()->effectiveRectFor(x->data->crect))) {
                w = x;
                break;
            }
        }
        --index;
    } while (index >= 0);
 
    if (!w)
        return;
 
    QWidgetPrivate *wd = w->d_func();
    const QPoint widgetPos(w->data->crect.topLeft());
    const bool hasMask = wd->extra && wd->extra->hasMask && !wd->graphicsEffect;
    if (index > 0) {
        QRegion wr(rgn);
        if (wd->isOpaque)
            wr -= hasMask ? wd->extra->mask.translated(widgetPos) : w->data->crect;
        paintSiblingsRecursive(pdev, siblings, --index, wr, offset, flags,
                               sharedPainter, repaintManager);
    }
 
    if (w->updatesEnabled()
#if QT_CONFIG(graphicsview)
            && (!w->d_func()->extra || !w->d_func()->extra->proxyWidget)
#endif // QT_CONFIG(graphicsview)
       ) {
        QRegion wRegion(rgn);
        wRegion &= wd->effectiveRectFor(w->data->crect);
        wRegion.translate(-widgetPos);
        if (hasMask)
            wRegion &= wd->extra->mask;
        wd->drawWidget(pdev, wRegion, offset + widgetPos, flags, sharedPainter, repaintManager);
    }
}
 
#if QT_CONFIG(graphicseffect)
QRectF QWidgetEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
{
    if (system != Qt::DeviceCoordinates)
        return m_widget->rect();
 
    if (Q_UNLIKELY(!context)) {
        // Device coordinates without context not yet supported.
        qWarning("QGraphicsEffectSource::boundingRect: Not yet implemented, lacking device context");
        return QRectF();
    }
 
    return context->painter->worldTransform().mapRect(m_widget->rect());
}
 
void QWidgetEffectSourcePrivate::draw(QPainter *painter)
{
    if (!context || context->painter != painter) {
        m_widget->render(painter);
        return;
    }
 
    // The region saved in the context is neither clipped to the rect
    // nor the mask, so we have to clip it here before calling drawWidget.
    QRegion toBePainted = context->rgn;
    toBePainted &= m_widget->rect();
    QWidgetPrivate *wd = qt_widget_private(m_widget);
    if (wd->extra && wd->extra->hasMask)
        toBePainted &= wd->extra->mask;
 
    wd->drawWidget(context->pdev, toBePainted, context->offset, context->flags,
                   context->sharedPainter, context->repaintManager);
}
 
QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
                                           QGraphicsEffect::PixmapPadMode mode) const
{
    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
    if (Q_UNLIKELY(!context && deviceCoordinates)) {
        // Device coordinates without context not yet supported.
        qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
        return QPixmap();
    }
 
    QPoint pixmapOffset;
    QRectF sourceRect = m_widget->rect();
 
    if (deviceCoordinates) {
        const QTransform &painterTransform = context->painter->worldTransform();
        sourceRect = painterTransform.mapRect(sourceRect);
        pixmapOffset = painterTransform.map(pixmapOffset);
    }
 
    QRect effectRect;
 
    if (mode == QGraphicsEffect::PadToEffectiveBoundingRect)
        effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
    else if (mode == QGraphicsEffect::PadToTransparentBorder)
        effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
    else
        effectRect = sourceRect.toAlignedRect();
 
    if (offset)
        *offset = effectRect.topLeft();
 
    pixmapOffset -= effectRect.topLeft();
 
    qreal dpr(1.0);
    if (const auto *paintDevice = context->painter->device())
        dpr = paintDevice->devicePixelRatio();
    else
        qWarning("QWidgetEffectSourcePrivate::pixmap: Painter not active");
    QPixmap pixmap(effectRect.size() * dpr);
    pixmap.setDevicePixelRatio(dpr);
 
    pixmap.fill(Qt::transparent);
    m_widget->render(&pixmap, pixmapOffset, QRegion(), QWidget::DrawChildren);
    return pixmap;
}
#endif // QT_CONFIG(graphicseffect)
 
#if QT_CONFIG(graphicsview)
QGraphicsProxyWidget *QWidgetPrivate::nearestGraphicsProxyWidget(const QWidget *origin)
{
    if (origin) {
        const auto &extra = origin->d_func()->extra;
        if (extra && extra->proxyWidget)
            return extra->proxyWidget;
        return nearestGraphicsProxyWidget(origin->parentWidget());
    }
    return nullptr;
}
#endif
 
void QWidgetPrivate::setLocale_helper(const QLocale &loc, bool forceUpdate)
{
    Q_Q(QWidget);
    if (locale == loc && !forceUpdate)
        return;
 
    locale = loc;
 
    if (!children.isEmpty()) {
        for (int i = 0; i < children.size(); ++i) {
            QWidget *w = qobject_cast<QWidget*>(children.at(i));
            if (!w)
                continue;
            if (w->testAttribute(Qt::WA_SetLocale))
                continue;
            if (w->isWindow() && !w->testAttribute(Qt::WA_WindowPropagation))
                continue;
            w->d_func()->setLocale_helper(loc, forceUpdate);
        }
    }
    QEvent e(QEvent::LocaleChange);
    QCoreApplication::sendEvent(q, &e);
}
 
void QWidget::setLocale(const QLocale &locale)
{
    Q_D(QWidget);
 
    setAttribute(Qt::WA_SetLocale);
    d->setLocale_helper(locale);
}
 
QLocale QWidget::locale() const
{
    Q_D(const QWidget);
 
    return d->locale;
}
 
void QWidgetPrivate::resolveLocale()
{
    Q_Q(const QWidget);
 
    if (!q->testAttribute(Qt::WA_SetLocale)) {
        QWidget *parent = q->parentWidget();
        setLocale_helper(!parent || (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation))
                         ? QLocale() : parent->locale());
    }
}
 
void QWidget::unsetLocale()
{
    Q_D(QWidget);
    setAttribute(Qt::WA_SetLocale, false);
    d->resolveLocale();
}
 
QString QWidget::windowTitle() const
{
    Q_D(const QWidget);
    if (d->extra && d->extra->topextra) {
        if (!d->extra->topextra->caption.isEmpty())
            return d->extra->topextra->caption;
        if (!d->extra->topextra->filePath.isEmpty())
            return QFileInfo(d->extra->topextra->filePath).fileName() + "[*]"_L1;
    }
    return QString();
}
 
QString qt_setWindowTitle_helperHelper(const QString &title, const QWidget *widget)
{
    Q_ASSERT(widget);
 
    QString cap = title;
    if (cap.isEmpty())
        return cap;
 
    const auto placeHolder = "[*]"_L1;
    int index = cap.indexOf(placeHolder);
 
    // here the magic begins
    while (index != -1) {
        index += placeHolder.size();
        int count = 1;
        while (cap.indexOf(placeHolder, index) == index) {
            ++count;
            index += placeHolder.size();
        }
 
        if (count%2) { // odd number of [*] -> replace last one
            int lastIndex = cap.lastIndexOf(placeHolder, index - 1);
            if (widget->isWindowModified()
             && widget->style()->styleHint(QStyle::SH_TitleBar_ModifyNotification, nullptr, widget))
                cap.replace(lastIndex, 3, QWidget::tr("*"));
            else
                cap.remove(lastIndex, 3);
        }
 
        index = cap.indexOf(placeHolder, index);
    }
 
    cap.replace("[*][*]"_L1, placeHolder);
 
    return cap;
}
 
void QWidgetPrivate::setWindowTitle_helper(const QString &title)
{
    Q_Q(QWidget);
    if (q->testAttribute(Qt::WA_WState_Created))
        setWindowTitle_sys(qt_setWindowTitle_helperHelper(title, q));
}
 
void QWidgetPrivate::setWindowTitle_sys(const QString &caption)
{
    Q_Q(QWidget);
    if (!q->isWindow())
        return;
 
    if (QWindow *window = q->windowHandle())
        window->setTitle(caption);
 
}
 
void QWidgetPrivate::setWindowIconText_helper(const QString &title)
{
    Q_Q(QWidget);
    if (q->testAttribute(Qt::WA_WState_Created))
        setWindowIconText_sys(qt_setWindowTitle_helperHelper(title, q));
}
 
void QWidgetPrivate::setWindowIconText_sys(const QString &iconText)
{
#if QT_CONFIG(xcb)
    Q_Q(QWidget);
    // ### The QWidget property is deprecated, but the XCB window function is not.
    // It should remain available for the rare application that needs it.
    if (QWindow *window = q->windowHandle()) {
        if (auto *xcbWindow = dynamic_cast<QXcbWindow*>(window->handle()))
            xcbWindow->setWindowIconText(iconText);
    }
#else
    Q_UNUSED(iconText);
#endif
}
 
void QWidget::setWindowIconText(const QString &iconText)
{
    if (QWidget::windowIconText() == iconText)
        return;
 
    Q_D(QWidget);
    d->topData()->iconText = iconText;
    d->setWindowIconText_helper(iconText);
 
    QEvent e(QEvent::IconTextChange);
    QCoreApplication::sendEvent(this, &e);
 
    emit windowIconTextChanged(iconText);
}
 
void QWidget::setWindowTitle(const QString &title)
{
    if (QWidget::windowTitle() == title && !title.isEmpty() && !title.isNull())
        return;
 
#if QT_CONFIG(accessibility)
    QString oldAccessibleName;
    const QAccessibleInterface *accessible = QAccessible::queryAccessibleInterface(this);
    if (accessible)
        oldAccessibleName = accessible->text(QAccessible::Name);
#endif
 
    Q_D(QWidget);
    d->topData()->caption = title;
    d->setWindowTitle_helper(title);
 
    QEvent e(QEvent::WindowTitleChange);
    QCoreApplication::sendEvent(this, &e);
 
    emit windowTitleChanged(title);
 
#if QT_CONFIG(accessibility)
    if (accessible && accessible->text(QAccessible::Name) != oldAccessibleName) {
        QAccessibleEvent event(this, QAccessible::NameChanged);
        QAccessible::updateAccessibility(&event);
    }
#endif
}
 
 
QIcon QWidget::windowIcon() const
{
    const QWidget *w = this;
    while (w) {
        const QWidgetPrivate *d = w->d_func();
        if (d->extra && d->extra->topextra && d->extra->topextra->icon)
            return *d->extra->topextra->icon;
        w = w->parentWidget();
    }
    return QApplication::windowIcon();
}
 
void QWidgetPrivate::setWindowIcon_helper()
{
    Q_Q(QWidget);
    QEvent e(QEvent::WindowIconChange);
 
    // Do not send the event if the widget is a top level.
    // In that case, setWindowIcon_sys does it, and event propagation from
    // QWidgetWindow to the top level QWidget ensures that the event reaches
    // the top level anyhow
    if (!q->windowHandle())
        QCoreApplication::sendEvent(q, &e);
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(children.at(i));
        if (w && !w->isWindow())
            QCoreApplication::sendEvent(w, &e);
    }
}
 
void QWidget::setWindowIcon(const QIcon &icon)
{
    Q_D(QWidget);
 
    setAttribute(Qt::WA_SetWindowIcon, !icon.isNull());
    d->createTLExtra();
 
    if (!d->extra->topextra->icon)
        d->extra->topextra->icon = std::make_unique<QIcon>(icon);
    else
        *d->extra->topextra->icon = icon;
 
    d->setWindowIcon_sys();
    d->setWindowIcon_helper();
 
    emit windowIconChanged(icon);
}
 
void QWidgetPrivate::setWindowIcon_sys()
{
    Q_Q(QWidget);
    if (QWindow *window = q->windowHandle())
        window->setIcon(q->windowIcon());
}
 
QString QWidget::windowIconText() const
{
    Q_D(const QWidget);
    return (d->extra && d->extra->topextra) ? d->extra->topextra->iconText : QString();
}
 
QString QWidget::windowFilePath() const
{
    Q_D(const QWidget);
    return (d->extra && d->extra->topextra) ? d->extra->topextra->filePath : QString();
}
 
void QWidget::setWindowFilePath(const QString &filePath)
{
    if (filePath == windowFilePath())
        return;
 
    Q_D(QWidget);
 
    d->createTLExtra();
    d->extra->topextra->filePath = filePath;
    d->setWindowFilePath_helper(filePath);
}
 
void QWidgetPrivate::setWindowFilePath_helper(const QString &filePath)
{
    if (extra->topextra && extra->topextra->caption.isEmpty()) {
#ifdef Q_OS_MAC
        setWindowTitle_helper(QFileInfo(filePath).fileName());
#else
        Q_Q(QWidget);
        Q_UNUSED(filePath);
        setWindowTitle_helper(q->windowTitle());
#endif
    }
#ifdef Q_OS_MAC
    setWindowFilePath_sys(filePath);
#endif
}
 
void QWidgetPrivate::setWindowFilePath_sys(const QString &filePath)
{
    Q_Q(QWidget);
    if (!q->isWindow())
        return;
 
    if (QWindow *window = q->windowHandle())
        window->setFilePath(filePath);
}
 
QString QWidget::windowRole() const
{
    Q_D(const QWidget);
    return (d->extra && d->extra->topextra) ? d->extra->topextra->role : QString();
}
 
void QWidget::setWindowRole(const QString &role)
{
#if QT_CONFIG(xcb)
    Q_D(QWidget);
    d->createTLExtra();
    d->topData()->role = role;
    if (windowHandle()) {
        if (auto *xcbWindow = dynamic_cast<QXcbWindow*>(windowHandle()->handle()))
            xcbWindow->setWindowRole(role);
    }
#else
    Q_UNUSED(role);
#endif
}
 
void QWidget::setFocusProxy(QWidget * w)
{
    Q_D(QWidget);
    if (!w && !d->extra)
        return;
 
    for (QWidget* fp  = w; fp; fp = fp->focusProxy()) {
        if (Q_UNLIKELY(fp == this)) {
            qWarning("QWidget: %s (%s) already in focus proxy chain", metaObject()->className(), objectName().toLocal8Bit().constData());
            return;
        }
    }
 
    const bool moveFocusToProxy = (QApplicationPrivate::focus_widget == this);
 
    d->createExtra();
    d->extra->focus_proxy = w;
 
    if (w && isAncestorOf(w)) {
        // If the focus proxy is a child of this (so this is a compound widget), then
        // we need to make sure that this widget is immediately in front of its own children
        // in the focus chain. Otherwise focusNextPrev_helper might jump over unrelated
        // widgets that are positioned between this compound widget, and its proxy in
        // the focus chain.
        const QWidget *parentOfW = w->parentWidget();
        Q_ASSERT(parentOfW); // can't be nullptr since we are an ancestor of w
        QWidget *firstChild = nullptr;
        const auto childList = children();
        for (QObject *child : childList) {
            if ((firstChild = qobject_cast<QWidget *>(child)))
                break;
        }
        Q_ASSERT(firstChild); // can't be nullptr since w is a child
        d->insertIntoFocusChainBefore(firstChild);
    } else if (w && w->isAncestorOf(this)) {
        // If the focus proxy is a parent, 'this' has to be inserted directly after its parent in the focus chain
        // remove it from the chain and insert this into the focus chain after its parent
 
        // is this the case already?
        QWidget *parentsNext = w->nextInFocusChain();
        if (parentsNext == this) {
            // nothing to do.
            Q_ASSERT(previousInFocusChain() == w);
        } else {
            d->QWidgetPrivate::insertIntoFocusChainAfter(w);
        }
    }
 
    if (moveFocusToProxy)
        setFocus(Qt::OtherFocusReason);
}
 
 
QWidget *QWidget::focusProxy() const
{
    Q_D(const QWidget);
    return d->extra ? d->extra->focus_proxy.data() : nullptr;
}
 
 
bool QWidget::hasFocus() const
{
    const QWidget* w = this;
    while (w->d_func()->extra && w->d_func()->extra->focus_proxy)
        w = w->d_func()->extra->focus_proxy;
#if QT_CONFIG(graphicsview)
    if (QWidget *window = w->window()) {
        const auto &e = window->d_func()->extra;
        if (e && e->proxyWidget && e->proxyWidget->hasFocus() && window->focusWidget() == w)
            return true;
    }
#endif // QT_CONFIG(graphicsview)
    return (QApplication::focusWidget() == w);
}
 
void QWidget::setFocus(Qt::FocusReason reason)
{
    if (!isEnabled())
        return;
 
    QWidget *f = d_func()->deepestFocusProxy();
    if (!f)
        f = this;
 
    if (QApplication::focusWidget() == f)
        return;
 
#if QT_CONFIG(graphicsview)
    QWidget *previousProxyFocus = nullptr;
    if (const auto &topData = window()->d_func()->extra) {
        if (topData->proxyWidget && topData->proxyWidget->hasFocus()) {
            previousProxyFocus = topData->proxyWidget->widget()->focusWidget();
            if (previousProxyFocus && previousProxyFocus->focusProxy())
                previousProxyFocus = previousProxyFocus->focusProxy();
            if (previousProxyFocus == f && !topData->proxyWidget->d_func()->proxyIsGivingFocus)
                return;
        }
    }
#endif
 
#if QT_CONFIG(graphicsview)
    // Update proxy state
    if (const auto &topData = window()->d_func()->extra) {
        if (topData->proxyWidget && !topData->proxyWidget->hasFocus()) {
            f->d_func()->updateFocusChild();
            topData->proxyWidget->d_func()->focusFromWidgetToProxy = 1;
            topData->proxyWidget->setFocus(reason);
            topData->proxyWidget->d_func()->focusFromWidgetToProxy = 0;
        }
    }
#endif
 
    if (f->isActiveWindow()) {
        QWidget *prev = QApplicationPrivate::focus_widget;
        if (prev) {
            if (reason != Qt::PopupFocusReason && reason != Qt::MenuBarFocusReason
                && prev->testAttribute(Qt::WA_InputMethodEnabled)) {
                QGuiApplication::inputMethod()->commit();
            }
 
            if (reason != Qt::NoFocusReason) {
                QFocusEvent focusAboutToChange(QEvent::FocusAboutToChange, reason);
                QCoreApplication::sendEvent(prev, &focusAboutToChange);
            }
        }
 
        f->d_func()->updateFocusChild();
 
        QApplicationPrivate::setFocusWidget(f, reason);
#if QT_CONFIG(accessibility)
        // menus update the focus manually and this would create bogus events
        if (!(f->inherits("QMenuBar") || f->inherits("QMenu") || f->inherits("QMenuItem")))
        {
            QAccessibleEvent event(f, QAccessible::Focus);
            QAccessible::updateAccessibility(&event);
        }
#endif
#if QT_CONFIG(graphicsview)
        if (const auto &topData = window()->d_func()->extra) {
            if (topData->proxyWidget) {
                if (previousProxyFocus && previousProxyFocus != f) {
                    // Send event to self
                    QFocusEvent event(QEvent::FocusOut, reason);
                    QPointer<QWidget> that = previousProxyFocus;
                    QCoreApplication::sendEvent(previousProxyFocus, &event);
                    if (that)
                        QCoreApplication::sendEvent(that->style(), &event);
                }
                if (!isHidden()) {
#if QT_CONFIG(graphicsview)
                    // Update proxy state
                    if (const auto &topData = window()->d_func()->extra)
                        if (topData->proxyWidget && topData->proxyWidget->hasFocus())
                            topData->proxyWidget->d_func()->updateProxyInputMethodAcceptanceFromWidget();
#endif
                    // Send event to self
                    QFocusEvent event(QEvent::FocusIn, reason);
                    QPointer<QWidget> that = f;
                    QCoreApplication::sendEvent(f, &event);
                    if (that)
                        QCoreApplication::sendEvent(that->style(), &event);
                }
            }
        }
#endif
    } else {
        f->d_func()->updateFocusChild();
    }
}
 
 
QWidget *QWidgetPrivate::deepestFocusProxy() const
{
    Q_Q(const QWidget);
 
    QWidget *focusProxy = q->focusProxy();
    if (!focusProxy)
        return nullptr;
 
    while (QWidget *nextFocusProxy = focusProxy->focusProxy())
        focusProxy = nextFocusProxy;
 
    return focusProxy;
}
 
static inline bool isEmbedded(const QWindow *w)
{
     const auto platformWindow = w->handle();
     return platformWindow && platformWindow->isEmbedded();
}
 
void QWidgetPrivate::setFocus_sys()
{
    Q_Q(QWidget);
    // Embedded native widget may have taken the focus; get it back to toplevel
    // if that is the case (QTBUG-25852), unless widget is a window container.
    if (extra && extra->hasWindowContainer)
        return;
    // Do not activate in case the popup menu opens another application (QTBUG-70810)
    // unless the application is embedded (QTBUG-71991).
    if (QWindow *nativeWindow = q->testAttribute(Qt::WA_WState_Created) ? q->window()->windowHandle() : nullptr) {
        if (nativeWindow->type() != Qt::Popup && nativeWindow != QGuiApplication::focusWindow()
            && (QGuiApplication::applicationState() == Qt::ApplicationActive
                || QCoreApplication::testAttribute(Qt::AA_PluginApplication)
                || isEmbedded(nativeWindow))) {
            nativeWindow->requestActivate();
        }
    }
}
 
// updates focus_child on parent widgets to point into this widget
void QWidgetPrivate::updateFocusChild()
{
    Q_Q(QWidget);
 
    QWidget *w = q;
    if (q->isHidden()) {
        while (w && w->isHidden()) {
            w->d_func()->focus_child = q;
            w = w->isWindow() ? nullptr : w->parentWidget();
        }
    } else {
        while (w) {
            w->d_func()->focus_child = q;
            w = w->isWindow() ? nullptr : w->parentWidget();
        }
    }
 
    if (QTLWExtra *extra = q->window()->d_func()->maybeTopData()) {
        if (extra->window)
            emit extra->window->focusObjectChanged(q);
    }
}
 
void QWidget::clearFocus()
{
    if (hasFocus()) {
        if (testAttribute(Qt::WA_InputMethodEnabled))
            QGuiApplication::inputMethod()->commit();
 
        QFocusEvent focusAboutToChange(QEvent::FocusAboutToChange);
        QCoreApplication::sendEvent(this, &focusAboutToChange);
    }
 
    QTLWExtra *extra = window()->d_func()->maybeTopData();
    QObject *originalFocusObject = nullptr;
    if (extra && extra->window) {
        originalFocusObject = extra->window->focusObject();
        // the window's focus object might already be nullptr if we are in the destructor, but we still
        // need to update QGuiApplication and input context if we have a focus widget.
        if (!originalFocusObject)
            originalFocusObject = focusWidget();
    }
 
    QWidget *w = this;
    while (w) {
        // Just like setFocus(), we update (clear) the focus_child of our parents
        if (w->d_func()->focus_child == this)
            w->d_func()->focus_child = nullptr;
        w = w->parentWidget();
    }
 
    // We've potentially cleared the focus_child of our parents, so we need
    // to report this to the rest of Qt. Note that the focus_child is not the same
    // thing as the application's focusWidget, which is why this piece of code is
    // not inside a hasFocus() block.
    if (originalFocusObject && originalFocusObject != extra->window->focusObject())
        emit extra->window->focusObjectChanged(extra->window->focusObject());
 
#if QT_CONFIG(graphicsview)
    const auto &topData = d_func()->extra;
    if (topData && topData->proxyWidget)
        topData->proxyWidget->clearFocus();
#endif
 
    if (hasFocus()) {
        // Update proxy state
        QApplicationPrivate::setFocusWidget(nullptr, Qt::OtherFocusReason);
#if QT_CONFIG(accessibility)
        QAccessibleEvent event(this, QAccessible::Focus);
        QAccessible::updateAccessibility(&event);
#endif
    }
}
 
 
bool QWidget::focusNextPrevChild(bool next)
{
    QWidget* p = parentWidget();
    bool isSubWindow = (windowType() == Qt::SubWindow);
    if (!isWindow() && !isSubWindow && p)
        return p->focusNextPrevChild(next);
#if QT_CONFIG(graphicsview)
    Q_D(QWidget);
    if (d->extra && d->extra->proxyWidget)
        return d->extra->proxyWidget->focusNextPrevChild(next);
#endif
 
    bool wrappingOccurred = false;
    QWidget *w = QApplicationPrivate::focusNextPrevChild_helper(this, next,
                                                                &wrappingOccurred);
    if (!w) return false;
 
    Qt::FocusReason reason = next ? Qt::TabFocusReason : Qt::BacktabFocusReason;
 
    /* If we are about to wrap the focus chain, give the platform
     * implementation a chance to alter the wrapping behavior.  This is
     * especially needed when the window is embedded in a window created by
     * another process.
     */
    if (wrappingOccurred) {
        QWindow *window = windowHandle();
        if (window != nullptr) {
            QWindowPrivate *winp = qt_window_private(window);
 
            if (winp->platformWindow != nullptr) {
                QFocusEvent event(QEvent::FocusIn, reason);
                event.ignore();
                winp->platformWindow->windowEvent(&event);
                if (event.isAccepted()) return true;
            }
        }
    }
 
    w->setFocus(reason);
    return true;
}
 
QWidget *QWidget::focusWidget() const
{
    return const_cast<QWidget *>(d_func()->focus_child);
}
 
QObject *QWidgetPrivate::focusObject()
{
    Q_Q(QWidget);
    QWidget *proxy = deepestFocusProxy();
    return proxy ? proxy : q;
}
 
QWidget *QWidget::nextInFocusChain() const
{
    Q_D(const QWidget);
    return d->nextPrevElementInFocusChain(QWidgetPrivate::FocusDirection::Next);
}
 
QWidget *QWidget::previousInFocusChain() const
{
    Q_D(const QWidget);
    return d->nextPrevElementInFocusChain(QWidgetPrivate::FocusDirection::Previous);
}
 
bool QWidget::isActiveWindow() const
{
    QWidget *tlw = window();
    if (tlw == QApplication::activeWindow() || (isVisible() && (tlw->windowType() == Qt::Popup)))
        return true;
 
#if QT_CONFIG(graphicsview)
    if (const auto &tlwExtra = tlw->d_func()->extra) {
        if (isVisible() && tlwExtra->proxyWidget)
            return tlwExtra->proxyWidget->isActiveWindow();
    }
#endif
 
    if (style()->styleHint(QStyle::SH_Widget_ShareActivation, nullptr, this)) {
        if (tlw->windowType() == Qt::Tool &&
           !tlw->isModal() &&
           (!tlw->parentWidget() || tlw->parentWidget()->isActiveWindow()))
           return true;
        QWidget *w = QApplication::activeWindow();
        while(w && tlw->windowType() == Qt::Tool &&
              !w->isModal() && w->parentWidget()) {
            w = w->parentWidget()->window();
            if (w == tlw)
                return true;
        }
    }
 
    // Check for an active window container
    if (QWindow *ww = QGuiApplication::focusWindow()) {
        while (ww) {
            QWidgetWindow *qww = qobject_cast<QWidgetWindow *>(ww);
            QWindowContainer *qwc = qww ? qobject_cast<QWindowContainer *>(qww->widget()) : 0;
            if (qwc && qwc->topLevelWidget() == tlw)
                return true;
            ww = ww->parent();
        }
    }
 
    // Check if platform adaptation thinks the window is active. This is necessary for
    // example in case of ActiveQt servers that are embedded into another application.
    // Those are separate processes that are not part of the parent application Qt window/widget
    // hierarchy, so they need to rely on native methods to determine if they are part of the
    // active window.
    if (const QWindow *w = tlw->windowHandle()) {
        if (w->handle())
            return w->handle()->isActive();
    }
 
    return false;
}
 
void QWidget::setTabOrder(QWidget* first, QWidget *second)
{
    if (!first || !second || first == second
            || first->focusPolicy() == Qt::NoFocus
            || second->focusPolicy() == Qt::NoFocus)
        return;
 
    if (Q_UNLIKELY(first->window() != second->window())) {
        qWarning("QWidget::setTabOrder: 'first' and 'second' must be in the same window");
        return;
    }
 
    const auto determineLastFocusChild = [](QWidget *target, QWidget *noFurtherThan)
    {
        // Since we need to repeat the same logic for both 'first' and 'second', we add a function that
        // determines the last focus child for a widget, taking proxies and compound widgets into account.
        // If the target is not a compound widget (it doesn't have a focus proxy that points to a child),
        // 'lastFocusChild' will be set to the target itself.
        QWidget *lastFocusChild = target;
 
        QWidget *focusProxy = target->d_func()->deepestFocusProxy();
        if (!focusProxy) {
            // QTBUG-81097: Another case is possible here. We can have a child
            // widget, that sets its focusProxy() to the parent (target).
            // An example of such widget is a QLineEdit, nested into
            // a QAbstractSpinBox. In this case such widget should be considered
            // the last focus child.
            for (auto *object : target->children()) {
                QWidget *w = qobject_cast<QWidget*>(object);
                if (w && w->focusProxy() == target) {
                    lastFocusChild = w;
                    break;
                }
            }
        } else if (target->isAncestorOf(focusProxy)) {
            lastFocusChild = focusProxy;
            for (QWidget *focusNext = lastFocusChild->nextInFocusChain();
                focusNext != focusProxy && target->isAncestorOf(focusNext) && focusNext->window() == focusProxy->window();
                focusNext = focusNext->nextInFocusChain()) {
                if (focusNext == noFurtherThan)
                    break;
                if (focusNext->focusPolicy() != Qt::NoFocus)
                    lastFocusChild = focusNext;
            }
        }
        return lastFocusChild;
    };
    // detect inflection in case we have compound widgets
    QWidget *lastFocusChildOfFirst = determineLastFocusChild(first, second);
    if (lastFocusChildOfFirst == second)
        lastFocusChildOfFirst = first;
    QWidget *lastFocusChildOfSecond = determineLastFocusChild(second, first);
    if (lastFocusChildOfSecond == first)
        lastFocusChildOfSecond = second;
 
    // Return if only NoFocus widgets are between first and second
    QWidget *oldPrev = second->previousInFocusChain();
    QWidget *prevWithFocus = oldPrev;
    while (prevWithFocus->focusPolicy() == Qt::NoFocus)
        prevWithFocus = prevWithFocus->previousInFocusChain();
    if (prevWithFocus == first)
        return;
    const QWidgetList chain = QWidgetPrivate::takeFromFocusChain(second, lastFocusChildOfSecond);
    QWidgetPrivate::insertIntoFocusChain(chain, QWidgetPrivate::FocusDirection::Next, lastFocusChildOfFirst);
}
 
void QWidget::setTabOrder(std::initializer_list<QWidget *> widgets)
{
    QWidget *prev = nullptr;
    for (const auto &widget : widgets) {
        if (!prev) {
            prev = widget;
        } else {
            QWidget::setTabOrder(prev, widget);
            prev = widget;
        }
    }
}
 
 
void QWidgetPrivate::reparentFocusWidgets(QWidget * oldtlw)
{
    Q_Q(QWidget);
    if (oldtlw == q->window())
        return; // nothing to do
 
    if (focus_child)
        focus_child->clearFocus();
 
    reparentFocusChildren(QWidgetPrivate::FocusDirection::Next);
}
 
QSize QWidget::frameSize() const
{
    Q_D(const QWidget);
    if (isWindow() && !(windowType() == Qt::Popup)) {
        QRect fs = d->frameStrut();
        return QSize(data->crect.width() + fs.left() + fs.right(),
                      data->crect.height() + fs.top() + fs.bottom());
    }
    return data->crect.size();
}
 
void QWidget::move(const QPoint &p)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_Moved);
    if (testAttribute(Qt::WA_WState_Created)) {
        if (isWindow())
            d->topData()->posIncludesFrame = false;
        d->setGeometry_sys(p.x() + geometry().x() - QWidget::x(),
                       p.y() + geometry().y() - QWidget::y(),
                       width(), height(), true);
        d->setDirtyOpaqueRegion();
    } else {
        // no frame yet: see also QWidgetPrivate::fixPosIncludesFrame(), QWindowPrivate::PositionPolicy.
        if (isWindow())
            d->topData()->posIncludesFrame = true;
        data->crect.moveTopLeft(p); // no frame yet
        setAttribute(Qt::WA_PendingMoveEvent);
    }
 
    if (d->extra && d->extra->hasWindowContainer)
        QWindowContainer::parentWasMoved(this);
}
 
// move() was invoked with Qt::WA_WState_Created not set (frame geometry
// unknown), that is, crect has a position including the frame.
// If we can determine the frame strut, fix that and clear the flag.
// FIXME: This does not play well with window states other than
// Qt::WindowNoState, as we depend on calling setGeometry() on the
// platform window after fixing up the position so that the new
// geometry is reflected in the platform window, but when the frame
// comes in after the window has been shown (e.g. maximized), we're
// not in a position to do that kind of fixup.
void QWidgetPrivate::fixPosIncludesFrame()
{
    Q_Q(QWidget);
    if (QTLWExtra *te = maybeTopData()) {
        if (te->posIncludesFrame) {
            // For Qt::WA_DontShowOnScreen, assume a frame of 0 (for
            // example, in QGraphicsProxyWidget).
            if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
                te->posIncludesFrame = 0;
            } else {
                if (q->windowHandle() && q->windowHandle()->handle()) {
                    updateFrameStrut();
                    if (!q->data->fstrut_dirty) {
                        data.crect.translate(te->frameStrut.x(), te->frameStrut.y());
                        te->posIncludesFrame = 0;
                    }
                } // windowHandle()
            } // !WA_DontShowOnScreen
        } // posIncludesFrame
    } // QTLWExtra
}
 
void QWidget::resize(const QSize &s)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_Resized);
    if (testAttribute(Qt::WA_WState_Created)) {
        d->fixPosIncludesFrame();
        d->setGeometry_sys(geometry().x(), geometry().y(), s.width(), s.height(), false);
        d->setDirtyOpaqueRegion();
    } else {
        const auto oldRect = data->crect;
        data->crect.setSize(s.boundedTo(maximumSize()).expandedTo(minimumSize()));
        if (oldRect != data->crect)
            setAttribute(Qt::WA_PendingResizeEvent);
    }
}
 
void QWidget::setGeometry(const QRect &r)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_Resized);
    setAttribute(Qt::WA_Moved);
    if (isWindow())
        d->topData()->posIncludesFrame = 0;
    if (testAttribute(Qt::WA_WState_Created)) {
        d->setGeometry_sys(r.x(), r.y(), r.width(), r.height(), true);
        d->setDirtyOpaqueRegion();
    } else {
        const auto oldRect = data->crect;
        data->crect.setTopLeft(r.topLeft());
        data->crect.setSize(r.size().boundedTo(maximumSize()).expandedTo(minimumSize()));
        if (oldRect != data->crect) {
            setAttribute(Qt::WA_PendingMoveEvent);
            setAttribute(Qt::WA_PendingResizeEvent);
        }
    }
 
    if (d->extra && d->extra->hasWindowContainer)
        QWindowContainer::parentWasMoved(this);
}
 
void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
{
    Q_Q(QWidget);
    if (extra) {                                // any size restrictions?
        w = qMin(w,extra->maxw);
        h = qMin(h,extra->maxh);
        w = qMax(w,extra->minw);
        h = qMax(h,extra->minh);
    }
 
    if (q->isWindow() && q->windowHandle()) {
        QPlatformIntegration *integration = QGuiApplicationPrivate::platformIntegration();
        if (!integration->hasCapability(QPlatformIntegration::NonFullScreenWindows)) {
            x = 0;
            y = 0;
            w = q->windowHandle()->width();
            h = q->windowHandle()->height();
        }
    }
 
    QPoint oldp = q->geometry().topLeft();
    QSize olds = q->size();
    QRect r(x, y, w, h);
 
    bool isResize = olds != r.size();
    if (!isMove)
        isMove = oldp != r.topLeft();
 
 
    // We only care about stuff that changes the geometry, or may
    // cause the window manager to change its state
    if (r.size() == olds && oldp == r.topLeft())
        return;
 
    if (!data.in_set_window_state) {
        q->data->window_state &= ~Qt::WindowMaximized;
        q->data->window_state &= ~Qt::WindowFullScreen;
        if (q->isWindow())
            topData()->normalGeometry = QRect(0, 0, -1, -1);
    }
 
    QPoint oldPos = q->pos();
    data.crect = r;
 
    bool needsShow = false;
 
    if (q->isWindow() || q->windowHandle()) {
        if (!(data.window_state & Qt::WindowFullScreen) && (w == 0 || h == 0)) {
            q->setAttribute(Qt::WA_OutsideWSRange, true);
            if (q->isVisible())
                hide_sys();
            data.crect = QRect(x, y, w, h);
        } else if (q->testAttribute(Qt::WA_OutsideWSRange)) {
            q->setAttribute(Qt::WA_OutsideWSRange, false);
            needsShow = true;
        }
    }
 
    if (q->isVisible()) {
        if (!q->testAttribute(Qt::WA_DontShowOnScreen) && !q->testAttribute(Qt::WA_OutsideWSRange)) {
            if (QWindow *win = q->windowHandle()) {
                if (q->isWindow()) {
                    if (isResize && !isMove)
                        win->resize(w, h);
                    else if (isMove && !isResize)
                        win->setPosition(x, y);
                    else
                        win->setGeometry(q->geometry());
                } else {
                    QPoint posInNativeParent =  q->mapTo(q->nativeParentWidget(),QPoint());
                    win->setGeometry(QRect(posInNativeParent,r.size()));
                }
 
                if (needsShow)
                    show_sys();
            }
 
            if (!q->isWindow()) {
                if (renderToTexture) {
                    QRegion updateRegion(q->geometry());
                    updateRegion += QRect(oldPos, olds);
                    q->parentWidget()->d_func()->invalidateBackingStore(updateRegion);
                } else if (isMove && !isResize) {
                    moveRect(QRect(oldPos, olds), x - oldPos.x(), y - oldPos.y());
                } else {
                    invalidateBackingStore_resizeHelper(oldPos, olds);
                }
            }
        }
 
        if (isMove) {
            QMoveEvent e(q->pos(), oldPos);
            QCoreApplication::sendEvent(q, &e);
        }
        if (isResize) {
            QResizeEvent e(r.size(), olds);
            QCoreApplication::sendEvent(q, &e);
            if (q->windowHandle())
                q->update();
        }
    } else { // not visible
        if (isMove && q->pos() != oldPos)
            q->setAttribute(Qt::WA_PendingMoveEvent, true);
        if (isResize)
            q->setAttribute(Qt::WA_PendingResizeEvent, true);
    }
 
}
 
QByteArray QWidget::saveGeometry() const
{
    QByteArray array;
    QDataStream stream(&array, QIODevice::WriteOnly);
    stream.setVersion(QDataStream::Qt_4_0);
    const quint32 magicNumber = 0x1D9D0CB;
    // Version history:
    // - Qt 4.2 - 4.8.6, 5.0 - 5.3    : Version 1.0
    // - Qt 4.8.6 - today, 5.4 - today: Version 2.0, save screen width in addition to check for high DPI scaling.
    // - Qt 5.12 - today              : Version 3.0, save QWidget::geometry()
    quint16 majorVersion = 3;
    quint16 minorVersion = 0;
    const int screenNumber = QGuiApplication::screens().indexOf(screen());
    stream << magicNumber
           << majorVersion
           << minorVersion
           << frameGeometry()
           << normalGeometry()
           << qint32(screenNumber)
           << quint8(windowState() & Qt::WindowMaximized)
           << quint8(windowState() & Qt::WindowFullScreen)
           << qint32(screen()->geometry().width()) // added in 2.0
           << geometry(); // added in 3.0
    return array;
}
 
void QWidgetPrivate::checkRestoredGeometry(const QRect &availableGeometry, QRect *restoredGeometry,
                                  int frameHeight)
{
    // compare with restored geometry's height increased by frameHeight
    const int height = restoredGeometry->height() + frameHeight;
 
    // Step 1: Resize if necessary:
    // make height / width 2px smaller than screen, because an exact match would be fullscreen
    if (availableGeometry.height() <= height)
        restoredGeometry->setHeight(availableGeometry.height() - 2 - frameHeight);
    if (availableGeometry.width() <= restoredGeometry->width())
        restoredGeometry->setWidth(availableGeometry.width() - 2);
 
    // Step 2: Move if necessary:
    // Construct a rectangle from restored Geometry adjusted by frameHeight
    const QRect restored = restoredGeometry->adjusted(0, -frameHeight, 0, 0);
 
    // Return if restoredGeometry (including frame) fits into screen
    if (availableGeometry.contains(restored))
        return;
 
    // (size is correct, but at least one edge is off screen)
 
    // Top out of bounds => move down
    if (restored.top() <= availableGeometry.top()) {
        restoredGeometry->moveTop(availableGeometry.top() + 1 + frameHeight);
    } else if (restored.bottom() >= availableGeometry.bottom()) {
        // Bottom out of bounds => move up
        restoredGeometry->moveBottom(availableGeometry.bottom() - 1);
    }
 
    // Left edge out of bounds => move right
    if (restored.left() <= availableGeometry.left()) {
        restoredGeometry->moveLeft(availableGeometry.left() + 1);
    } else if (restored.right() >= availableGeometry.right()) {
        // Right edge out of bounds => move left
        restoredGeometry->moveRight(availableGeometry.right() - 1);
    }
}
 
bool QWidget::restoreGeometry(const QByteArray &geometry)
{
    if (geometry.size() < 4)
        return false;
    QDataStream stream(geometry);
    stream.setVersion(QDataStream::Qt_4_0);
 
    const quint32 magicNumber = 0x1D9D0CB;
    quint32 storedMagicNumber;
    stream >> storedMagicNumber;
    if (storedMagicNumber != magicNumber)
        return false;
 
    const quint16 currentMajorVersion = 3;
    quint16 majorVersion = 0;
    quint16 minorVersion = 0;
 
    stream >> majorVersion >> minorVersion;
 
    if (majorVersion > currentMajorVersion)
        return false;
    // (Allow all minor versions.)
 
    QRect restoredFrameGeometry;
    QRect restoredGeometry;
    QRect restoredNormalGeometry;
    qint32 restoredScreenNumber;
    quint8 maximized;
    quint8 fullScreen;
    qint32 restoredScreenWidth = 0;
 
    stream >> restoredFrameGeometry // Only used for sanity checks in version 0
           >> restoredNormalGeometry
           >> restoredScreenNumber
           >> maximized
           >> fullScreen;
 
    if (majorVersion > 1)
        stream >> restoredScreenWidth;
    if (majorVersion > 2)
        stream >> restoredGeometry;
 
    // ### Qt 6 - Perhaps it makes sense to dumb down the restoreGeometry() logic, see QTBUG-69104
 
    if (restoredScreenNumber >= qMax(QGuiApplication::screens().size(), 1))
        restoredScreenNumber = 0;
    const QScreen *restoredScreen = QGuiApplication::screens().value(restoredScreenNumber, nullptr);
    const qreal screenWidthF = restoredScreen ? qreal(restoredScreen->geometry().width()) : 0;
    // Sanity check bailing out when large variations of screen sizes occur due to
    // high DPI scaling or different levels of DPI awareness.
    if (restoredScreenWidth) {
        const qreal factor = qreal(restoredScreenWidth) / screenWidthF;
        if (factor < 0.8 || factor > 1.25)
            return false;
    } else {
        // Saved by Qt 5.3 and earlier, try to prevent too large windows
        // unless the size will be adapted by maximized or fullscreen.
        if (!maximized && !fullScreen && qreal(restoredFrameGeometry.width()) / screenWidthF > 1.5)
            return false;
    }
 
    const int frameHeight = QApplication::style()
                          ? QApplication::style()->pixelMetric(QStyle::PM_TitleBarHeight, nullptr, this)
                          : 20;
 
    if (!restoredNormalGeometry.isValid())
        restoredNormalGeometry = QRect(QPoint(0, frameHeight), sizeHint());
    if (!restoredNormalGeometry.isValid()) {
        // use the widget's adjustedSize if the sizeHint() doesn't help
        restoredNormalGeometry.setSize(restoredNormalGeometry
                                       .size()
                                       .expandedTo(d_func()->adjustedSize()));
    }
 
    const QRect availableGeometry = restoredScreen ? restoredScreen->availableGeometry()
                                                   : QRect();
 
    // Modify the restored geometry if we are about to restore to coordinates
    // that would make the window "lost". This happens if:
    // - The restored geometry is completely or partly oustside the available geometry
    // - The title bar is outside the available geometry.
 
    QWidgetPrivate::checkRestoredGeometry(availableGeometry, &restoredGeometry, frameHeight);
    QWidgetPrivate::checkRestoredGeometry(availableGeometry, &restoredNormalGeometry, frameHeight);
 
    if (maximized || fullScreen) {
        // set geometry before setting the window state to make
        // sure the window is maximized to the right screen.
        Qt::WindowStates ws = windowState();
#ifndef Q_OS_WIN
        setGeometry(restoredNormalGeometry);
#else
        if (ws & Qt::WindowFullScreen) {
            // Full screen is not a real window state on Windows.
            move(availableGeometry.topLeft());
        } else if (ws & Qt::WindowMaximized) {
            // Setting a geometry on an already maximized window causes this to be
            // restored into a broken, half-maximized state, non-resizable state (QTBUG-4397).
            // Move the window in normal state if needed.
            if (restoredScreen != screen()) {
                setWindowState(Qt::WindowNoState);
                setGeometry(restoredNormalGeometry);
            }
        } else {
            setGeometry(restoredNormalGeometry);
        }
#endif // Q_OS_WIN
        if (maximized)
            ws |= Qt::WindowMaximized;
        if (fullScreen)
            ws |= Qt::WindowFullScreen;
       setWindowState(ws);
       d_func()->topData()->normalGeometry = restoredNormalGeometry;
    } else {
        setWindowState(windowState() & ~(Qt::WindowMaximized | Qt::WindowFullScreen));
 
        // FIXME: Why fall back to restoredNormalGeometry if majorVersion <= 2?
        if (majorVersion > 2)
            setGeometry(restoredGeometry);
        else
            setGeometry(restoredNormalGeometry);
    }
    return true;
}
 
void QWidget::setContentsMargins(int left, int top, int right, int bottom)
{
    Q_D(QWidget);
    if (left == d->leftmargin && top == d->topmargin
         && right == d->rightmargin && bottom == d->bottommargin)
        return;
    d->leftmargin = left;
    d->topmargin = top;
    d->rightmargin = right;
    d->bottommargin = bottom;
 
    d->updateContentsRect();
}
 
void QWidget::setContentsMargins(const QMargins &margins)
{
    setContentsMargins(margins.left(), margins.top(),
                       margins.right(), margins.bottom());
}
 
void QWidgetPrivate::updateContentsRect()
{
    Q_Q(QWidget);
 
    if (layout)
        layout->update(); //force activate; will do updateGeometry
    else
        q->updateGeometry();
 
    if (q->isVisible()) {
        q->update();
        QResizeEvent e(q->data->crect.size(), q->data->crect.size());
        QCoreApplication::sendEvent(q, &e);
    } else {
        q->setAttribute(Qt::WA_PendingResizeEvent, true);
    }
 
    QEvent e(QEvent::ContentsRectChange);
    QCoreApplication::sendEvent(q, &e);
}
 
QMargins QWidget::contentsMargins() const
{
    Q_D(const QWidget);
    QMargins userMargins(d->leftmargin, d->topmargin, d->rightmargin, d->bottommargin);
    return testAttribute(Qt::WA_ContentsMarginsRespectsSafeArea) ?
        userMargins | d->safeAreaMargins() : userMargins;
}
 
QRect QWidget::contentsRect() const
{
    return rect() - contentsMargins();
}
 
QMargins QWidgetPrivate::safeAreaMargins() const
{
    Q_Q(const QWidget);
    QWidget *nativeWidget = q->window();
    if (!nativeWidget->windowHandle())
        return QMargins();
 
    QPlatformWindow *platformWindow = nativeWidget->windowHandle()->handle();
    if (!platformWindow)
        return QMargins();
 
    QMargins safeAreaMargins = platformWindow->safeAreaMargins();
 
    if (!q->isWindow()) {
        // In theory the native parent widget already has a contents rect reflecting
        // the safe area of that widget, but we can't be sure that the widget or child
        // widgets of that widget have respected the contents rect when setting their
        // geometry, so we need to manually compute the safe area.
 
        // Unless the native widget doesn't have any margins, in which case there's
        // nothing for us to compute.
        if (safeAreaMargins.isNull())
            return QMargins();
 
        // Or, if one of our ancestors are in a layout that does not have WA_LayoutOnEntireRect
        // set, and the widget respects the safe area, then we know that the layout has already
        // taken care of placing us inside the safe area, by taking the contents rect of its
        // parent widget into account.
        const QWidget *assumedSafeWidget = nullptr;
        for (const QWidget *w = q; w != nativeWidget; w = w->parentWidget()) {
            QWidget *parentWidget = w->parentWidget();
            if (!parentWidget->testAttribute(Qt::WA_ContentsMarginsRespectsSafeArea))
                continue; // Layout can't help us
 
            if (parentWidget->testAttribute(Qt::WA_LayoutOnEntireRect))
                continue; // Layout not going to help us
 
            QLayout *layout = parentWidget->layout();
            if (!layout)
                continue;
 
            if (layout->geometry().isNull())
                continue; // Layout hasn't been activated yet
 
            if (layout->indexOf(w) < 0)
                continue; // Widget is not in layout
 
            assumedSafeWidget = w;
            break;
        }
 
#if !defined(QT_DEBUG)
        if (assumedSafeWidget) {
            // We found a layout that we assume will take care of keeping us within the safe area
            // For debug builds we still map the safe area using the fallback logic, so that we
            // can detect any misbehaving layouts.
            return QMargins();
        }
#endif
 
        // In all other cases we need to map the safe area of the native parent to the widget.
        // This depends on the widget being positioned and sized already, which means the initial
        // layout will be wrong, but the layout will then adjust itself.
        QPoint topLeftMargins = q->mapFrom(nativeWidget, QPoint(safeAreaMargins.left(), safeAreaMargins.top()));
        QRect widgetRect = q->isVisible() ? q->visibleRegion().boundingRect() : q->rect();
        QPoint bottomRightMargins = widgetRect.bottomRight() - q->mapFrom(nativeWidget,
            nativeWidget->rect().bottomRight() - QPoint(safeAreaMargins.right(), safeAreaMargins.bottom()));
 
        // Margins should never be negative
        safeAreaMargins = QMargins(qMax(0, topLeftMargins.x()), qMax(0, topLeftMargins.y()),
            qMax(0, bottomRightMargins.x()), qMax(0, bottomRightMargins.y()));
 
        if (!safeAreaMargins.isNull() && assumedSafeWidget) {
            QLayout *layout = assumedSafeWidget->parentWidget()->layout();
            qWarning() << layout << "is laying out" << assumedSafeWidget
                << "outside of the contents rect of" << layout->parentWidget();
            return QMargins(); // Return empty margin to visually highlight the error
        }
    }
 
    return safeAreaMargins;
}
 
Qt::ContextMenuPolicy QWidget::contextMenuPolicy() const
{
    return (Qt::ContextMenuPolicy)data->context_menu_policy;
}
 
void QWidget::setContextMenuPolicy(Qt::ContextMenuPolicy policy)
{
    data->context_menu_policy = (uint) policy;
}
 
Qt::FocusPolicy QWidget::focusPolicy() const
{
    return (Qt::FocusPolicy)data->focus_policy;
}
 
void QWidget::setFocusPolicy(Qt::FocusPolicy policy)
{
    data->focus_policy = (uint) policy;
    Q_D(QWidget);
    if (d->extra && d->extra->focus_proxy)
        d->extra->focus_proxy->setFocusPolicy(policy);
}
 
void QWidget::setUpdatesEnabled(bool enable)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_ForceUpdatesDisabled, !enable);
    d->setUpdatesEnabled_helper(enable);
}
 
void QWidget::show()
{
    // Note: We don't call showNormal() as not to clobber Qt::Window(Max/Min)imized
 
    if (!isWindow()) {
        setVisible(true);
    } else {
        const auto *platformIntegration = QGuiApplicationPrivate::platformIntegration();
        Qt::WindowState defaultState = platformIntegration->defaultWindowState(data->window_flags);
        if (defaultState == Qt::WindowFullScreen)
            showFullScreen();
        else if (defaultState == Qt::WindowMaximized)
            showMaximized();
        else
            setVisible(true);
    }
}
 
void QWidgetPrivate::show_recursive()
{
    Q_Q(QWidget);
    // polish if necessary
 
    if (!q->testAttribute(Qt::WA_WState_Created))
        createRecursively();
    q->ensurePolished();
 
    if (!q->isWindow() && q->parentWidget()->d_func()->layout && !q->parentWidget()->data->in_show)
        q->parentWidget()->d_func()->layout->activate();
    // activate our layout before we and our children become visible
    if (layout)
        layout->activate();
 
    show_helper();
}
 
void QWidgetPrivate::sendPendingMoveAndResizeEvents(bool recursive, bool disableUpdates)
{
    Q_Q(QWidget);
 
    disableUpdates = disableUpdates && q->updatesEnabled();
    if (disableUpdates)
        q->setAttribute(Qt::WA_UpdatesDisabled);
 
    if (q->testAttribute(Qt::WA_PendingMoveEvent)) {
        QMoveEvent e(data.crect.topLeft(), data.crect.topLeft());
        QCoreApplication::sendEvent(q, &e);
        q->setAttribute(Qt::WA_PendingMoveEvent, false);
    }
 
    if (q->testAttribute(Qt::WA_PendingResizeEvent)) {
        QResizeEvent e(data.crect.size(), QSize());
        QCoreApplication::sendEvent(q, &e);
        q->setAttribute(Qt::WA_PendingResizeEvent, false);
    }
 
    if (disableUpdates)
        q->setAttribute(Qt::WA_UpdatesDisabled, false);
 
    if (!recursive)
        return;
 
    for (int i = 0; i < children.size(); ++i) {
        if (QWidget *child = qobject_cast<QWidget *>(children.at(i)))
            child->d_func()->sendPendingMoveAndResizeEvents(recursive, disableUpdates);
    }
}
 
void QWidgetPrivate::activateChildLayoutsRecursively()
{
    sendPendingMoveAndResizeEvents(false, true);
 
    for (int i = 0; i < children.size(); ++i) {
        QWidget *child = qobject_cast<QWidget *>(children.at(i));
        if (!child || child->isHidden() || child->isWindow())
            continue;
 
        child->ensurePolished();
 
        // Activate child's layout
        QWidgetPrivate *childPrivate = child->d_func();
        if (childPrivate->layout)
            childPrivate->layout->activate();
 
        // Pretend we're visible.
        const bool wasVisible = child->isVisible();
        if (!wasVisible)
            child->setAttribute(Qt::WA_WState_Visible);
 
        // Do the same for all my children.
        childPrivate->activateChildLayoutsRecursively();
 
        // We're not cheating anymore.
        if (!wasVisible)
            child->setAttribute(Qt::WA_WState_Visible, false);
    }
}
 
void QWidgetPrivate::show_helper()
{
    Q_Q(QWidget);
    data.in_show = true; // qws optimization
    // make sure we receive pending move and resize events
    sendPendingMoveAndResizeEvents();
 
    // become visible before showing all children
    q->setAttribute(Qt::WA_WState_Visible);
 
    // finally show all children recursively
    showChildren(false);
 
 
 
    const bool isWindow = q->isWindow();
#if QT_CONFIG(graphicsview)
    bool isEmbedded = isWindow && q->graphicsProxyWidget() != nullptr;
#else
    bool isEmbedded = false;
#endif
 
    // popup handling: new popups and tools need to be raised, and
    // existing popups must be closed. Also propagate the current
    // windows's KeyboardFocusChange status.
    if (isWindow && !isEmbedded) {
        if ((q->windowType() == Qt::Tool) || (q->windowType() == Qt::Popup) || q->windowType() == Qt::ToolTip) {
            q->raise();
            if (q->parentWidget() && q->parentWidget()->window()->testAttribute(Qt::WA_KeyboardFocusChange))
                q->setAttribute(Qt::WA_KeyboardFocusChange);
        } else {
            while (QApplication::activePopupWidget()) {
                if (!QApplication::activePopupWidget()->close())
                    break;
            }
        }
    }
 
    // Automatic embedding of child windows of widgets already embedded into
    // QGraphicsProxyWidget when they are shown the first time.
#if QT_CONFIG(graphicsview)
    if (isWindow) {
        if (!isEmbedded && !bypassGraphicsProxyWidget(q)) {
            QGraphicsProxyWidget *ancestorProxy = nearestGraphicsProxyWidget(q->parentWidget());
            if (ancestorProxy) {
                isEmbedded = true;
                ancestorProxy->d_func()->embedSubWindow(q);
            }
        }
    }
#else
    Q_UNUSED(isEmbedded);
#endif
 
    // send the show event before showing the window
    QShowEvent showEvent;
    QCoreApplication::sendEvent(q, &showEvent);
 
    show_sys();
 
    if (!isEmbedded && q->windowType() == Qt::Popup)
        qApp->d_func()->openPopup(q);
 
#if QT_CONFIG(accessibility)
    if (q->windowType() != Qt::ToolTip) {    // Tooltips are read aloud twice in MS narrator.
        QAccessibleEvent event(q, QAccessible::ObjectShow);
        QAccessible::updateAccessibility(&event);
    }
#endif
 
    if (QApplicationPrivate::hidden_focus_widget == q) {
        QApplicationPrivate::hidden_focus_widget = nullptr;
        q->setFocus(Qt::OtherFocusReason);
    }
 
    // Process events when showing a Qt::SplashScreen widget before the event loop
    // is spinnning; otherwise it might not show up on particular platforms.
    // This makes QSplashScreen behave the same on all platforms.
    if (!qApp->d_func()->in_exec && q->windowType() == Qt::SplashScreen)
        QCoreApplication::processEvents();
 
    data.in_show = false;  // reset qws optimization
}
 
void QWidgetPrivate::show_sys()
{
    Q_Q(QWidget);
 
    auto window = qobject_cast<QWidgetWindow *>(windowHandle());
 
    if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
        invalidateBackingStore(q->rect());
        q->setAttribute(Qt::WA_Mapped);
        // add our window the modal window list (native dialogs)
        if (window && q->isWindow()
#if QT_CONFIG(graphicsview)
            && (!extra || !extra->proxyWidget)
#endif
            && q->windowModality() != Qt::NonModal) {
            QGuiApplicationPrivate::showModalWindow(window);
        }
        return;
    }
 
    if (renderToTexture && !q->isWindow())
        QCoreApplication::postEvent(q->parentWidget(), new QUpdateLaterEvent(q->geometry()));
    else
        QCoreApplication::postEvent(q, new QUpdateLaterEvent(q->rect()));
 
    if ((!q->isWindow() && !q->testAttribute(Qt::WA_NativeWindow))
            || q->testAttribute(Qt::WA_OutsideWSRange)) {
        return;
    }
 
    if (window) {
        if (q->isWindow())
            fixPosIncludesFrame();
        QRect geomRect = q->geometry();
        if (!q->isWindow()) {
            QPoint topLeftOfWindow = q->mapTo(q->nativeParentWidget(),QPoint());
            geomRect.moveTopLeft(topLeftOfWindow);
        }
        const QRect windowRect = window->geometry();
        if (windowRect != geomRect) {
            if (q->testAttribute(Qt::WA_Moved)
                || !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::WindowManagement))
                window->setGeometry(geomRect);
            else
                window->resize(geomRect.size());
        }
 
#ifndef QT_NO_CURSOR
        qt_qpa_set_cursor(q, false); // Needed in case cursor was set before show
#endif
        invalidateBackingStore(q->rect());
        window->setNativeWindowVisibility(true);
        // Was the window moved by the Window system or QPlatformWindow::initialGeometry() ?
        if (window->isTopLevel()) {
            const QPoint crectTopLeft = q->data->crect.topLeft();
            const QPoint windowTopLeft = window->geometry().topLeft();
            if (crectTopLeft == QPoint(0, 0) && windowTopLeft != crectTopLeft)
                q->data->crect.moveTopLeft(windowTopLeft);
        }
    }
}
 
void QWidget::hide()
{
    setVisible(false);
}
 
void QWidgetPrivate::hide_helper()
{
    Q_Q(QWidget);
 
    bool isEmbedded = false;
#if QT_CONFIG(graphicsview)
    isEmbedded = q->isWindow() && !bypassGraphicsProxyWidget(q) && nearestGraphicsProxyWidget(q->parentWidget()) != nullptr;
#else
    Q_UNUSED(isEmbedded);
#endif
 
    if (!isEmbedded && (q->windowType() == Qt::Popup))
        qApp->d_func()->closePopup(q);
 
    q->setAttribute(Qt::WA_Mapped, false);
    hide_sys();
 
    bool wasVisible = q->testAttribute(Qt::WA_WState_Visible);
 
    if (wasVisible) {
        q->setAttribute(Qt::WA_WState_Visible, false);
 
    }
 
    QHideEvent hideEvent;
    QCoreApplication::sendEvent(q, &hideEvent);
    hideChildren(false);
 
    // next bit tries to move the focus if the focus widget is now
    // hidden.
    if (wasVisible) {
        qApp->d_func()->sendSyntheticEnterLeave(q);
        QWidget *fw = QApplication::focusWidget();
        while (fw &&  !fw->isWindow()) {
            if (fw == q) {
                q->focusNextPrevChild(true);
                break;
            }
            fw = fw->parentWidget();
        }
    }
 
    if (QWidgetRepaintManager *repaintManager = maybeRepaintManager())
        repaintManager->removeDirtyWidget(q);
 
#if QT_CONFIG(accessibility)
    if (wasVisible) {
        QAccessibleEvent event(q, QAccessible::ObjectHide);
        QAccessible::updateAccessibility(&event);
    }
#endif
}
 
void QWidgetPrivate::hide_sys()
{
    Q_Q(QWidget);
 
    auto window = qobject_cast<QWidgetWindow *>(windowHandle());
 
    if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
        q->setAttribute(Qt::WA_Mapped, false);
        // remove our window from the modal window list (native dialogs)
        if (window && q->isWindow()
#if QT_CONFIG(graphicsview)
            && (!extra || !extra->proxyWidget)
#endif
            && q->windowModality() != Qt::NonModal) {
            QGuiApplicationPrivate::hideModalWindow(window);
        }
        // do not return here, if window non-zero, we must hide it
    }
 
    deactivateWidgetCleanup();
 
    if (!q->isWindow()) {
        QWidget *p = q->parentWidget();
        if (p &&p->isVisible()) {
            if (renderToTexture)
                p->d_func()->invalidateBackingStore(q->geometry());
            else
                invalidateBackingStore(q->rect());
        }
    } else {
        invalidateBackingStore(q->rect());
    }
 
    if (window)
        window->setNativeWindowVisibility(false);
}
 
void QWidget::setVisible(bool visible)
{
    Q_D(QWidget);
    qCDebug(lcWidgetShowHide) << "Setting visibility of" << this
                              << "with attributes" << WidgetAttributes{this}
                              << "to" << visible << "via QWidget";
 
    if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden) == !visible)
        return;
 
    // Remember that setVisible was called explicitly
    setAttribute(Qt::WA_WState_ExplicitShowHide);
 
    d->setVisible(visible);
}
 
// This method is called from QWidgetWindow in response to QWindow::setVisible,
// and should match the semantics of QWindow::setVisible. QWidget::setVisible on
// the other hand keeps track of WA_WState_ExplicitShowHide in addition.
void QWidgetPrivate::setVisible(bool visible)
{
    Q_Q(QWidget);
    qCDebug(lcWidgetShowHide) << "Setting visibility of" << q
                              << "with attributes" << WidgetAttributes{q}
                              << "to" << visible << "via QWidgetPrivate";
 
    if (visible) { // show
        // Designer uses a trick to make grabWidget work without showing
        if (!q->isWindow() && q->parentWidget() && q->parentWidget()->isVisible()
            && !q->parentWidget()->testAttribute(Qt::WA_WState_Created))
            q->parentWidget()->window()->d_func()->createRecursively();
 
        //create toplevels but not children of non-visible parents
        QWidget *pw = q->parentWidget();
        if (!q->testAttribute(Qt::WA_WState_Created)
            && (q->isWindow() || pw->testAttribute(Qt::WA_WState_Created))) {
            q->create();
        }
 
        bool wasResized = q->testAttribute(Qt::WA_Resized);
        Qt::WindowStates initialWindowState = q->windowState();
 
        // polish if necessary
        q->ensurePolished();
 
        // whether we need to inform the parent widget immediately
        bool needUpdateGeometry = !q->isWindow() && q->testAttribute(Qt::WA_WState_Hidden);
        // we are no longer hidden
        q->setAttribute(Qt::WA_WState_Hidden, false);
 
        if (needUpdateGeometry)
            updateGeometry_helper(true);
 
        // activate our layout before we and our children become visible
        if (layout)
            layout->activate();
 
        if (!q->isWindow()) {
            QWidget *parent = q->parentWidget();
            while (parent && parent->isVisible() && parent->d_func()->layout  && !parent->data->in_show) {
                parent->d_func()->layout->activate();
                if (parent->isWindow())
                    break;
                parent = parent->parentWidget();
            }
            if (parent)
                parent->d_func()->setDirtyOpaqueRegion();
        }
 
        // adjust size if necessary
        if (!wasResized
            && (q->isWindow() || !q->parentWidget()->d_func()->layout))  {
            if (q->isWindow()) {
                q->adjustSize();
                if (q->windowState() != initialWindowState)
                    q->setWindowState(initialWindowState);
            } else {
                q->adjustSize();
            }
            q->setAttribute(Qt::WA_Resized, false);
        }
 
        q->setAttribute(Qt::WA_KeyboardFocusChange, false);
 
        if (q->isWindow() || q->parentWidget()->isVisible()) {
            show_helper();
 
            qApp->d_func()->sendSyntheticEnterLeave(q);
        }
 
        QEvent showToParentEvent(QEvent::ShowToParent);
        QCoreApplication::sendEvent(q, &showToParentEvent);
    } else { // hide
        if (QApplicationPrivate::hidden_focus_widget == q)
            QApplicationPrivate::hidden_focus_widget = nullptr;
 
        // hw: The test on getOpaqueRegion() needs to be more intelligent
        // currently it doesn't work if the widget is hidden (the region will
        // be clipped). The real check should be testing the cached region
        // (and dirty flag) directly.
        if (!q->isWindow() && q->parentWidget()) // && !d->getOpaqueRegion().isEmpty())
            q->parentWidget()->d_func()->setDirtyOpaqueRegion();
 
        if (!q->testAttribute(Qt::WA_WState_Hidden)) {
            q->setAttribute(Qt::WA_WState_Hidden);
            hide_helper();
        }
 
        // invalidate layout similar to updateGeometry()
        if (!q->isWindow() && q->parentWidget()) {
            if (q->parentWidget()->d_func()->layout)
                q->parentWidget()->d_func()->layout->invalidate();
            else if (q->parentWidget()->isVisible())
                QCoreApplication::postEvent(q->parentWidget(), new QEvent(QEvent::LayoutRequest));
        }
 
        QEvent hideToParentEvent(QEvent::HideToParent);
        QCoreApplication::sendEvent(q, &hideToParentEvent);
    }
}
 
void QWidget::setHidden(bool hidden)
{
    setVisible(!hidden);
}
 
bool QWidgetPrivate::isExplicitlyHidden() const
{
    Q_Q(const QWidget);
    return q->isHidden() && q->testAttribute(Qt::WA_WState_ExplicitShowHide);
}
 
void QWidgetPrivate::_q_showIfNotHidden()
{
    Q_Q(QWidget);
    if (!isExplicitlyHidden())
        q->setVisible(true);
}
 
void QWidgetPrivate::showChildren(bool spontaneous)
{
    Q_Q(QWidget);
    qCDebug(lcWidgetShowHide) << "Showing children of" << q
                              << "spontaneously" << spontaneous;
 
    QList<QObject*> childList = children;
    for (int i = 0; i < childList.size(); ++i) {
        QWidget *widget = qobject_cast<QWidget*>(childList.at(i));
        if (!widget)
            continue;
        qCDebug(lcWidgetShowHide) << "Considering" << widget
              << "with attributes" << WidgetAttributes{widget};
        if (widget->windowHandle() && !widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
            widget->setAttribute(Qt::WA_WState_Hidden, false);
        if (widget->isWindow() || widget->testAttribute(Qt::WA_WState_Hidden))
            continue;
        if (spontaneous) {
            widget->setAttribute(Qt::WA_Mapped);
            widget->d_func()->showChildren(true);
            QShowEvent e;
            QApplication::sendSpontaneousEvent(widget, &e);
        } else {
            if (widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
                widget->d_func()->show_recursive();
            else
                widget->d_func()->setVisible(true);
        }
    }
}
 
void QWidgetPrivate::hideChildren(bool spontaneous)
{
    Q_Q(QWidget);
    qCDebug(lcWidgetShowHide) << "Hiding children of" << q
                              << "spontaneously" << spontaneous;
 
    QList<QObject*> childList = children;
    for (int i = 0; i < childList.size(); ++i) {
        QWidget *widget = qobject_cast<QWidget*>(childList.at(i));
        if (!widget)
            continue;
        qCDebug(lcWidgetShowHide) << "Considering" << widget
              << "with attributes" << WidgetAttributes{widget};
        if (widget->isWindow() || !widget->isVisible())
            continue;
 
        if (spontaneous)
            widget->setAttribute(Qt::WA_Mapped, false);
        else
            widget->setAttribute(Qt::WA_WState_Visible, false);
        widget->d_func()->hideChildren(spontaneous);
        QHideEvent e;
        if (spontaneous) {
            QApplication::sendSpontaneousEvent(widget, &e);
        } else {
            QCoreApplication::sendEvent(widget, &e);
            if (widget->internalWinId()
                && widget->testAttribute(Qt::WA_DontCreateNativeAncestors)) {
                // hide_sys() on an ancestor won't have any affect on this
                // widget, so it needs an explicit hide_sys() of its own
                widget->d_func()->hide_sys();
            }
        }
        qApp->d_func()->sendSyntheticEnterLeave(widget);
#if QT_CONFIG(accessibility)
        if (!spontaneous) {
            QAccessibleEvent event(widget, QAccessible::ObjectHide);
            QAccessible::updateAccessibility(&event);
        }
#endif
    }
 
    // If the window of this widget is not closed, then the leave event
    // will eventually handle the widget under mouse use case.
    // Otherwise, we need to explicitly handle it here.
    if (QWidget* widgetWindow = q->window();
        widgetWindow && widgetWindow->data->is_closing) {
        q->setAttribute(Qt::WA_UnderMouse, false);
    }
}
 
bool QWidgetPrivate::handleClose(CloseMode mode)
{
    Q_Q(QWidget);
    qCDebug(lcWidgetShowHide) << "Handling close event for" << q;
 
    if (data.is_closing)
        return true;
 
    // We might not have initiated the close, so update the state now that we know
    data.is_closing = true;
 
    QPointer<QWidget> that = q;
 
    if (data.in_destructor)
        mode = CloseNoEvent;
 
    if (mode != CloseNoEvent) {
        QCloseEvent e;
        if (mode == CloseWithSpontaneousEvent)
            QApplication::sendSpontaneousEvent(q, &e);
        else
            QCoreApplication::sendEvent(q, &e);
        if (!that.isNull() && !e.isAccepted()) {
            data.is_closing = false;
            return false;
        }
    }
 
    // even for windows, make sure we deliver a hide event and that all children get hidden
    if (!that.isNull() && !q->isHidden())
        q->hide();
 
    if (!that.isNull()) {
        data.is_closing = false;
        if (q->testAttribute(Qt::WA_DeleteOnClose)) {
            q->setAttribute(Qt::WA_DeleteOnClose, false);
            q->deleteLater();
        }
    }
    return true;
}
 
 
bool QWidget::close()
{
    return d_func()->close();
}
 
bool QWidgetPrivate::close()
{
    // FIXME: We're not setting is_closing here, even though that would
    // make sense, as the code below will not end up in handleClose to
    // reset is_closing when there's a QWindow, but no QPlatformWindow,
    // and we can't assume close is synchronous so we can't reset it here.
 
    // Close native widgets via QWindow::close() in order to run QWindow
    // close code. The QWidget-specific close code in handleClose() will
    // in this case be called from the Close event handler in QWidgetWindow.
    if (QWindow *widgetWindow = windowHandle()) {
        if (widgetWindow->isTopLevel())
            return widgetWindow->close();
    }
 
    return handleClose(QWidgetPrivate::CloseWithEvent);
}
 
bool QWidget::isVisibleTo(const QWidget *ancestor) const
{
    if (!ancestor)
        return isVisible();
    const QWidget * w = this;
    while (!w->isHidden()
            && !w->isWindow()
            && w->parentWidget()
            && w->parentWidget() != ancestor)
        w = w->parentWidget();
    return !w->isHidden();
}
 
 
QRegion QWidget::visibleRegion() const
{
    Q_D(const QWidget);
 
    QRect clipRect = d->clipRect();
    if (clipRect.isEmpty())
        return QRegion();
    QRegion r(clipRect);
    d->subtractOpaqueChildren(r, clipRect);
    d->subtractOpaqueSiblings(r);
    return r;
}
 
 
QSize QWidgetPrivate::adjustedSize() const
{
    Q_Q(const QWidget);
 
    QSize s = q->sizeHint();
 
    if (q->isWindow()) {
        Qt::Orientations exp;
        if (layout) {
            if (layout->hasHeightForWidth())
                s.setHeight(layout->totalHeightForWidth(s.width()));
            exp = layout->expandingDirections();
        } else
        {
            if (q->sizePolicy().hasHeightForWidth())
                s.setHeight(q->heightForWidth(s.width()));
            exp = q->sizePolicy().expandingDirections();
        }
        if (exp & Qt::Horizontal)
            s.setWidth(qMax(s.width(), 200));
        if (exp & Qt::Vertical)
            s.setHeight(qMax(s.height(), 100));
 
        QRect screen;
        if (const QScreen *screenAtPoint = QGuiApplication::screenAt(q->pos()))
            screen = screenAtPoint->geometry();
        else
            screen = QGuiApplication::primaryScreen()->geometry();
 
        s.setWidth(qMin(s.width(), screen.width()*2/3));
        s.setHeight(qMin(s.height(), screen.height()*2/3));
 
        if (QTLWExtra *extra = maybeTopData())
            extra->sizeAdjusted = true;
    }
 
    if (!s.isValid()) {
        QRect r = q->childrenRect(); // get children rectangle
        if (r.isNull())
            return s;
        s = r.size() + QSize(2 * r.x(), 2 * r.y());
    }
 
    return s;
}
 
void QWidget::adjustSize()
{
    Q_D(QWidget);
    ensurePolished();
    QSize s = d->adjustedSize();
 
    if (d->layout)
        d->layout->activate();
 
    if (s.isValid())
        resize(s);
}
 
 
QSize QWidget::sizeHint() const
{
    Q_D(const QWidget);
    if (d->layout)
        return d->layout->totalSizeHint();
    return QSize(-1, -1);
}
 
QSize QWidget::minimumSizeHint() const
{
    Q_D(const QWidget);
    if (d->layout)
        return d->layout->totalMinimumSize();
    return QSize(-1, -1);
}
 
 
bool QWidget::isAncestorOf(const QWidget *child) const
{
    while (child) {
        if (child == this)
            return true;
        if (child->isWindow())
            return false;
        child = child->parentWidget();
    }
    return false;
}
 
/*****************************************************************************
  QWidget event handling
 *****************************************************************************/
 
bool QWidget::event(QEvent *event)
{
    Q_D(QWidget);
 
    // ignore mouse and key events when disabled
    if (!isEnabled()) {
        switch(event->type()) {
        case QEvent::TabletPress:
        case QEvent::TabletRelease:
        case QEvent::TabletMove:
        case QEvent::MouseButtonPress:
        case QEvent::MouseButtonRelease:
        case QEvent::MouseButtonDblClick:
        case QEvent::MouseMove:
        case QEvent::TouchBegin:
        case QEvent::TouchUpdate:
        case QEvent::TouchEnd:
        case QEvent::TouchCancel:
        case QEvent::ContextMenu:
        case QEvent::KeyPress:
        case QEvent::KeyRelease:
#if QT_CONFIG(wheelevent)
        case QEvent::Wheel:
#endif
            return false;
        default:
            break;
        }
    }
    switch (event->type()) {
    case QEvent::PlatformSurface: {
        // Sync up QWidget's view of whether or not the widget has been created
        switch (static_cast<QPlatformSurfaceEvent*>(event)->surfaceEventType()) {
        case QPlatformSurfaceEvent::SurfaceCreated:
            if (!testAttribute(Qt::WA_WState_Created))
                create();
            break;
        case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
            if (testAttribute(Qt::WA_WState_Created)) {
                // Child windows have already been destroyed by QWindow,
                // so we skip them here.
                destroy(false, false);
            }
            break;
        }
        break;
    }
    case QEvent::MouseMove:
        mouseMoveEvent((QMouseEvent*)event);
        break;
 
    case QEvent::MouseButtonPress:
        mousePressEvent((QMouseEvent*)event);
        break;
 
    case QEvent::MouseButtonRelease:
        mouseReleaseEvent((QMouseEvent*)event);
        break;
 
    case QEvent::MouseButtonDblClick:
        mouseDoubleClickEvent((QMouseEvent*)event);
        break;
#if QT_CONFIG(wheelevent)
    case QEvent::Wheel:
        wheelEvent((QWheelEvent*)event);
        break;
#endif
#if QT_CONFIG(tabletevent)
    case QEvent::TabletMove:
        if (static_cast<QTabletEvent *>(event)->buttons() == Qt::NoButton && !testAttribute(Qt::WA_TabletTracking))
            break;
        Q_FALLTHROUGH();
    case QEvent::TabletPress:
    case QEvent::TabletRelease:
        tabletEvent((QTabletEvent*)event);
        break;
#endif
    case QEvent::KeyPress: {
        QKeyEvent *k = static_cast<QKeyEvent *>(event);
        bool res = false;
        if (!(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier))) {  //### Add MetaModifier?
            if (k->key() == Qt::Key_Backtab
                || (k->key() == Qt::Key_Tab && (k->modifiers() & Qt::ShiftModifier)))
                res = focusNextPrevChild(false);
            else if (k->key() == Qt::Key_Tab)
                res = focusNextPrevChild(true);
            if (res)
                break;
        }
        keyPressEvent(k);
#ifdef QT_KEYPAD_NAVIGATION
        if (!k->isAccepted() && QApplication::keypadNavigationEnabled()
            && !(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier | Qt::ShiftModifier))) {
            if (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder) {
                if (k->key() == Qt::Key_Up)
                    res = focusNextPrevChild(false);
                else if (k->key() == Qt::Key_Down)
                    res = focusNextPrevChild(true);
            } else if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
                if (k->key() == Qt::Key_Up)
                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionNorth);
                else if (k->key() == Qt::Key_Right)
                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionEast);
                else if (k->key() == Qt::Key_Down)
                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionSouth);
                else if (k->key() == Qt::Key_Left)
                    res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionWest);
            }
            if (res) {
                k->accept();
                break;
            }
        }
#endif
#if QT_CONFIG(whatsthis)
        if (!k->isAccepted()
            && k->modifiers() & Qt::ShiftModifier && k->key() == Qt::Key_F1
            && d->whatsThis.size()) {
            QWhatsThis::showText(mapToGlobal(inputMethodQuery(Qt::ImCursorRectangle).toRect().center()), d->whatsThis, this);
            k->accept();
        }
#endif
    }
        break;
 
    case QEvent::KeyRelease:
        keyReleaseEvent((QKeyEvent*)event);
        Q_FALLTHROUGH();
    case QEvent::ShortcutOverride:
        break;
 
    case QEvent::InputMethod:
        inputMethodEvent((QInputMethodEvent *) event);
        break;
 
    case QEvent::InputMethodQuery: {
            QInputMethodQueryEvent *query = static_cast<QInputMethodQueryEvent *>(event);
            Qt::InputMethodQueries queries = query->queries();
            for (uint i = 0; i < 32; ++i) {
                Qt::InputMethodQuery q = (Qt::InputMethodQuery)(int)(queries & (1<<i));
                if (q) {
                    QVariant v = inputMethodQuery(q);
                    if (q == Qt::ImEnabled && !v.isValid() && isEnabled()) {
                        // Qt:ImEnabled was added in Qt 5.3. So not all widgets support it, even
                        // if they implement IM otherwise (by overriding inputMethodQuery()). Instead
                        // they set the widget attribute Qt::WA_InputMethodEnabled. But this attribute
                        // will only be set if the widget supports IM _and_ is not read-only. So for
                        // read-only widgets, not all IM features will be supported when ImEnabled is
                        // not implemented explicitly (e.g selection handles for read-only widgets on iOS).
                        v = QVariant(testAttribute(Qt::WA_InputMethodEnabled));
                    }
                    query->setValue(q, v);
                }
            }
            query->accept();
        }
        break;
 
    case QEvent::PolishRequest:
        ensurePolished();
        break;
 
    case QEvent::Polish: {
        style()->polish(this);
        setAttribute(Qt::WA_WState_Polished);
        if (!QApplication::font(this).isCopyOf(QApplication::font()))
            d->resolveFont();
        if (!QApplication::palette(this).isCopyOf(QGuiApplication::palette()))
            d->resolvePalette();
    }
        break;
 
    case QEvent::ApplicationWindowIconChange:
        if (isWindow() && !testAttribute(Qt::WA_SetWindowIcon)) {
            d->setWindowIcon_sys();
            d->setWindowIcon_helper();
        }
        break;
    case QEvent::FocusIn:
        focusInEvent((QFocusEvent*)event);
        d->updateWidgetTransform(event);
        break;
 
    case QEvent::FocusOut:
        focusOutEvent((QFocusEvent*)event);
        break;
 
    case QEvent::Enter:
#if QT_CONFIG(statustip)
        if (d->statusTip.size()) {
            QStatusTipEvent tip(d->statusTip);
            QCoreApplication::sendEvent(const_cast<QWidget *>(this), &tip);
        }
#endif
        enterEvent(static_cast<QEnterEvent*>(event));
        break;
 
    case QEvent::Leave:
#if QT_CONFIG(statustip)
        if (d->statusTip.size()) {
            QString empty;
            QStatusTipEvent tip(empty);
            QCoreApplication::sendEvent(const_cast<QWidget *>(this), &tip);
        }
#endif
        leaveEvent(event);
        break;
 
    case QEvent::HoverEnter:
    case QEvent::HoverLeave:
        update();
        break;
 
    case QEvent::Paint:
        // At this point the event has to be delivered, regardless
        // whether the widget isVisible() or not because it
        // already went through the filters
        paintEvent((QPaintEvent*)event);
        break;
 
    case QEvent::Move:
        moveEvent((QMoveEvent*)event);
        d->updateWidgetTransform(event);
        break;
 
    case QEvent::Resize:
        resizeEvent((QResizeEvent*)event);
        d->updateWidgetTransform(event);
        break;
 
    case QEvent::Close:
        closeEvent((QCloseEvent *)event);
        break;
 
#ifndef QT_NO_CONTEXTMENU
    case QEvent::ContextMenu:
        switch (data->context_menu_policy) {
        case Qt::PreventContextMenu:
            break;
        case Qt::DefaultContextMenu:
            contextMenuEvent(static_cast<QContextMenuEvent *>(event));
            break;
        case Qt::CustomContextMenu:
            emit customContextMenuRequested(static_cast<QContextMenuEvent *>(event)->pos());
            break;
#if QT_CONFIG(menu)
        case Qt::ActionsContextMenu:
            if (d->actions.size()) {
                QMenu::exec(d->actions, static_cast<QContextMenuEvent *>(event)->globalPos(),
                            nullptr, this);
                break;
            }
            Q_FALLTHROUGH();
#endif
        default:
            event->ignore();
            break;
        }
        break;
#endif // QT_NO_CONTEXTMENU
 
#if QT_CONFIG(draganddrop)
    case QEvent::Drop:
        dropEvent((QDropEvent*) event);
        break;
 
    case QEvent::DragEnter:
        dragEnterEvent((QDragEnterEvent*) event);
        break;
 
    case QEvent::DragMove:
        dragMoveEvent((QDragMoveEvent*) event);
        break;
 
    case QEvent::DragLeave:
        dragLeaveEvent((QDragLeaveEvent*) event);
        break;
#endif
 
    case QEvent::Show:
        showEvent((QShowEvent*) event);
        break;
 
    case QEvent::Hide:
        hideEvent((QHideEvent*) event);
        break;
 
    case QEvent::ShowWindowRequest:
        if (!isHidden())
            d->show_sys();
        break;
 
    case QEvent::ApplicationFontChange:
        d->resolveFont();
        break;
    case QEvent::ApplicationPaletteChange:
        if (!(windowType() == Qt::Desktop))
            d->resolvePalette();
        break;
 
    case QEvent::ToolBarChange:
    case QEvent::ActivationChange:
    case QEvent::EnabledChange:
    case QEvent::FontChange:
    case QEvent::StyleChange:
    case QEvent::PaletteChange:
    case QEvent::WindowTitleChange:
    case QEvent::IconTextChange:
    case QEvent::ModifiedChange:
    case QEvent::MouseTrackingChange:
    case QEvent::TabletTrackingChange:
    case QEvent::ParentChange:
    case QEvent::LocaleChange:
    case QEvent::MacSizeChange:
    case QEvent::ContentsRectChange:
    case QEvent::ThemeChange:
    case QEvent::ReadOnlyChange:
        changeEvent(event);
        break;
 
    case QEvent::WindowStateChange: {
        const bool wasMinimized = static_cast<const QWindowStateChangeEvent *>(event)->oldState() & Qt::WindowMinimized;
        if (wasMinimized != isMinimized()) {
            QWidget *widget = const_cast<QWidget *>(this);
            if (wasMinimized) {
                // Always send the spontaneous events here, otherwise it can break the application!
                if (!d->childrenShownByExpose) {
                    // Show widgets only when they are not yet shown by the expose event
                    d->showChildren(true);
                    QShowEvent showEvent;
                    QCoreApplication::sendSpontaneousEvent(widget, &showEvent);
                }
                d->childrenHiddenByWState = false; // Set it always to "false" when window is restored
            } else {
                QHideEvent hideEvent;
                QCoreApplication::sendSpontaneousEvent(widget, &hideEvent);
                d->hideChildren(true);
                d->childrenHiddenByWState = true;
            }
            d->childrenShownByExpose = false; // Set it always to "false" when window state changes
        }
        changeEvent(event);
    }
        break;
 
    case QEvent::WindowActivate:
    case QEvent::WindowDeactivate: {
        if (isVisible() && !palette().isEqual(QPalette::Active, QPalette::Inactive))
            update();
        QList<QObject*> childList = d->children;
        for (int i = 0; i < childList.size(); ++i) {
            QWidget *w = qobject_cast<QWidget *>(childList.at(i));
            if (w && w->isVisible() && !w->isWindow())
                QCoreApplication::sendEvent(w, event);
        }
        break; }
 
    case QEvent::LanguageChange:
        changeEvent(event);
        {
            QList<QObject*> childList = d->children;
            for (int i = 0; i < childList.size(); ++i) {
                QObject *o = childList.at(i);
                if (o)
                    QCoreApplication::sendEvent(o, event);
            }
        }
        update();
        break;
 
    case QEvent::ApplicationLayoutDirectionChange:
        d->resolveLayoutDirection();
        break;
 
    case QEvent::LayoutDirectionChange:
        if (d->layout)
            d->layout->invalidate();
        update();
        changeEvent(event);
        break;
    case QEvent::UpdateRequest:
        d->syncBackingStore();
        break;
    case QEvent::UpdateLater:
        update(static_cast<QUpdateLaterEvent*>(event)->region());
        break;
    case QEvent::StyleAnimationUpdate:
        if (isVisible() && !window()->isMinimized()) {
            event->accept();
            update();
        }
        break;
 
    case QEvent::WindowBlocked:
    case QEvent::WindowUnblocked:
        if (!d->children.isEmpty()) {
            QWidget *modalWidget = QApplication::activeModalWidget();
            for (int i = 0; i < d->children.size(); ++i) {
                QObject *o = d->children.at(i);
                if (o && o != modalWidget && o->isWidgetType()) {
                    QWidget *w  = static_cast<QWidget *>(o);
                    // do not forward the event to child windows; QApplication does this for us
                    if (!w->isWindow())
                        QCoreApplication::sendEvent(w, event);
                }
            }
        }
        break;
#if QT_CONFIG(tooltip)
    case QEvent::ToolTip:
        if (!d->toolTip.isEmpty())
            QToolTip::showText(static_cast<QHelpEvent*>(event)->globalPos(), d->toolTip, this, QRect(), d->toolTipDuration);
        else
            event->ignore();
        break;
#endif
#if QT_CONFIG(whatsthis)
    case QEvent::WhatsThis:
        if (d->whatsThis.size())
            QWhatsThis::showText(static_cast<QHelpEvent *>(event)->globalPos(), d->whatsThis, this);
        else
            event->ignore();
        break;
    case QEvent::QueryWhatsThis:
        if (d->whatsThis.isEmpty())
            event->ignore();
        break;
#endif
    case QEvent::EmbeddingControl:
        d->topData()->frameStrut.setCoords(0 ,0, 0, 0);
        data->fstrut_dirty = false;
        break;
#ifndef QT_NO_ACTION
    case QEvent::ActionAdded:
    case QEvent::ActionRemoved:
    case QEvent::ActionChanged:
        actionEvent((QActionEvent*)event);
        break;
#endif
 
    case QEvent::KeyboardLayoutChange:
        {
            changeEvent(event);
 
            // inform children of the change
            QList<QObject*> childList = d->children;
            for (int i = 0; i < childList.size(); ++i) {
                QWidget *w = qobject_cast<QWidget *>(childList.at(i));
                if (w && w->isVisible() && !w->isWindow())
                    QCoreApplication::sendEvent(w, event);
            }
            break;
        }
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
    case QEvent::TouchCancel:
    {
        event->ignore();
        break;
    }
#ifndef QT_NO_GESTURES
    case QEvent::Gesture:
        event->ignore();
        break;
#endif
    case QEvent::ScreenChangeInternal:
        if (const QTLWExtra *te = d->maybeTopData()) {
            const QWindow *win = te->window;
            d->setWinId((win && win->handle()) ? win->handle()->winId() : 0);
        }
        break;
    case QEvent::DevicePixelRatioChange:
        if (d->data.fnt.d->dpi != logicalDpiY())
            d->updateFont(d->data.fnt);
        d->renderToTextureReallyDirty = 1;
        break;
    case QEvent::DynamicPropertyChange: {
        const QByteArray &propName = static_cast<QDynamicPropertyChangeEvent *>(event)->propertyName();
        if (propName.size() == 13 && !qstrncmp(propName, "_q_customDpi", 12)) {
            uint value = property(propName.constData()).toUInt();
            if (!d->extra)
                d->createExtra();
            const char axis = propName.at(12);
            if (axis == 'X')
                d->extra->customDpiX = value;
            else if (axis == 'Y')
                d->extra->customDpiY = value;
            d->updateFont(d->data.fnt);
        }
        if (windowHandle() && !qstrncmp(propName, "_q_platform_", 12))
            windowHandle()->setProperty(propName, property(propName));
        Q_FALLTHROUGH();
    }
    default:
        return QObject::event(event);
    }
    return true;
}
 
void QWidget::changeEvent(QEvent * event)
{
    switch(event->type()) {
    case QEvent::EnabledChange: {
        update();
#if QT_CONFIG(accessibility)
        QAccessible::State s;
        s.disabled = true;
        QAccessibleStateChangeEvent event(this, s);
        QAccessible::updateAccessibility(&event);
#endif
        break;
    }
 
    case QEvent::FontChange:
    case QEvent::StyleChange: {
        Q_D(QWidget);
        update();
        updateGeometry();
        if (d->layout)
            d->layout->invalidate();
        break;
    }
 
    case QEvent::PaletteChange:
        update();
        break;
 
    case QEvent::ThemeChange:
        if (QGuiApplication::desktopSettingsAware() && windowType() != Qt::Desktop
            && qApp && !QCoreApplication::closingDown()) {
            if (testAttribute(Qt::WA_WState_Polished))
                QApplication::style()->unpolish(this);
            if (testAttribute(Qt::WA_WState_Polished))
                QApplication::style()->polish(this);
            QEvent styleChangedEvent(QEvent::StyleChange);
            QCoreApplication::sendEvent(this, &styleChangedEvent);
            if (isVisible())
                update();
        }
        break;
 
#ifdef Q_OS_MAC
    case QEvent::MacSizeChange:
        updateGeometry();
        break;
#endif
 
    default:
        break;
    }
}
 
void QWidget::mouseMoveEvent(QMouseEvent *event)
{
    event->ignore();
}
 
void QWidget::mousePressEvent(QMouseEvent *event)
{
    event->ignore();
    if ((windowType() == Qt::Popup)) {
        event->accept();
        QWidget* w;
        while ((w = QApplication::activePopupWidget()) && w != this){
            w->close();
            if (QApplication::activePopupWidget() == w) // widget does not want to disappear
                w->hide(); // hide at least
        }
        if (!rect().contains(event->position().toPoint())){
            close();
        }
    }
}
 
void QWidget::mouseReleaseEvent(QMouseEvent *event)
{
    event->ignore();
}
 
void QWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    mousePressEvent(event);
}
 
#if QT_CONFIG(wheelevent)
void QWidget::wheelEvent(QWheelEvent *event)
{
    event->ignore();
}
#endif // QT_CONFIG(wheelevent)
 
#if QT_CONFIG(tabletevent)
void QWidget::tabletEvent(QTabletEvent *event)
{
    event->ignore();
}
#endif // QT_CONFIG(tabletevent)
 
void QWidget::keyPressEvent(QKeyEvent *event)
{
#ifndef QT_NO_SHORTCUT
    if ((windowType() == Qt::Popup) && event->matches(QKeySequence::Cancel)) {
        event->accept();
        close();
    } else
#endif
    {
        event->ignore();
    }
}
 
void QWidget::keyReleaseEvent(QKeyEvent *event)
{
    event->ignore();
}
 
void QWidget::focusInEvent(QFocusEvent *)
{
    if (focusPolicy() != Qt::NoFocus || !isWindow()) {
        update();
    }
}
 
void QWidget::focusOutEvent(QFocusEvent *)
{
    if (focusPolicy() != Qt::NoFocus || !isWindow())
        update();
 
#if !defined(QT_PLATFORM_UIKIT)
    // FIXME: revisit autoSIP logic, QTBUG-42906
    if (qApp->autoSipEnabled() && testAttribute(Qt::WA_InputMethodEnabled))
        QGuiApplication::inputMethod()->hide();
#endif
}
 
void QWidget::enterEvent(QEnterEvent *)
{
}
 
void QWidget::leaveEvent(QEvent *)
{
}
 
void QWidget::paintEvent(QPaintEvent *)
{
}
 
 
void QWidget::moveEvent(QMoveEvent *)
{
}
 
 
void QWidget::resizeEvent(QResizeEvent * /* event */)
{
}
 
#ifndef QT_NO_ACTION
void QWidget::actionEvent(QActionEvent *)
{
 
}
#endif
 
void QWidget::closeEvent(QCloseEvent *event)
{
    event->accept();
}
 
#ifndef QT_NO_CONTEXTMENU
void QWidget::contextMenuEvent(QContextMenuEvent *event)
{
    event->ignore();
}
#endif // QT_NO_CONTEXTMENU
 
 
void QWidget::inputMethodEvent(QInputMethodEvent *event)
{
    event->ignore();
}
 
QVariant QWidget::inputMethodQuery(Qt::InputMethodQuery query) const
{
    switch(query) {
    case Qt::ImCursorRectangle:
        return QRect(width()/2, 0, 1, height());
    case Qt::ImFont:
        return font();
    case Qt::ImAnchorPosition:
        // Fallback.
        return inputMethodQuery(Qt::ImCursorPosition);
    case Qt::ImHints:
        return (int)inputMethodHints();
    case Qt::ImInputItemClipRectangle:
        return d_func()->clipRect();
    default:
        return QVariant();
    }
}
 
Qt::InputMethodHints QWidget::inputMethodHints() const
{
#if QT_CONFIG(im)
    const QWidgetPrivate *priv = d_func();
    while (priv->inheritsInputMethodHints) {
        priv = priv->q_func()->parentWidget()->d_func();
        Q_ASSERT(priv);
    }
    return priv->imHints;
#else
    return Qt::ImhNone;
#endif
}
 
void QWidget::setInputMethodHints(Qt::InputMethodHints hints)
{
#ifndef QT_NO_IM
    Q_D(QWidget);
    if (d->imHints == hints)
        return;
    d->imHints = hints;
    if (this == QGuiApplication::focusObject())
        QGuiApplication::inputMethod()->update(Qt::ImHints);
#else
    Q_UNUSED(hints);
#endif //QT_NO_IM
}
 
 
#if QT_CONFIG(draganddrop)
 
void QWidget::dragEnterEvent(QDragEnterEvent *)
{
}
 
void QWidget::dragMoveEvent(QDragMoveEvent *)
{
}
 
void QWidget::dragLeaveEvent(QDragLeaveEvent *)
{
}
 
void QWidget::dropEvent(QDropEvent *)
{
}
 
#endif // QT_CONFIG(draganddrop)
 
void QWidget::showEvent(QShowEvent *)
{
}
 
void QWidget::hideEvent(QHideEvent *)
{
}
 
bool QWidget::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)
{
    Q_UNUSED(eventType);
    Q_UNUSED(message);
    Q_UNUSED(result);
    return false;
}
 
void QWidget::ensurePolished() const
{
    Q_D(const QWidget);
 
    const QMetaObject *m = metaObject();
    if (m == d->polished)
        return;
    d->polished = m;
 
    QEvent e(QEvent::Polish);
    QCoreApplication::sendEvent(const_cast<QWidget *>(this), &e);
 
    // polish children after 'this'
    QList<QObject*> children = d->children;
    for (int i = 0; i < children.size(); ++i) {
        QObject *o = children.at(i);
        if (!o->isWidgetType())
            continue;
        if (QWidget *w = qobject_cast<QWidget *>(o))
            w->ensurePolished();
    }
 
    if (d->parent && d->sendChildEvents) {
        QChildEvent e(QEvent::ChildPolished, const_cast<QWidget *>(this));
        QCoreApplication::sendEvent(d->parent, &e);
    }
}
 
QRegion QWidget::mask() const
{
    Q_D(const QWidget);
    return d->extra ? d->extra->mask : QRegion();
}
 
QLayout *QWidget::layout() const
{
    return d_func()->layout;
}
 
 
void QWidget::setLayout(QLayout *l)
{
    if (Q_UNLIKELY(!l)) {
        qWarning("QWidget::setLayout: Cannot set layout to 0");
        return;
    }
    if (layout()) {
        if (Q_UNLIKELY(layout() != l))
            qWarning("QWidget::setLayout: Attempting to set QLayout \"%s\" on %s \"%s\", which already has a"
                     " layout", l->objectName().toLocal8Bit().data(), metaObject()->className(),
                     objectName().toLocal8Bit().data());
        return;
    }
 
    QObject *oldParent = l->parent();
    if (oldParent && oldParent != this) {
        if (oldParent->isWidgetType()) {
            // Steal the layout off a widget parent. Takes effect when
            // morphing laid-out container widgets in Designer.
            QWidget *oldParentWidget = static_cast<QWidget *>(oldParent);
            oldParentWidget->takeLayout();
        } else {
            qWarning("QWidget::setLayout: Attempting to set QLayout \"%s\" on %s \"%s\", when the QLayout already has a parent",
                     l->objectName().toLocal8Bit().data(), metaObject()->className(),
                     objectName().toLocal8Bit().data());
            return;
        }
    }
 
    Q_D(QWidget);
    l->d_func()->topLevel = true;
    d->layout = l;
    if (oldParent != this) {
        l->setParent(this);
        l->d_func()->reparentChildWidgets(this);
        l->invalidate();
    }
 
    if (isWindow() && d->maybeTopData())
        d->topData()->sizeAdjusted = false;
}
 
QLayout *QWidget::takeLayout()
{
    Q_D(QWidget);
    QLayout *l =  layout();
    if (!l)
        return nullptr;
    d->layout = nullptr;
    l->setParent(nullptr);
    return l;
}
 
QSizePolicy QWidget::sizePolicy() const
{
    Q_D(const QWidget);
    return d->size_policy;
}
 
void QWidget::setSizePolicy(QSizePolicy policy)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_WState_OwnSizePolicy);
    if (policy == d->size_policy)
        return;
 
    if (d->size_policy.retainSizeWhenHidden() != policy.retainSizeWhenHidden())
        d->retainSizeWhenHiddenChanged = 1;
 
    d->size_policy = policy;
 
#if QT_CONFIG(graphicsview)
    if (const auto &extra = d->extra) {
        if (extra->proxyWidget)
            extra->proxyWidget->setSizePolicy(policy);
    }
#endif
 
    updateGeometry();
    d->retainSizeWhenHiddenChanged = 0;
 
    if (isWindow() && d->maybeTopData())
        d->topData()->sizeAdjusted = false;
}
 
int QWidget::heightForWidth(int w) const
{
    if (layout() && layout()->hasHeightForWidth())
        return layout()->totalHeightForWidth(w);
    return -1;
}
 
 
bool QWidget::hasHeightForWidth() const
{
    Q_D(const QWidget);
    return d->layout ? d->layout->hasHeightForWidth() : d->size_policy.hasHeightForWidth();
}
 
QWidget *QWidget::childAt(const QPoint &p) const
{
    return d_func()->childAt_helper(p, false);
}
 
QWidget *QWidgetPrivate::childAt_helper(const QPoint &p, bool ignoreChildrenInDestructor) const
{
    if (children.isEmpty())
        return nullptr;
 
    if (!pointInsideRectAndMask(p))
        return nullptr;
    return childAtRecursiveHelper(p, ignoreChildrenInDestructor);
}
 
QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChildrenInDestructor) const
{
    for (int i = children.size() - 1; i >= 0; --i) {
        QWidget *child = qobject_cast<QWidget *>(children.at(i));
        if (!child || child->isWindow() || child->isHidden() || child->testAttribute(Qt::WA_TransparentForMouseEvents)
            || (ignoreChildrenInDestructor && child->data->in_destructor)) {
            continue;
        }
 
        // Map the point 'p' from parent coordinates to child coordinates.
        QPoint childPoint = p;
        childPoint -= child->data->crect.topLeft();
 
        // Check if the point hits the child.
        if (!child->d_func()->pointInsideRectAndMask(childPoint))
            continue;
 
        // Do the same for the child's descendants.
        if (QWidget *w = child->d_func()->childAtRecursiveHelper(childPoint, ignoreChildrenInDestructor))
            return w;
 
        // We have found our target; namely the child at position 'p'.
        return child;
    }
    return nullptr;
}
 
void QWidgetPrivate::updateGeometry_helper(bool forceUpdate)
{
    Q_Q(QWidget);
    if (widgetItem)
        widgetItem->invalidateSizeCache();
    QWidget *parent;
    if (forceUpdate || !extra || extra->minw != extra->maxw || extra->minh != extra->maxh) {
        const int isHidden = q->isHidden() && !size_policy.retainSizeWhenHidden() && !retainSizeWhenHiddenChanged;
 
        if (!q->isWindow() && !isHidden && (parent = q->parentWidget())) {
            if (parent->d_func()->layout)
                parent->d_func()->layout->invalidate();
            else if (parent->isVisible())
                QCoreApplication::postEvent(parent, new QEvent(QEvent::LayoutRequest));
        }
    }
}
 
void QWidget::updateGeometry()
{
    Q_D(QWidget);
    d->updateGeometry_helper(false);
}
 
void QWidget::setWindowFlags(Qt::WindowFlags flags)
{
    Q_D(QWidget);
    d->setWindowFlags(flags);
}
 
void QWidget::setWindowFlag(Qt::WindowType flag, bool on)
{
    Q_D(QWidget);
    if (on)
        d->setWindowFlags(data->window_flags | flag);
    else
        d->setWindowFlags(data->window_flags & ~flag);
}
 
void QWidgetPrivate::setWindowFlags(Qt::WindowFlags flags)
{
    Q_Q(QWidget);
    if (q->data->window_flags == flags)
        return;
 
    if ((q->data->window_flags | flags) & Qt::Window) {
        // the old type was a window and/or the new type is a window
        QPoint oldPos = q->pos();
        bool visible = q->isVisible();
        const bool windowFlagChanged = (q->data->window_flags ^ flags) & Qt::Window;
        q->setParent(q->parentWidget(), flags);
 
        // if both types are windows or neither of them are, we restore
        // the old position
        if (!windowFlagChanged && (visible || q->testAttribute(Qt::WA_Moved)))
            q->move(oldPos);
        // for backward-compatibility we change Qt::WA_QuitOnClose attribute value only when the window was recreated.
        adjustQuitOnCloseAttribute();
    } else {
        q->data->window_flags = flags;
    }
}
 
void QWidget::overrideWindowFlags(Qt::WindowFlags flags)
{
    data->window_flags = flags;
}
 
void QWidget::setParent(QWidget *parent)
{
    if (parent == parentWidget())
        return;
    setParent((QWidget*)parent, windowFlags() & ~Qt::WindowType_Mask);
}
 
void qSendWindowChangeToTextureChildrenRecursively(QWidget *widget, QEvent::Type eventType)
{
    QWidgetPrivate *d = QWidgetPrivate::get(widget);
    if (d->renderToTexture) {
        QEvent e(eventType);
        QCoreApplication::sendEvent(widget, &e);
    }
 
    for (int i = 0; i < d->children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(d->children.at(i));
        if (w && !w->isWindow())
            qSendWindowChangeToTextureChildrenRecursively(w, eventType);
    }
 
    // Notify QWidgetWindow after we've notified all child QWidgets
    if (auto *window = d->windowHandle(QWidgetPrivate::WindowHandleMode::Direct)) {
        QEvent e(eventType);
        QCoreApplication::sendEvent(window, &e);
    }
}
 
void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)
{
    Q_D(QWidget);
    Q_ASSERT_X(this != parent, Q_FUNC_INFO, "Cannot parent a QWidget to itself");
#ifdef QT_DEBUG
    const auto checkForParentChildLoops = qScopeGuard([&](){
        int depth = 0;
        auto p = parentWidget();
        while (p) {
            if (++depth == QObjectPrivate::CheckForParentChildLoopsWarnDepth) {
                qWarning("QWidget %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; "
                         "this is undefined behavior",
                         this, metaObject()->className(), qPrintable(objectName()));
            }
            p = p->parentWidget();
        }
    });
#endif
 
    const bool resized = testAttribute(Qt::WA_Resized);
    const bool wasCreated = testAttribute(Qt::WA_WState_Created);
    QWidget *oldtlw = window();
    Q_ASSERT(oldtlw);
    QWidget *oldParentWithWindow = d->closestParentWidgetWithWindowHandle();
 
    if (f & Qt::Window) // Frame geometry likely changes, refresh.
        d->data.fstrut_dirty = true;
 
    QWidget *desktopWidget = nullptr;
    if (parent && parent->windowType() == Qt::Desktop)
        desktopWidget = parent;
    bool newParent = (parent != parentWidget()) || desktopWidget;
 
    if (newParent && parent && !desktopWidget) {
        if (testAttribute(Qt::WA_NativeWindow) && !QCoreApplication::testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
            parent->d_func()->enforceNativeChildren();
        else if (parent->d_func()->nativeChildrenForced() || parent->testAttribute(Qt::WA_PaintOnScreen))
            setAttribute(Qt::WA_NativeWindow);
    }
 
    if (wasCreated) {
        if (!testAttribute(Qt::WA_WState_Hidden)) {
            // Hiding the widget will set WA_WState_Hidden as well, which would
            // normally require the widget to be explicitly shown again to become
            // visible, even as a child widget. But we refine this value later in
            // setParent_sys(), applying WA_WState_Hidden based on whether the
            // widget is a top level or not.
            hide();
 
            // We reset WA_WState_ExplicitShowHide here, likely as a remnant of
            // when we only had QWidget::setVisible(), which is treated as an
            // explicit show/hide. Nowadays we have QWidgetPrivate::setVisible(),
            // that allows us to hide a widget without affecting ExplicitShowHide.
            // Though it can be argued that ExplicitShowHide should reflect the
            // last update of the widget's state, so if we hide the widget as a
            // side effect of changing parent, perhaps we _should_ reset it?
            setAttribute(Qt::WA_WState_ExplicitShowHide, false);
        }
        if (newParent) {
            QEvent e(QEvent::ParentAboutToChange);
            QCoreApplication::sendEvent(this, &e);
        }
    }
 
    // texture-based widgets need a pre-notification when their associated top-level window changes
    // This is not under the wasCreated/newParent conditions above in order to also play nice with QDockWidget.
    const bool oldParentUsesRhiFlush = oldParentWithWindow ? oldParentWithWindow->d_func()->usesRhiFlush : false;
    if (oldParentUsesRhiFlush && ((!parent && parentWidget()) || (parent && parent->window() != oldtlw)))
        qSendWindowChangeToTextureChildrenRecursively(this, QEvent::WindowAboutToChangeInternal);
 
    // If we get parented into another window, children will be folded
    // into the new parent's focus chain, so clear focus now.
    if (newParent && isAncestorOf(focusWidget()) && !(f & Qt::Window))
        focusWidget()->clearFocus();
 
    d->setParent_sys(parent, f);
 
    if (desktopWidget)
        parent = nullptr;
 
    if (d->textureChildSeen && parent) {
        // set the textureChildSeen flag up the whole parent chain
        QWidgetPrivate::get(parent)->setTextureChildSeen();
    }
 
    if (QWidgetRepaintManager *oldPaintManager = oldtlw->d_func()->maybeRepaintManager()) {
        if (newParent)
            oldPaintManager->removeDirtyWidget(this);
        // Move the widget and all its static children from
        // the old backing store to the new one.
        oldPaintManager->moveStaticWidgets(this);
    }
 
    d->reparentFocusWidgets(oldtlw);
    setAttribute(Qt::WA_Resized, resized);
 
    const bool useStyleSheetPropagationInWidgetStyles =
        QCoreApplication::testAttribute(Qt::AA_UseStyleSheetPropagationInWidgetStyles);
 
    if (!useStyleSheetPropagationInWidgetStyles && !testAttribute(Qt::WA_StyleSheet)
        && (!parent || !parent->testAttribute(Qt::WA_StyleSheet))) {
        // if the parent has a font set or inherited, then propagate the mask to the new child
        if (parent) {
            const auto pd = parent->d_func();
            d->inheritedFontResolveMask = pd->directFontResolveMask | pd->inheritedFontResolveMask;
            d->inheritedPaletteResolveMask = pd->directPaletteResolveMask | pd->inheritedPaletteResolveMask;
        }
        d->resolveFont();
        d->resolvePalette();
    }
    d->resolveLayoutDirection();
    d->resolveLocale();
 
    // Note: GL widgets under WGL or EGL will always need a ParentChange
    // event to handle recreation/rebinding of the GL context, hence the
    // (f & Qt::MSWindowsOwnDC) clause (which is set on QGLWidgets on all
    // platforms).
    if (newParent || !wasCreated
#if QT_CONFIG(opengles2)
        || (f & Qt::MSWindowsOwnDC)
#endif
        ) {
        // propagate enabled updates enabled state to non-windows
        if (!isWindow()) {
            if (!testAttribute(Qt::WA_ForceDisabled))
                d->setEnabled_helper(parent ? parent->isEnabled() : true);
            if (!testAttribute(Qt::WA_ForceUpdatesDisabled))
                d->setUpdatesEnabled_helper(parent ? parent->updatesEnabled() : true);
        }
        d->inheritStyle();
 
        // send and post remaining QObject events
        if (parent && d->sendChildEvents) {
            QChildEvent e(QEvent::ChildAdded, this);
            QCoreApplication::sendEvent(parent, &e);
        }
 
        if (parent && d->sendChildEvents && d->polished) {
            QChildEvent e(QEvent::ChildPolished, this);
            QCoreApplication::sendEvent(parent, &e);
        }
 
        QEvent e(QEvent::ParentChange);
        QCoreApplication::sendEvent(this, &e);
    }
 
    // texture-based widgets need another event when their top-level window
    // changes (more precisely, has already changed at this point)
    if (oldParentUsesRhiFlush && oldtlw != window())
        qSendWindowChangeToTextureChildrenRecursively(this, QEvent::WindowChangeInternal);
 
    if (!wasCreated) {
        if (isWindow() || parentWidget()->isVisible())
            setAttribute(Qt::WA_WState_Hidden, true);
        else if (!testAttribute(Qt::WA_WState_ExplicitShowHide))
            setAttribute(Qt::WA_WState_Hidden, false);
    }
 
    d->updateIsOpaque();
 
#if QT_CONFIG(graphicsview)
    // Embed the widget into a proxy if the parent is embedded.
    // ### Doesn't handle reparenting out of an embedded widget.
    if (oldtlw->graphicsProxyWidget()) {
        if (QGraphicsProxyWidget *ancestorProxy = d->nearestGraphicsProxyWidget(oldtlw))
            ancestorProxy->d_func()->unembedSubWindow(this);
    }
    if (isWindow() && parent && !graphicsProxyWidget() && !bypassGraphicsProxyWidget(this)) {
        if (QGraphicsProxyWidget *ancestorProxy = d->nearestGraphicsProxyWidget(parent))
            ancestorProxy->d_func()->embedSubWindow(this);
    }
#endif
 
    if (d->extra && d->extra->hasWindowContainer)
        QWindowContainer::parentWasChanged(this);
 
    QWidget *newParentWithWindow = d->closestParentWidgetWithWindowHandle();
    if (newParentWithWindow && newParentWithWindow != oldParentWithWindow) {
        // Check if the native parent now needs to switch to RHI
        qCDebug(lcWidgetPainting) << "Evaluating whether reparenting of" << this
              << "into" << parent << "requires RHI enablement for" << newParentWithWindow;
 
        QPlatformBackingStoreRhiConfig rhiConfig;
        QSurface::SurfaceType surfaceType = QSurface::RasterSurface;
 
        // First evaluate whether the reparented widget uses RHI.
        // We do this as a separate step because the performance
        // implications of always checking the native parent are
        // problematic when it comes to large widget trees.
        if (q_evaluateRhiConfig(this, &rhiConfig, &surfaceType)) {
            // Then check whether the native parent requires RHI
            // as a result. It may not, if this widget is a native
            // window, and can handle its own RHI flushing.
            if (q_evaluateRhiConfig(newParentWithWindow, nullptr, nullptr)) {
                // Finally, check whether we need to recreate the
                // native parent to enable RHI flushing.
                auto *existingWindow = newParentWithWindow->windowHandle();
                auto existingSurfaceType = existingWindow->surfaceType();
                if (existingSurfaceType != surfaceType) {
                    qCDebug(lcWidgetPainting)
                        << "Recreating" << existingWindow
                        << "with current type" << existingSurfaceType
                        << "to support" << surfaceType;
                    const auto windowStateBeforeDestroy = newParentWithWindow->windowState();
                    const auto visibilityBeforeDestroy = newParentWithWindow->isVisible();
                    newParentWithWindow->destroy();
                    newParentWithWindow->create();
                    Q_ASSERT(newParentWithWindow->windowHandle());
                    newParentWithWindow->windowHandle()->setWindowStates(windowStateBeforeDestroy);
                    QWidgetPrivate::get(newParentWithWindow)->setVisible(visibilityBeforeDestroy);
                } else if (auto *backingStore = newParentWithWindow->backingStore()) {
                    // If we don't recreate we still need to make sure the native parent
                    // widget has a RHI config that the reparented widget can use.
                    backingStore->handle()->createRhi(existingWindow, rhiConfig);
                    // And that it knows it's now flushing with RHI
                    QWidgetPrivate::get(newParentWithWindow)->usesRhiFlush = true;
                }
            }
        }
    }
}
 
void QWidgetPrivate::setParent_sys(QWidget *newparent, Qt::WindowFlags f)
{
    Q_Q(QWidget);
 
    Qt::WindowFlags oldFlags = data.window_flags;
    bool wasCreated = q->testAttribute(Qt::WA_WState_Created);
 
    QScreen *targetScreen = nullptr;
    // Handle a request to move the widget to a particular screen
    if (newparent && newparent->windowType() == Qt::Desktop) {
        // make sure the widget is created on the same screen as the
        // programmer specified desktop widget
        targetScreen = newparent->screen();
        newparent = nullptr;
    }
 
    setWinId(0);
 
    if (!newparent) {
        f |= Qt::Window;
        if (parent)
            targetScreen = q->parentWidget()->window()->screen();
    }
 
    const bool destroyWindow = (
        // Reparenting top level to child
        (oldFlags & Qt::Window) && !(f & Qt::Window)
        // And we can dispose of the window
        && wasCreated && !q->testAttribute(Qt::WA_NativeWindow)
    );
 
    if (parent != newparent) {
        // Update object parent now, so we can resolve new parent window below
        QObjectPrivate::setParent_helper(newparent);
 
        if (q->windowHandle())
            q->windowHandle()->setFlags(f);
 
        // If the widget itself or any of its children have been created,
        // we need to reparent their QWindows as well.
        QWidget *parentWithWindow = closestParentWidgetWithWindowHandle();
        // But if the widget is about to be destroyed we must skip the
        // widget itself, and only reparent children.
        if (destroyWindow)
            reparentWidgetWindowChildren(parentWithWindow);
        else
            reparentWidgetWindows(parentWithWindow, f);
    }
 
    bool explicitlyHidden = isExplicitlyHidden();
 
    if (destroyWindow) {
        if (extra && extra->hasWindowContainer)
            QWindowContainer::toplevelAboutToBeDestroyed(q);
 
        // There shouldn't be any QWindow children left, but if there
        // are, re-parent them now, before we destroy.
        if (!q->windowHandle()->children().isEmpty()) {
            QWidget *parentWithWindow = closestParentWidgetWithWindowHandle();
            QWindow *newParentWindow = parentWithWindow ? parentWithWindow->windowHandle() : nullptr;
            for (QObject *child : q->windowHandle()->children()) {
                if (QWindow *childWindow = qobject_cast<QWindow *>(child)) {
                    qCWarning(lcWidgetWindow) << "Reparenting" << childWindow
                                              << "before destroying" << this;
                    childWindow->setParent(newParentWindow);
                }
            }
        }
 
        // We have reparented any child windows of the widget we are
        // about to destroy to the new parent window handle, so we can
        // safely destroy this widget without destroying sub windows.
        q->destroy(true, false);
    }
 
    adjustFlags(f, q);
    data.window_flags = f;
    q->setAttribute(Qt::WA_WState_Created, false);
    q->setAttribute(Qt::WA_WState_Visible, false);
    q->setAttribute(Qt::WA_WState_Hidden, false);
 
    if (newparent && wasCreated && (q->testAttribute(Qt::WA_NativeWindow) || (f & Qt::Window)))
        q->createWinId();
 
    if (q->isWindow() || (!newparent || newparent->isVisible()) || explicitlyHidden)
        q->setAttribute(Qt::WA_WState_Hidden);
    q->setAttribute(Qt::WA_WState_ExplicitShowHide, explicitlyHidden);
 
    // move the window to the selected screen
    if (!newparent && targetScreen) {
        // only if it is already created
        if (q->testAttribute(Qt::WA_WState_Created))
            q->windowHandle()->setScreen(targetScreen);
        else
            topData()->initialScreen = targetScreen;
    }
}
 
void QWidgetPrivate::reparentWidgetWindows(QWidget *parentWithWindow, Qt::WindowFlags windowFlags)
{
    if (QWindow *window = windowHandle()) {
        // Reparent this QWindow, and all QWindow children will follow
        if (parentWithWindow) {
            // The reparented widget has not updated its window flags yet,
            // so we can't ask the widget directly. And we can't use the
            // QWindow flags, as unlike QWidgets the QWindow flags always
            // reflect Qt::Window, even for child windows. And we can't use
            // QWindow::isTopLevel() either, as that depends on the parent,
            // which we are in the process of updating. So we propagate the
            // new flags of the reparented window from setParent_sys().
            if (windowFlags & Qt::Window) {
                // Top level windows can only have transient parents,
                // and the transient parent must be another top level.
                QWidget *topLevel = parentWithWindow->window();
                auto *transientParent = topLevel->windowHandle();
                Q_ASSERT(transientParent);
                qCDebug(lcWidgetWindow) << "Setting" << window << "transient parent to" << transientParent;
                window->setTransientParent(transientParent);
                window->setParent(nullptr);
            } else {
                auto *parentWindow = parentWithWindow->windowHandle();
                qCDebug(lcWidgetWindow) << "Reparenting" << window << "into" << parentWindow;
                window->setTransientParent(nullptr);
                window->setParent(parentWindow);
            }
        } else {
            qCDebug(lcWidgetWindow) << "Making" << window << "top level window";
            window->setTransientParent(nullptr);
            window->setParent(nullptr);
        }
    } else {
        reparentWidgetWindowChildren(parentWithWindow);
    }
}
 
void QWidgetPrivate::reparentWidgetWindowChildren(QWidget *parentWithWindow)
{
    for (auto *child : std::as_const(children)) {
        if (auto *childWidget = qobject_cast<QWidget*>(child)) {
            auto *childPrivate = QWidgetPrivate::get(childWidget);
            childPrivate->reparentWidgetWindows(parentWithWindow);
        }
    }
}
 
void QWidget::scroll(int dx, int dy)
{
    if ((!updatesEnabled() && children().size() == 0) || !isVisible())
        return;
    if (dx == 0 && dy == 0)
        return;
    Q_D(QWidget);
#if QT_CONFIG(graphicsview)
    if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
        // Graphics View maintains its own dirty region as a list of rects;
        // until we can connect item updates directly to the view, we must
        // separately add a translated dirty region.
        for (const QRect &rect : d->dirty)
            proxy->update(rect.translated(dx, dy));
        proxy->scroll(dx, dy, proxy->subWidgetRect(this));
        return;
    }
#endif
    d->setDirtyOpaqueRegion();
    d->scroll_sys(dx, dy);
}
 
void QWidgetPrivate::scroll_sys(int dx, int dy)
{
    Q_Q(QWidget);
    scrollChildren(dx, dy);
    scrollRect(q->rect(), dx, dy);
}
 
void QWidget::scroll(int dx, int dy, const QRect &r)
{
 
    if ((!updatesEnabled() && children().size() == 0) || !isVisible())
        return;
    if (dx == 0 && dy == 0)
        return;
    Q_D(QWidget);
#if QT_CONFIG(graphicsview)
    if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
        // Graphics View maintains its own dirty region as a list of rects;
        // until we can connect item updates directly to the view, we must
        // separately add a translated dirty region.
        if (!d->dirty.isEmpty()) {
            for (const QRect &rect : d->dirty.translated(dx, dy) & r)
                proxy->update(rect);
        }
        proxy->scroll(dx, dy, r.translated(proxy->subWidgetRect(this).topLeft().toPoint()));
        return;
    }
#endif
    d->scroll_sys(dx, dy, r);
}
 
void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
{
    scrollRect(r, dx, dy);
}
 
void QWidget::repaint()
{
    repaint(rect());
}
 
void QWidget::repaint(int x, int y, int w, int h)
{
    if (x > data->crect.width() || y > data->crect.height())
        return;
 
    if (w < 0)
        w = data->crect.width()  - x;
    if (h < 0)
        h = data->crect.height() - y;
 
    repaint(QRect(x, y, w, h));
}
 
void QWidget::repaint(const QRect &rect)
{
    Q_D(QWidget);
    d->repaint(rect);
}
 
void QWidget::repaint(const QRegion &rgn)
{
    Q_D(QWidget);
    d->repaint(rgn);
}
 
template <typename T>
void QWidgetPrivate::repaint(T r)
{
    Q_Q(QWidget);
 
    if (!q->isVisible() || !q->updatesEnabled() || r.isEmpty())
        return;
 
    QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
    if (tlwExtra && tlwExtra->backingStore && tlwExtra->repaintManager)
        tlwExtra->repaintManager->markDirty(r, q, QWidgetRepaintManager::UpdateNow);
}
 
void QWidget::update()
{
    update(rect());
}
 
void QWidget::update(const QRect &rect)
{
    Q_D(QWidget);
    d->update(rect);
}
 
void QWidget::update(const QRegion &rgn)
{
    Q_D(QWidget);
    d->update(rgn);
}
 
template <typename T>
void QWidgetPrivate::update(T r)
{
    Q_Q(QWidget);
 
    if (renderToTexture && !q->isVisible()) {
        renderToTextureReallyDirty = 1;
        return;
    }
 
    if (!q->isVisible() || !q->updatesEnabled())
        return;
 
    T clipped = r & q->rect();
 
    if (clipped.isEmpty())
        return;
 
    if (q->testAttribute(Qt::WA_WState_InPaintEvent)) {
        QCoreApplication::postEvent(q, new QUpdateLaterEvent(clipped));
        return;
    }
 
    QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
    if (tlwExtra && tlwExtra->backingStore && tlwExtra->repaintManager)
        tlwExtra->repaintManager->markDirty(clipped, q);
}
 
static void setAttribute_internal(Qt::WidgetAttribute attribute, bool on, QWidgetData *data,
                                  QWidgetPrivate *d)
{
    if (attribute < int(8*sizeof(uint))) {
        if (on)
            data->widget_attributes |= (1<<attribute);
        else
            data->widget_attributes &= ~(1<<attribute);
    } else {
        const int x = attribute - 8*sizeof(uint);
        const int int_off = x / (8*sizeof(uint));
        if (on)
            d->high_attributes[int_off] |= (1<<(x-(int_off*8*sizeof(uint))));
        else
            d->high_attributes[int_off] &= ~(1<<(x-(int_off*8*sizeof(uint))));
    }
}
 
#ifdef Q_OS_MAC
void QWidgetPrivate::macUpdateSizeAttribute()
{
    Q_Q(QWidget);
    QEvent event(QEvent::MacSizeChange);
    QCoreApplication::sendEvent(q, &event);
    for (int i = 0; i < children.size(); ++i) {
        QWidget *w = qobject_cast<QWidget *>(children.at(i));
        if (w && (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))
              && !w->testAttribute(Qt::WA_MacMiniSize) // no attribute set? inherit from parent
              && !w->testAttribute(Qt::WA_MacSmallSize)
              && !w->testAttribute(Qt::WA_MacNormalSize))
            w->d_func()->macUpdateSizeAttribute();
    }
    resolveFont();
}
#endif
 
void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
{
    if (testAttribute(attribute) == on)
        return;
 
    Q_D(QWidget);
    static_assert(sizeof(d->high_attributes)*8 >= (Qt::WA_AttributeCount - sizeof(uint)*8),
                      "QWidget::setAttribute(WidgetAttribute, bool): "
                      "QWidgetPrivate::high_attributes[] too small to contain all attributes in WidgetAttribute");
#ifdef Q_OS_WIN
    // ### Don't use PaintOnScreen+paintEngine() to do native painting in some future release
    if (attribute == Qt::WA_PaintOnScreen && on && windowType() != Qt::Desktop && !inherits("QGLWidget")) {
        // see ::paintEngine for details
        paintEngine();
        if (d->noPaintOnScreen)
            return;
    }
#endif
 
    // Don't set WA_NativeWindow on platforms that don't support it -- except for QGLWidget, which depends on it
    if (attribute == Qt::WA_NativeWindow && !d->mustHaveWindowHandle) {
        QPlatformIntegration *platformIntegration = QGuiApplicationPrivate::platformIntegration();
        if (!platformIntegration->hasCapability(QPlatformIntegration::NativeWidgets))
            return;
    }
 
    setAttribute_internal(attribute, on, data, d);
 
    switch (attribute) {
 
#if QT_CONFIG(draganddrop)
    case Qt::WA_AcceptDrops:  {
        if (on && !testAttribute(Qt::WA_DropSiteRegistered))
            setAttribute(Qt::WA_DropSiteRegistered, true);
        else if (!on && (isWindow() || !parentWidget() || !parentWidget()->testAttribute(Qt::WA_DropSiteRegistered)))
            setAttribute(Qt::WA_DropSiteRegistered, false);
        QEvent e(QEvent::AcceptDropsChange);
        QCoreApplication::sendEvent(this, &e);
        break;
    }
    case Qt::WA_DropSiteRegistered:  {
        for (int i = 0; i < d->children.size(); ++i) {
            QWidget *w = qobject_cast<QWidget *>(d->children.at(i));
            if (w && !w->isWindow() && !w->testAttribute(Qt::WA_AcceptDrops) && w->testAttribute(Qt::WA_DropSiteRegistered) != on)
                w->setAttribute(Qt::WA_DropSiteRegistered, on);
        }
        break;
    }
#endif
 
    case Qt::WA_NoChildEventsForParent:
        d->sendChildEvents = !on;
        break;
    case Qt::WA_NoChildEventsFromChildren:
        d->receiveChildEvents = !on;
        break;
    case Qt::WA_MacNormalSize:
    case Qt::WA_MacSmallSize:
    case Qt::WA_MacMiniSize:
#ifdef Q_OS_MAC
        {
            // We can only have one of these set at a time
            const Qt::WidgetAttribute MacSizes[] = { Qt::WA_MacNormalSize, Qt::WA_MacSmallSize,
                                                     Qt::WA_MacMiniSize };
            for (int i = 0; i < 3; ++i) {
                if (MacSizes[i] != attribute)
                    setAttribute_internal(MacSizes[i], false, data, d);
            }
            d->macUpdateSizeAttribute();
        }
#endif
        break;
    case Qt::WA_ShowModal:
        if (!on) {
            // reset modality type to NonModal when clearing WA_ShowModal
            data->window_modality = Qt::NonModal;
        } else if (data->window_modality == Qt::NonModal) {
            // If modality hasn't been set prior to setting WA_ShowModal, use
            // ApplicationModal.
            data->window_modality = Qt::ApplicationModal;
            // Some window managers do not allow us to enter modality after the
            // window is visible.The window must be hidden before changing the
            // windowModality property and then reshown.
        }
        if (testAttribute(Qt::WA_WState_Created)) {
            // don't call setModal_sys() before create()
            d->setModal_sys();
        }
        break;
    case Qt::WA_MouseTracking: {
        QEvent e(QEvent::MouseTrackingChange);
        QCoreApplication::sendEvent(this, &e);
        break; }
    case Qt::WA_TabletTracking: {
        QEvent e(QEvent::TabletTrackingChange);
        QCoreApplication::sendEvent(this, &e);
        break; }
    case Qt::WA_NativeWindow: {
        d->createTLExtra();
        if (on)
            d->createTLSysExtra();
#ifndef QT_NO_IM
        QWidget *focusWidget = d->effectiveFocusWidget();
        if (on && !internalWinId() && this == QGuiApplication::focusObject()
            && focusWidget->testAttribute(Qt::WA_InputMethodEnabled)) {
            QGuiApplication::inputMethod()->commit();
            QGuiApplication::inputMethod()->update(Qt::ImEnabled);
        }
        if (!QCoreApplication::testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget())
            parentWidget()->d_func()->enforceNativeChildren();
        if (on && !internalWinId() && testAttribute(Qt::WA_WState_Created))
            d->createWinId();
        if (isEnabled() && focusWidget->isEnabled() && this == QGuiApplication::focusObject()
            && focusWidget->testAttribute(Qt::WA_InputMethodEnabled)) {
            QGuiApplication::inputMethod()->update(Qt::ImEnabled);
        }
#endif //QT_NO_IM
        break;
    }
    case Qt::WA_PaintOnScreen:
        d->updateIsOpaque();
        Q_FALLTHROUGH();
    case Qt::WA_OpaquePaintEvent:
        d->updateIsOpaque();
        break;
    case Qt::WA_NoSystemBackground:
        d->updateIsOpaque();
        Q_FALLTHROUGH();
    case Qt::WA_UpdatesDisabled:
        d->updateSystemBackground();
        break;
    case Qt::WA_TransparentForMouseEvents:
        break;
    case Qt::WA_InputMethodEnabled: {
#ifndef QT_NO_IM
        if (QGuiApplication::focusObject() == this) {
            if (!on)
                QGuiApplication::inputMethod()->commit();
            QGuiApplication::inputMethod()->update(Qt::ImEnabled);
        }
#endif //QT_NO_IM
        break;
    }
    case Qt::WA_WindowPropagation:
        d->resolvePalette();
        d->resolveFont();
        d->resolveLocale();
        break;
    case Qt::WA_DontShowOnScreen: {
        if (on && isVisible()) {
            // Make sure we keep the current state and only hide the widget
            // from the desktop. show_sys will only update platform specific
            // attributes at this point.
            d->hide_sys();
            d->show_sys();
        }
        break;
    }
 
    case Qt::WA_X11NetWmWindowTypeDesktop:
    case Qt::WA_X11NetWmWindowTypeDock:
    case Qt::WA_X11NetWmWindowTypeToolBar:
    case Qt::WA_X11NetWmWindowTypeMenu:
    case Qt::WA_X11NetWmWindowTypeUtility:
    case Qt::WA_X11NetWmWindowTypeSplash:
    case Qt::WA_X11NetWmWindowTypeDialog:
    case Qt::WA_X11NetWmWindowTypeDropDownMenu:
    case Qt::WA_X11NetWmWindowTypePopupMenu:
    case Qt::WA_X11NetWmWindowTypeToolTip:
    case Qt::WA_X11NetWmWindowTypeNotification:
    case Qt::WA_X11NetWmWindowTypeCombo:
    case Qt::WA_X11NetWmWindowTypeDND:
        d->setNetWmWindowTypes();
        break;
 
    case Qt::WA_StaticContents:
        if (QWidgetRepaintManager *repaintManager = d->maybeRepaintManager()) {
            if (on)
                repaintManager->addStaticWidget(this);
            else
                repaintManager->removeStaticWidget(this);
        }
        break;
    case Qt::WA_TranslucentBackground:
        if (on)
            setAttribute(Qt::WA_NoSystemBackground);
        d->updateIsTranslucent();
 
        break;
    case Qt::WA_AcceptTouchEvents:
        break;
    default:
        break;
    }
}
 
bool QWidget::testAttribute_helper(Qt::WidgetAttribute attribute) const
{
    Q_D(const QWidget);
    const int x = attribute - 8*sizeof(uint);
    const int int_off = x / (8*sizeof(uint));
    return (d->high_attributes[int_off] & (1<<(x-(int_off*8*sizeof(uint)))));
}
 
qreal QWidget::windowOpacity() const
{
    Q_D(const QWidget);
    return (isWindow() && d->maybeTopData()) ? d->maybeTopData()->opacity / 255. : 1.0;
}
 
void QWidget::setWindowOpacity(qreal opacity)
{
    Q_D(QWidget);
    if (!isWindow())
        return;
 
    opacity = qBound(qreal(0.0), opacity, qreal(1.0));
    QTLWExtra *extra = d->topData();
    extra->opacity = uint(opacity * 255);
    setAttribute(Qt::WA_WState_WindowOpacitySet);
    d->setWindowOpacity_sys(opacity);
 
    if (!testAttribute(Qt::WA_WState_Created))
        return;
 
#if QT_CONFIG(graphicsview)
    if (QGraphicsProxyWidget *proxy = graphicsProxyWidget()) {
        // Avoid invalidating the cache if set.
        if (proxy->cacheMode() == QGraphicsItem::NoCache)
            proxy->update();
        else if (QGraphicsScene *scene = proxy->scene())
            scene->update(proxy->sceneBoundingRect());
        return;
    }
#endif
}
 
void QWidgetPrivate::setWindowOpacity_sys(qreal level)
{
    Q_Q(QWidget);
    if (q->windowHandle())
        q->windowHandle()->setOpacity(level);
}
 
bool QWidget::isWindowModified() const
{
    return testAttribute(Qt::WA_WindowModified);
}
 
void QWidget::setWindowModified(bool mod)
{
    Q_D(QWidget);
    setAttribute(Qt::WA_WindowModified, mod);
 
    d->setWindowModified_helper();
 
    QEvent e(QEvent::ModifiedChange);
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidgetPrivate::setWindowModified_helper()
{
    Q_Q(QWidget);
    QWindow *window = q->windowHandle();
    if (!window)
        return;
    QPlatformWindow *platformWindow = window->handle();
    if (!platformWindow)
        return;
    bool on = q->testAttribute(Qt::WA_WindowModified);
    if (!platformWindow->setWindowModified(on)) {
        if (Q_UNLIKELY(on && !q->windowTitle().contains("[*]"_L1)))
            qWarning("QWidget::setWindowModified: The window title does not contain a '[*]' placeholder");
        setWindowTitle_helper(q->windowTitle());
        setWindowIconText_helper(q->windowIconText());
    }
}
 
#if QT_CONFIG(tooltip)
void QWidget::setToolTip(const QString &s)
{
    Q_D(QWidget);
    d->toolTip = s;
 
    QEvent event(QEvent::ToolTipChange);
    QCoreApplication::sendEvent(this, &event);
}
 
QString QWidget::toolTip() const
{
    Q_D(const QWidget);
    return d->toolTip;
}
 
void QWidget::setToolTipDuration(int msec)
{
    Q_D(QWidget);
    d->toolTipDuration = msec;
}
 
int QWidget::toolTipDuration() const
{
    Q_D(const QWidget);
    return d->toolTipDuration;
}
 
#endif // QT_CONFIG(tooltip)
 
 
#if QT_CONFIG(statustip)
void QWidget::setStatusTip(const QString &s)
{
    Q_D(QWidget);
    d->statusTip = s;
}
 
QString QWidget::statusTip() const
{
    Q_D(const QWidget);
    return d->statusTip;
}
#endif // QT_CONFIG(statustip)
 
#if QT_CONFIG(whatsthis)
void QWidget::setWhatsThis(const QString &s)
{
    Q_D(QWidget);
    d->whatsThis = s;
}
 
QString QWidget::whatsThis() const
{
    Q_D(const QWidget);
    return d->whatsThis;
}
#endif // QT_CONFIG(whatsthis)
 
#if QT_CONFIG(accessibility)
void QWidget::setAccessibleName(const QString &name)
{
    Q_D(QWidget);
    d->accessibleName = name;
    QAccessibleEvent event(this, QAccessible::NameChanged);
    QAccessible::updateAccessibility(&event);
}
 
QString QWidget::accessibleName() const
{
    Q_D(const QWidget);
    return d->accessibleName;
}
 
void QWidget::setAccessibleDescription(const QString &description)
{
    Q_D(QWidget);
    d->accessibleDescription = description;
    QAccessibleEvent event(this, QAccessible::DescriptionChanged);
    QAccessible::updateAccessibility(&event);
}
 
QString QWidget::accessibleDescription() const
{
    Q_D(const QWidget);
    return d->accessibleDescription;
}
#endif // QT_CONFIG(accessibility)
 
#ifndef QT_NO_SHORTCUT
int QWidget::grabShortcut(const QKeySequence &key, Qt::ShortcutContext context)
{
    Q_ASSERT(qApp);
    if (key.isEmpty())
        return 0;
    setAttribute(Qt::WA_GrabbedShortcut);
    return QGuiApplicationPrivate::instance()->shortcutMap.addShortcut(this, key, context, qWidgetShortcutContextMatcher);
}
 
void QWidget::releaseShortcut(int id)
{
    Q_ASSERT(qApp);
    if (id)
        QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(id, this, 0);
}
 
void QWidget::setShortcutEnabled(int id, bool enable)
{
    Q_ASSERT(qApp);
    if (id)
        QGuiApplicationPrivate::instance()->shortcutMap.setShortcutEnabled(enable, id, this, 0);
}
 
void QWidget::setShortcutAutoRepeat(int id, bool enable)
{
    Q_ASSERT(qApp);
    if (id)
        QGuiApplicationPrivate::instance()->shortcutMap.setShortcutAutoRepeat(enable, id, this, 0);
}
#endif // QT_NO_SHORTCUT
 
void QWidget::updateMicroFocus(Qt::InputMethodQuery query)
{
    if (this == QGuiApplication::focusObject())
        QGuiApplication::inputMethod()->update(query);
}
 
void QWidget::raise()
{
    Q_D(QWidget);
    if (!isWindow()) {
        QWidget *p = parentWidget();
        const int parentChildCount = p->d_func()->children.size();
        if (parentChildCount < 2)
            return;
        const int from = p->d_func()->children.indexOf(this);
        Q_ASSERT(from >= 0);
        // Do nothing if the widget is already in correct stacking order _and_ created.
        if (from != parentChildCount -1)
            p->d_func()->children.move(from, parentChildCount - 1);
        if (!testAttribute(Qt::WA_WState_Created) && p->testAttribute(Qt::WA_WState_Created))
            create();
        else if (from == parentChildCount - 1)
            return;
 
        QRegion region(rect());
        d->subtractOpaqueSiblings(region);
        d->invalidateBackingStore(region);
    }
    if (testAttribute(Qt::WA_WState_Created))
        d->raise_sys();
 
    if (d->extra && d->extra->hasWindowContainer)
        QWindowContainer::parentWasRaised(this);
 
    QEvent e(QEvent::ZOrderChange);
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidgetPrivate::raise_sys()
{
    Q_Q(QWidget);
    if (q->isWindow() || q->testAttribute(Qt::WA_NativeWindow)) {
        q->windowHandle()->raise();
    } else if (renderToTexture) {
        if (QWidget *p = q->parentWidget()) {
            setDirtyOpaqueRegion();
            p->d_func()->invalidateBackingStore(effectiveRectFor(q->geometry()));
        }
    }
}
 
void QWidget::lower()
{
    Q_D(QWidget);
    if (!isWindow()) {
        QWidget *p = parentWidget();
        const int parentChildCount = p->d_func()->children.size();
        if (parentChildCount < 2)
            return;
        const int from = p->d_func()->children.indexOf(this);
        Q_ASSERT(from >= 0);
        // Do nothing if the widget is already in correct stacking order _and_ created.
        if (from != 0)
            p->d_func()->children.move(from, 0);
        if (!testAttribute(Qt::WA_WState_Created) && p->testAttribute(Qt::WA_WState_Created))
            create();
        else if (from == 0)
            return;
    }
    if (testAttribute(Qt::WA_WState_Created))
        d->lower_sys();
 
    if (d->extra && d->extra->hasWindowContainer)
        QWindowContainer::parentWasLowered(this);
 
    QEvent e(QEvent::ZOrderChange);
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidgetPrivate::lower_sys()
{
    Q_Q(QWidget);
    if (q->isWindow() || q->testAttribute(Qt::WA_NativeWindow)) {
        Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
        q->windowHandle()->lower();
    } else if (QWidget *p = q->parentWidget()) {
        setDirtyOpaqueRegion();
        p->d_func()->invalidateBackingStore(effectiveRectFor(q->geometry()));
    }
}
 
void QWidget::stackUnder(QWidget* w)
{
    Q_D(QWidget);
    QWidget *p = parentWidget();
    if (!w || isWindow() || p != w->parentWidget() || this == w)
        return;
    if (p) {
        int from = p->d_func()->children.indexOf(this);
        int to = p->d_func()->children.indexOf(w);
        Q_ASSERT(from >= 0);
        Q_ASSERT(to >= 0);
        if (from < to)
            --to;
        // Do nothing if the widget is already in correct stacking order _and_ created.
        if (from != to)
            p->d_func()->children.move(from, to);
        if (!testAttribute(Qt::WA_WState_Created) && p->testAttribute(Qt::WA_WState_Created))
            create();
        else if (from == to)
            return;
    }
    if (testAttribute(Qt::WA_WState_Created))
        d->stackUnder_sys(w);
 
    QEvent e(QEvent::ZOrderChange);
    QCoreApplication::sendEvent(this, &e);
}
 
void QWidgetPrivate::stackUnder_sys(QWidget*)
{
    Q_Q(QWidget);
    if (QWidget *p = q->parentWidget()) {
        setDirtyOpaqueRegion();
        p->d_func()->invalidateBackingStore(effectiveRectFor(q->geometry()));
    }
}
 
QRect QWidgetPrivate::frameStrut() const
{
    Q_Q(const QWidget);
    if (!q->isWindow() || (q->windowType() == Qt::Desktop) || q->testAttribute(Qt::WA_DontShowOnScreen)) {
        // x2 = x1 + w - 1, so w/h = 1
        return QRect(0, 0, 1, 1);
    }
 
    if (data.fstrut_dirty
        // ### Fix properly for 4.3
        && q->isVisible()
        && q->testAttribute(Qt::WA_WState_Created))
        const_cast<QWidgetPrivate *>(this)->updateFrameStrut();
 
    return maybeTopData() ? maybeTopData()->frameStrut : QRect();
}
 
void QWidgetPrivate::updateFrameStrut()
{
    Q_Q(QWidget);
    if (q->data->fstrut_dirty) {
        if (QTLWExtra *te = maybeTopData()) {
            if (te->window && te->window->handle()) {
                const QMargins margins = te->window->frameMargins();
                if (!margins.isNull()) {
                    te->frameStrut.setCoords(margins.left(), margins.top(), margins.right(), margins.bottom());
                    q->data->fstrut_dirty = false;
                }
            }
        }
    }
}
 
#ifdef QT_KEYPAD_NAVIGATION
bool QWidgetPrivate::navigateToDirection(Direction direction)
{
    QWidget *targetWidget = widgetInNavigationDirection(direction);
    if (targetWidget)
        targetWidget->setFocus();
    return (targetWidget != 0);
}
 
QWidget *QWidgetPrivate::widgetInNavigationDirection(Direction direction)
{
    const QWidget *sourceWidget = QApplication::focusWidget();
    if (!sourceWidget)
        return nullptr;
    const QRect sourceRect = sourceWidget->rect().translated(sourceWidget->mapToGlobal(QPoint()));
    const int sourceX =
            (direction == DirectionNorth || direction == DirectionSouth) ?
                (sourceRect.left() + (sourceRect.right() - sourceRect.left()) / 2)
                :(direction == DirectionEast ? sourceRect.right() : sourceRect.left());
    const int sourceY =
            (direction == DirectionEast || direction == DirectionWest) ?
                (sourceRect.top() + (sourceRect.bottom() - sourceRect.top()) / 2)
                :(direction == DirectionSouth ? sourceRect.bottom() : sourceRect.top());
    const QPoint sourcePoint(sourceX, sourceY);
    const QPoint sourceCenter = sourceRect.center();
    const QWidget *sourceWindow = sourceWidget->window();
 
    QWidget *targetWidget = nullptr;
    int shortestDistance = INT_MAX;
 
    const auto targetCandidates = QApplication::allWidgets();
    for (QWidget *targetCandidate : targetCandidates) {
 
        const QRect targetCandidateRect = targetCandidate->rect().translated(targetCandidate->mapToGlobal(QPoint()));
 
        // For focus proxies, the child widget handling the focus can have keypad navigation focus,
        // but the owner of the proxy cannot.
        // Additionally, empty widgets should be ignored.
        if (targetCandidate->focusProxy() || targetCandidateRect.isEmpty())
            continue;
 
        // Only navigate to a target widget that...
        if (       targetCandidate != sourceWidget
                   // ...takes the focus,
                && targetCandidate->focusPolicy() & Qt::TabFocus
                   // ...is above if DirectionNorth,
                && !(direction == DirectionNorth && targetCandidateRect.bottom() > sourceRect.top())
                   // ...is on the right if DirectionEast,
                && !(direction == DirectionEast  && targetCandidateRect.left()   < sourceRect.right())
                   // ...is below if DirectionSouth,
                && !(direction == DirectionSouth && targetCandidateRect.top()    < sourceRect.bottom())
                   // ...is on the left if DirectionWest,
                && !(direction == DirectionWest  && targetCandidateRect.right()  > sourceRect.left())
                   // ...is enabled,
                && targetCandidate->isEnabled()
                   // ...is visible,
                && targetCandidate->isVisible()
                   // ...is in the same window,
                && targetCandidate->window() == sourceWindow) {
            const int targetCandidateDistance = [](const QPoint &sourcePoint,
                                                   const QRect &targetCandidateRect) {
                int dx = 0;
                int dy = 0;
                if (p.x() < r.left())
                    dx = r.left() - p.x();
                else if (p.x() > r.right())
                    dx = p.x() - r.right();
                if (p.y() < r.top())
                    dy = r.top() - p.y();
                else if (p.y() > r.bottom())
                    dy = p.y() - r.bottom();
                return dx + dy;
            }();
            if (targetCandidateDistance < shortestDistance) {
                shortestDistance = targetCandidateDistance;
                targetWidget = targetCandidate;
            }
        }
    }
    return targetWidget;
}
 
bool QWidgetPrivate::canKeypadNavigate(Qt::Orientation orientation)
{
    return orientation == Qt::Horizontal?
            (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast)
                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest))
            :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth)
                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth));
}
bool QWidgetPrivate::inTabWidget(QWidget *widget)
{
    for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget())
        if (qobject_cast<const QTabWidget*>(tabWidget))
            return true;
    return false;
}
#endif
 
void QWidget::setBackingStore(QBackingStore *store)
{
    // ### createWinId() ??
 
    if (!isWindow())
        return;
 
    Q_D(QWidget);
 
    QTLWExtra *topData = d->topData();
    if (topData->backingStore == store)
        return;
 
    QBackingStore *oldStore = topData->backingStore;
    delete topData->backingStore;
    topData->backingStore = store;
 
    QWidgetRepaintManager *repaintManager = d->maybeRepaintManager();
    if (!repaintManager)
        return;
 
    if (isWindow()) {
        if (repaintManager->backingStore() != oldStore && repaintManager->backingStore() != store)
            delete repaintManager->backingStore();
        repaintManager->setBackingStore(store);
    }
}
 
QBackingStore *QWidget::backingStore() const
{
    Q_D(const QWidget);
    QTLWExtra *extra = d->maybeTopData();
    if (extra && extra->backingStore)
        return extra->backingStore;
 
    if (!isWindow())
        return window()->backingStore();
 
    return nullptr;
}
 
void QWidgetPrivate::getLayoutItemMargins(int *left, int *top, int *right, int *bottom) const
{
    if (left)
        *left = (int)leftLayoutItemMargin;
    if (top)
        *top = (int)topLayoutItemMargin;
    if (right)
        *right = (int)rightLayoutItemMargin;
    if (bottom)
        *bottom = (int)bottomLayoutItemMargin;
}
 
void QWidgetPrivate::setLayoutItemMargins(int left, int top, int right, int bottom)
{
    if (leftLayoutItemMargin == left
        && topLayoutItemMargin == top
        && rightLayoutItemMargin == right
        && bottomLayoutItemMargin == bottom)
        return;
 
    Q_Q(QWidget);
    leftLayoutItemMargin = (signed char)left;
    topLayoutItemMargin = (signed char)top;
    rightLayoutItemMargin = (signed char)right;
    bottomLayoutItemMargin = (signed char)bottom;
    q->updateGeometry();
}
 
void QWidgetPrivate::setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt)
{
    Q_Q(QWidget);
    QStyleOption myOpt;
    if (!opt) {
        myOpt.initFrom(q);
        myOpt.rect.setRect(0, 0, 32768, 32768);     // arbitrary
        opt = &myOpt;
    }
 
    QRect liRect = q->style()->subElementRect(element, opt, q);
    if (liRect.isValid()) {
        leftLayoutItemMargin = (signed char)(opt->rect.left() - liRect.left());
        topLayoutItemMargin = (signed char)(opt->rect.top() - liRect.top());
        rightLayoutItemMargin = (signed char)(liRect.right() - opt->rect.right());
        bottomLayoutItemMargin = (signed char)(liRect.bottom() - opt->rect.bottom());
    } else {
        leftLayoutItemMargin = 0;
        topLayoutItemMargin = 0;
        rightLayoutItemMargin = 0;
        bottomLayoutItemMargin = 0;
    }
}
// resets the Qt::WA_QuitOnClose attribute to the default value for transient widgets.
void QWidgetPrivate::adjustQuitOnCloseAttribute()
{
    Q_Q(QWidget);
 
    if (!q->parentWidget()) {
        Qt::WindowType type = q->windowType();
        if (type == Qt::Widget || type == Qt::SubWindow)
            type = Qt::Window;
        if (type != Qt::Widget && type != Qt::Window && type != Qt::Dialog)
            q->setAttribute(Qt::WA_QuitOnClose, false);
    }
}
 
void QWidgetPrivate::sendComposeStatus(QWidget *w, bool end)
{
    QWidgetPrivate *wd = QWidgetPrivate::get(w);
    if (!wd->textureChildSeen)
        return;
    if (end)
        wd->endCompose();
    else
        wd->beginCompose();
    for (int i = 0; i < wd->children.size(); ++i) {
        w = qobject_cast<QWidget *>(wd->children.at(i));
        if (w && !w->isWindow() && !w->isHidden() && QWidgetPrivate::get(w)->textureChildSeen)
            sendComposeStatus(w, end);
    }
}
 
Q_WIDGETS_EXPORT QWidgetData *qt_qwidget_data(QWidget *widget)
{
    return widget->data;
}
 
Q_WIDGETS_EXPORT QWidgetPrivate *qt_widget_private(QWidget *widget)
{
    return widget->d_func();
}
 
 
#if QT_CONFIG(graphicsview)
QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const
{
    Q_D(const QWidget);
    if (d->extra) {
        return d->extra->proxyWidget;
    }
    return nullptr;
}
#endif
 
#ifndef QT_NO_GESTURES
void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags)
{
    Q_D(QWidget);
    d->gestureContext.insert(gesture, flags);
    (void)QGestureManager::instance(); // create a gesture manager
}
 
void QWidget::ungrabGesture(Qt::GestureType gesture)
{
    // if you modify this function, check the inlined version in ~QWidget, too
    Q_D(QWidget);
    if (d->gestureContext.remove(gesture)) {
        if (QGestureManager *manager = QGestureManager::instance())
            manager->cleanupCachedGestures(this, gesture);
    }
}
#endif // QT_NO_GESTURES
 
void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
{
    Q_D(QWidget);
 
    d->aboutToDestroy();
    if (!isWindow() && parentWidget())
        parentWidget()->d_func()->invalidateBackingStore(d->effectiveRectFor(geometry()));
    d->deactivateWidgetCleanup();
 
    if ((windowType() == Qt::Popup) && qApp)
        qApp->d_func()->closePopup(this);
 
    if (this == qApp->activeWindow())
        QApplicationPrivate::setActiveWindow(nullptr);
    if (QWidget::mouseGrabber() == this)
        releaseMouse();
    if (QWidget::keyboardGrabber() == this)
        releaseKeyboard();
 
    setAttribute(Qt::WA_WState_Created, false);
 
    if (windowType() != Qt::Desktop) {
        if (destroySubWindows) {
            QObjectList childList(children());
            for (int i = 0; i < childList.size(); i++) {
                QWidget *widget = qobject_cast<QWidget *>(childList.at(i));
                if (widget && widget->testAttribute(Qt::WA_NativeWindow)) {
                    if (widget->windowHandle()) {
                        widget->destroy();
                    }
                }
            }
        }
        if (destroyWindow) {
            d->deleteTLSysExtra();
        } else {
            if (parentWidget() && parentWidget()->testAttribute(Qt::WA_WState_Created)) {
                d->hide_sys();
            }
        }
 
        d->setWinId(0);
    }
}
 
QPaintEngine *QWidget::paintEngine() const
{
    qWarning("QWidget::paintEngine: Should no longer be called");
 
#ifdef Q_OS_WIN
    // We set this bit which is checked in setAttribute for
    // Qt::WA_PaintOnScreen. We do this to allow these two scenarios:
    //
    // 1. Users accidentally set Qt::WA_PaintOnScreen on X and port to
    // Windows which would mean suddenly their widgets stop working.
    //
    // 2. Users set paint on screen and subclass paintEngine() to
    // return 0, in which case we have a "hole" in the backingstore
    // allowing use of GDI or DirectX directly.
    //
    // 1 is WRONG, but to minimize silent failures, we have set this
    // bit to ignore the setAttribute call. 2. needs to be
    // supported because its our only means of embedding native
    // graphics stuff.
    const_cast<QWidgetPrivate *>(d_func())->noPaintOnScreen = 1;
#endif
 
    return nullptr; //##### @@@
}
 
// Do not call QWindow::mapToGlobal() until QPlatformWindow is properly showing.
static inline bool canMapPosition(QWindow *window)
{
    return window->handle() && !qt_window_private(window)->resizeEventPending;
}
 
#if QT_CONFIG(graphicsview)
static inline QGraphicsProxyWidget *graphicsProxyWidget(const QWidget *w)
{
    QGraphicsProxyWidget *result = nullptr;
    const QWidgetPrivate *d = qt_widget_private(const_cast<QWidget *>(w));
    if (d->extra)
        result = d->extra->proxyWidget;
    return result;
}
#endif // QT_CONFIG(graphicsview)
 
struct MapToGlobalTransformResult {
    QTransform transform;
    QWindow *window;
};
 
static MapToGlobalTransformResult mapToGlobalTransform(const QWidget *w)
{
    MapToGlobalTransformResult result;
    result.window = nullptr;
    for ( ; w ; w = w->parentWidget()) {
#if QT_CONFIG(graphicsview)
        if (QGraphicsProxyWidget *qgpw = graphicsProxyWidget(w)) {
            if (const QGraphicsScene *scene = qgpw->scene()) {
                const QList <QGraphicsView *> views = scene->views();
                if (!views.isEmpty()) {
                    result.transform *= qgpw->sceneTransform();
                    result.transform *= views.first()->viewportTransform();
                    w = views.first()->viewport();
                }
            }
        }
#endif // QT_CONFIG(graphicsview)
        QWindow *window = w->windowHandle();
        if (window && canMapPosition(window)) {
            result.window = window;
            break;
        }
 
        const QPoint topLeft = w->geometry().topLeft();
        result.transform.translate(topLeft.x(), topLeft.y());
        if (w->isWindow())
            break;
    }
    return result;
}
 
QPointF QWidget::mapToGlobal(const QPointF &pos) const
{
    const MapToGlobalTransformResult t = mapToGlobalTransform(this);
    const QPointF g = t.transform.map(pos);
    return t.window ? t.window->mapToGlobal(g) : g;
}
 
QPoint QWidget::mapToGlobal(const QPoint &pos) const
{
    return mapToGlobal(QPointF(pos)).toPoint();
}
 
QPointF QWidget::mapFromGlobal(const QPointF &pos) const
{
   const MapToGlobalTransformResult t = mapToGlobalTransform(this);
   const QPointF windowLocal = t.window ? t.window->mapFromGlobal(pos) : pos;
   return t.transform.inverted().map(windowLocal);
}
 
QPoint QWidget::mapFromGlobal(const QPoint &pos) const
{
   return mapFromGlobal(QPointF(pos)).toPoint();
}
 
QWidget *qt_pressGrab = nullptr;
QWidget *qt_mouseGrb = nullptr;
static bool mouseGrabWithCursor = false;
static QWidget *keyboardGrb = nullptr;
 
static inline QWindow *grabberWindow(const QWidget *w)
{
    QWindow *window = w->windowHandle();
    if (!window)
        if (const QWidget *nativeParent = w->nativeParentWidget())
            window = nativeParent->windowHandle();
    return window;
}
 
#ifndef QT_NO_CURSOR
static void grabMouseForWidget(QWidget *widget, const QCursor *cursor = nullptr)
#else
static void grabMouseForWidget(QWidget *widget)
#endif
{
    if (qt_mouseGrb)
        qt_mouseGrb->releaseMouse();
 
    mouseGrabWithCursor = false;
    if (QWindow *window = grabberWindow(widget)) {
#ifndef QT_NO_CURSOR
        if (cursor) {
            mouseGrabWithCursor = true;
            QGuiApplication::setOverrideCursor(*cursor);
        }
#endif // !QT_NO_CURSOR
        window->setMouseGrabEnabled(true);
    }
 
    qt_mouseGrb = widget;
    qt_pressGrab = nullptr;
}
 
static void releaseMouseGrabOfWidget(QWidget *widget)
{
    if (qt_mouseGrb == widget) {
        if (QWindow *window = grabberWindow(widget)) {
#ifndef QT_NO_CURSOR
            if (mouseGrabWithCursor) {
                QGuiApplication::restoreOverrideCursor();
                mouseGrabWithCursor = false;
            }
#endif // !QT_NO_CURSOR
            window->setMouseGrabEnabled(false);
        }
    }
    qt_mouseGrb = nullptr;
}
 
void QWidget::grabMouse()
{
    grabMouseForWidget(this);
}
 
#ifndef QT_NO_CURSOR
void QWidget::grabMouse(const QCursor &cursor)
{
    grabMouseForWidget(this, &cursor);
}
#endif
 
bool QWidgetPrivate::stealMouseGrab(bool grab)
{
    // This is like a combination of grab/releaseMouse() but with error checking
    // and it has no effect on the result of mouseGrabber().
    Q_Q(QWidget);
    QWindow *window = grabberWindow(q);
    return window ? window->setMouseGrabEnabled(grab) : false;
}
 
void QWidget::releaseMouse()
{
    releaseMouseGrabOfWidget(this);
}
 
void QWidget::grabKeyboard()
{
    if (keyboardGrb)
        keyboardGrb->releaseKeyboard();
    if (QWindow *window = grabberWindow(this))
        window->setKeyboardGrabEnabled(true);
    keyboardGrb = this;
}
 
bool QWidgetPrivate::stealKeyboardGrab(bool grab)
{
    // This is like a combination of grab/releaseKeyboard() but with error
    // checking and it has no effect on the result of keyboardGrabber().
    Q_Q(QWidget);
    QWindow *window = grabberWindow(q);
    return window ? window->setKeyboardGrabEnabled(grab) : false;
}
 
void QWidget::releaseKeyboard()
{
    if (keyboardGrb == this) {
        if (QWindow *window = grabberWindow(this))
            window->setKeyboardGrabEnabled(false);
        keyboardGrb = nullptr;
    }
}
 
QWidget *QWidget::mouseGrabber()
{
    if (qt_mouseGrb)
        return qt_mouseGrb;
    return qt_pressGrab;
}
 
QWidget *QWidget::keyboardGrabber()
{
    return keyboardGrb;
}
 
void QWidget::activateWindow()
{
    QWindow *const wnd = window()->windowHandle();
 
    if (wnd)
        wnd->requestActivate();
}
 
int QWidget::metric(PaintDeviceMetric m) const
{
    QScreen *screen = this->screen();
 
    if (!screen) {
        if (m == PdmDpiX || m == PdmDpiY)
              return 72;
        return QPaintDevice::metric(m);
    }
 
    auto resolveDevicePixelRatio = [this, screen]() -> qreal {
 
        // Note: keep in sync with QBackingStorePrivate::backingStoreDevicePixelRatio()!
        static bool downscale = qEnvironmentVariableIntValue("QT_WIDGETS_HIGHDPI_DOWNSCALE") > 0;
        QWindow *window = this->window()->windowHandle();
        if (window)
            return downscale ? std::ceil(window->devicePixelRatio()) : window->devicePixelRatio();
        return screen->devicePixelRatio();
    };
 
    switch (m) {
    case PdmWidth:
        return data->crect.width();
    case PdmWidthMM:
        return data->crect.width() * screen->physicalSize().width() / screen->geometry().width();
    case PdmHeight:
        return data->crect.height();
    case PdmHeightMM:
        return data->crect.height() * screen->physicalSize().height() / screen->geometry().height();
    case PdmDepth:
        return screen->depth();
    case PdmDpiX:
        for (const QWidget *p = this; p; p = p->parentWidget()) {
            if (p->d_func()->extra && p->d_func()->extra->customDpiX)
                return p->d_func()->extra->customDpiX;
        }
        return qRound(screen->logicalDotsPerInchX());
    case PdmDpiY:
        for (const QWidget *p = this; p; p = p->parentWidget()) {
            if (p->d_func()->extra && p->d_func()->extra->customDpiY)
                return p->d_func()->extra->customDpiY;
        }
        return qRound(screen->logicalDotsPerInchY());
    case PdmPhysicalDpiX:
        return qRound(screen->physicalDotsPerInchX());
    case PdmPhysicalDpiY:
        return qRound(screen->physicalDotsPerInchY());
    case PdmDevicePixelRatio:
        return resolveDevicePixelRatio();
    case PdmDevicePixelRatioScaled:
        return QPaintDevice::devicePixelRatioFScale() * resolveDevicePixelRatio();
    case PdmDevicePixelRatioF_EncodedA:
        Q_FALLTHROUGH();
    case PdmDevicePixelRatioF_EncodedB:
        return QPaintDevice::encodeMetricF(m, resolveDevicePixelRatio());
    default:
        break;
    }
    return QPaintDevice::metric(m);
}
 
void QWidget::initPainter(QPainter *painter) const
{
    const QPalette &pal = palette();
    painter->d_func()->state->pen = QPen(pal.brush(foregroundRole()), 1);
    painter->d_func()->state->bgBrush = pal.brush(backgroundRole());
    QFont f(font(), const_cast<QWidget *>(this));
    painter->d_func()->state->deviceFont = f;
    painter->d_func()->state->font = f;
}
 
QPaintDevice *QWidget::redirected(QPoint *offset) const
{
    return d_func()->redirected(offset);
}
 
QPainter *QWidget::sharedPainter() const
{
    // Someone sent a paint event directly to the widget
    if (!d_func()->redirectDev)
        return nullptr;
 
    QPainter *sp = d_func()->sharedPainter();
    if (!sp || !sp->isActive())
        return nullptr;
 
    if (sp->paintEngine()->paintDevice() != d_func()->redirectDev)
        return nullptr;
 
    return sp;
}
 
void QWidget::setMask(const QRegion &newMask)
{
    Q_D(QWidget);
 
    d->createExtra();
    if (newMask == d->extra->mask)
        return;
 
#ifndef QT_NO_BACKINGSTORE
    const QRegion oldMask(d->extra->mask);
#endif
 
    d->extra->mask = newMask;
    d->extra->hasMask = !newMask.isEmpty();
 
    if (!testAttribute(Qt::WA_WState_Created))
        return;
 
    d->setMask_sys(newMask);
 
#ifndef QT_NO_BACKINGSTORE
    if (!isVisible())
        return;
 
    if (!d->extra->hasMask) {
        // Mask was cleared; update newly exposed area.
        QRegion expose(rect());
        expose -= oldMask;
        if (!expose.isEmpty()) {
            d->setDirtyOpaqueRegion();
            update(expose);
        }
        return;
    }
 
    if (!isWindow()) {
        // Update newly exposed area on the parent widget.
        QRegion parentExpose(rect());
        parentExpose -= newMask;
        if (!parentExpose.isEmpty()) {
            d->setDirtyOpaqueRegion();
            parentExpose.translate(data->crect.topLeft());
            parentWidget()->update(parentExpose);
        }
 
        // Update newly exposed area on this widget
        if (!oldMask.isEmpty())
            update(newMask - oldMask);
    }
#endif
}
 
void QWidgetPrivate::setMask_sys(const QRegion &region)
{
    Q_Q(QWidget);
    if (QWindow *window = q->windowHandle())
        window->setMask(region);
}
 
void QWidget::setMask(const QBitmap &bitmap)
{
    setMask(QRegion(bitmap));
}
 
void QWidget::clearMask()
{
    Q_D(QWidget);
    if (!d->extra || !d->extra->hasMask)
        return;
    setMask(QRegion());
}
 
void QWidgetPrivate::setWidgetParentHelper(QObject *widgetAsObject, QObject *newParent)
{
    Q_ASSERT(widgetAsObject->isWidgetType());
    Q_ASSERT(!newParent || newParent->isWidgetType());
    QWidget *widget = static_cast<QWidget*>(widgetAsObject);
    widget->setParent(static_cast<QWidget*>(newParent));
}
 
std::string QWidgetPrivate::flagsForDumping() const
{
    Q_Q(const QWidget);
    std::string flags = QObjectPrivate::flagsForDumping();
    if (QApplication::focusWidget() == q)
        flags += 'F';
    if (q->isVisible()) {
        std::stringstream s;
        s << '<'
          << q->width() << 'x' << q->height()
          << std::showpos << q->x() << q->y()
          << '>';
        flags += s.str();
    } else {
        flags += 'I';
    }
    return flags;
}
 
void QWidgetPrivate::setNetWmWindowTypes(bool skipIfMissing)
{
#if QT_CONFIG(xcb)
    Q_Q(QWidget);
 
    if (!q->windowHandle())
        return;
 
    QXcbWindow::WindowTypes wmWindowType = QXcbWindow::None;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeDesktop))
        wmWindowType |= QXcbWindow::Desktop;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeDock))
        wmWindowType |= QXcbWindow::Dock;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeToolBar))
        wmWindowType |= QXcbWindow::Toolbar;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeMenu))
        wmWindowType |= QXcbWindow::Menu;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeUtility))
        wmWindowType |= QXcbWindow::Utility;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeSplash))
        wmWindowType |= QXcbWindow::Splash;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeDialog))
        wmWindowType |= QXcbWindow::Dialog;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu))
        wmWindowType |= QXcbWindow::DropDownMenu;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypePopupMenu))
        wmWindowType |= QXcbWindow::PopupMenu;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeToolTip))
        wmWindowType |= QXcbWindow::Tooltip;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeNotification))
        wmWindowType |= QXcbWindow::Notification;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeCombo))
        wmWindowType |= QXcbWindow::Combo;
    if (q->testAttribute(Qt::WA_X11NetWmWindowTypeDND))
        wmWindowType |= QXcbWindow::Dnd;
 
    if (wmWindowType == QXcbWindow::None && skipIfMissing)
        return;
 
    if (auto *xcbWindow = dynamic_cast<QXcbWindow*>(q->windowHandle()->handle()))
        xcbWindow->setWindowType(wmWindowType);
#else
    Q_UNUSED(skipIfMissing);
#endif
}
 
bool QWidgetPrivate::hasChildWithFocusPolicy(Qt::FocusPolicy policy, const QWidget *excludeChildrenOf) const
{
    Q_Q(const QWidget);
    const QWidgetList &children = q->findChildren<QWidget *>(Qt::FindChildrenRecursively);
    for (const auto *child : children) {
        if (child->focusPolicy() == policy && child->isEnabled()
            && (!excludeChildrenOf || !excludeChildrenOf->isAncestorOf(child))) {
            return true;
        }
    }
    return false;
}
 
#ifndef QT_NO_DEBUG_STREAM
 
namespace {
QDebug operator<<(QDebug debug, const WidgetAttributes &attributes)
{
    const QDebugStateSaver saver(debug);
    debug.nospace();
    debug << '[';
    if (const QWidget *widget = attributes.widget) {
        const QMetaObject *qtMo = qt_getEnumMetaObject(Qt::WA_AttributeCount);
        const QMetaEnum me = qtMo->enumerator(qtMo->indexOfEnumerator("WidgetAttribute"));
        int count = 0;
        for (int a = 0; a < Qt::WA_AttributeCount; ++a) {
            if (widget->testAttribute(static_cast<Qt::WidgetAttribute>(a))) {
                if (count++)
                    debug << ',';
                debug << me.valueToKey(a);
            }
        }
    }
    debug << ']';
    return debug;
}
}
 
QDebug operator<<(QDebug debug, const QWidget *widget)
{
    const QDebugStateSaver saver(debug);
    debug.nospace();
    if (widget) {
        debug << widget->metaObject()->className() << '(' << (const void *)widget;
        if (!widget->objectName().isEmpty())
            debug << ", name=" << widget->objectName();
        if (debug.verbosity() > 2) {
            const QRect geometry = widget->geometry();
            const QRect frameGeometry = widget->frameGeometry();
            if (widget->isVisible())
                debug << ", visible";
            if (!widget->isEnabled())
                debug << ", disabled";
            debug << ", states=" << widget->windowState()
                << ", type=" << widget->windowType() << ", flags=" <<  widget->windowFlags();
            debug << ", attributes=" << WidgetAttributes{widget};
            if (widget->isWindow())
                debug << ", window";
            debug << ", " << geometry.width() << 'x' << geometry.height()
                << Qt::forcesign << geometry.x() << geometry.y() << Qt::noforcesign;
            if (frameGeometry != geometry) {
                const QMargins margins(geometry.x() - frameGeometry.x(),
                                       geometry.y() - frameGeometry.y(),
                                       frameGeometry.right() - geometry.right(),
                                       frameGeometry.bottom() - geometry.bottom());
                debug << ", margins=" << margins;
            }
            debug << ", devicePixelRatio=" << widget->devicePixelRatio();
            if (const WId wid = widget->internalWinId())
                debug << ", winId=0x" << Qt::hex << wid << Qt::dec;
        }
        debug << ')';
    } else {
        debug << "QWidget(0x0)";
    }
    return debug;
}
#endif // !QT_NO_DEBUG_STREAM
 
 
// *************************** Focus abstraction ************************************
 
#define FOCUS_NEXT(w) w->d_func()->focus_next
#define FOCUS_PREV(w) w->d_func()->focus_prev
 
QWidget *QWidgetPrivate::nextPrevElementInFocusChain(FocusDirection direction) const
{
    Q_Q(const QWidget);
    return direction == FocusDirection::Next ? FOCUS_NEXT(q) : FOCUS_PREV(q);
}
 
bool QWidgetPrivate::removeFromFocusChain(FocusChainRemovalRules rules, FocusDirection direction)
{
    Q_Q(QWidget);
    if (!isFocusChainConsistent()) {
#ifdef QT_DEBUG
        if (rules.testFlag(FocusChainRemovalRule::AssertConsistency))
            qFatal() << q << "has inconsistent focus chain.";
#endif
        qCDebug(lcWidgetFocus) << q << "wasn't removed, because of inconsistent focus chain.";
        return false;
    }
 
    if (!isInFocusChain()) {
        qCDebug(lcWidgetFocus) << q << "wasn't removed, because it is not part of a focus chain.";
        return false;
    }
 
    if (rules.testFlag(FocusChainRemovalRule::EnsureFocusOut))
        q->focusNextPrevChild(direction == FocusDirection::Next);
 
    FOCUS_NEXT(FOCUS_PREV(q)) = FOCUS_NEXT(q);
    FOCUS_PREV(FOCUS_NEXT(q)) = FOCUS_PREV(q);
    initFocusChain();
    qCDebug(lcWidgetFocus) << q << "removed from focus chain.";
    return true;
}
 
void QWidgetPrivate::initFocusChain()
{
    Q_Q(QWidget);
    qCDebug(lcWidgetFocus) << "Initializing focus chain of" << q;
    FOCUS_PREV(q) = q;
    FOCUS_NEXT(q) = q;
}
 
void QWidgetPrivate::reparentFocusChildren(FocusDirection direction)
{
    Q_Q(QWidget);
 
    // separate the focus chain into new (children of myself) and old (the rest)
    QWidget *firstOld = nullptr;
    QWidget *lastOld = nullptr; // last in the old list
    QWidget *lastNew = q; // last in the new list
    bool prevWasNew = true;
    QWidget *widget = nextPrevElementInFocusChain(direction);
 
    // For efficiency, do not maintain the list invariant inside the loop.
    // Append items to the relevant list, and we optimize by not changing pointers,
    // when subsequent items are going into the same list.
    while (widget != q) {
        bool currentIsNew = q->isAncestorOf(widget);
        if (currentIsNew) {
            if (!prevWasNew) {
                // previous was old => append to new list
                FOCUS_NEXT(lastNew) = widget;
                FOCUS_PREV(widget) = lastNew;
            }
            lastNew = widget;
        } else {
            if (prevWasNew) {
                // prev was new => append to old list, if it exists
                if (lastOld) {
                    FOCUS_NEXT(lastOld) = widget;
                    FOCUS_PREV(widget) = lastOld;
                } else {
                    // start the old list
                    firstOld = widget;
                }
            }
            lastOld = widget;
        }
        widget = widget->d_func()->nextPrevElementInFocusChain(direction);
        prevWasNew = currentIsNew;
    }
 
    // repair old list:
    if (firstOld) {
        FOCUS_NEXT(lastOld) = firstOld;
        FOCUS_PREV(firstOld) = lastOld;
    }
 
    if (!q->isWindow()) {
        QWidget *topLevel = q->window();
        // insert new chain into toplevel's chain
        QWidget *prev = FOCUS_PREV(topLevel);
        FOCUS_PREV(topLevel) = lastNew;
        FOCUS_NEXT(prev) = q;
        FOCUS_PREV(q) = prev;
        FOCUS_NEXT(lastNew) = topLevel;
    } else {
        // repair new list
        FOCUS_NEXT(lastNew) = q;
        FOCUS_PREV(q) = lastNew;
    }
}
 
bool QWidgetPrivate::insertIntoFocusChain(FocusDirection direction, QWidget *position)
{
    Q_Q(QWidget);
    Q_ASSERT(position);
    QWidget *next = FOCUS_NEXT(q);
    QWidget *previous = FOCUS_PREV(q);
 
    switch (direction) {
    case FocusDirection::Next:
        if (previous == position) {
            qCDebug(lcWidgetFocus) << "No-op insertion." << q << "is already before" << position;
            return false;
        }
 
        removeFromFocusChain(FocusChainRemovalRule::AssertConsistency);
 
        FOCUS_NEXT(q) = FOCUS_NEXT(position);
        FOCUS_PREV(FOCUS_NEXT(position)) = q;
        FOCUS_NEXT(position) = q;
        FOCUS_PREV(q) = position;
        qCDebug(lcWidgetFocus) << q << "inserted after" << position;
        break;
 
    case FocusDirection::Previous:
        if (next == position) {
            qCDebug(lcWidgetFocus) << "No-op insertion." << q << "is already after" << position;
            return false;
        }
 
        removeFromFocusChain(FocusChainRemovalRule::AssertConsistency);
 
        FOCUS_PREV(q) = FOCUS_PREV(position);
        FOCUS_NEXT(FOCUS_PREV(position)) = q;
        FOCUS_PREV(position) = q;
        FOCUS_NEXT(q) = position;
        qCDebug(lcWidgetFocus) << q << "inserted before" << position;
        break;
    }
 
    Q_ASSERT(isFocusChainConsistent());
    return true;
}
 
bool QWidgetPrivate::insertIntoFocusChain(const QWidgetList &toBeInserted,
                                        FocusDirection direction, QWidget *position)
{
    if (toBeInserted.isEmpty()) {
        qCDebug(lcWidgetFocus) << "No-op insertion of an empty list";
        return false;
    }
 
    Q_ASSERT_X(!toBeInserted.contains(position),
               Q_FUNC_INFO,
               "Coding error: toBeInserted contains position");
 
    QWidget *first = toBeInserted.constFirst();
    QWidget *last = toBeInserted.constLast();
 
    // Call QWidget override to log accordingly
    if (toBeInserted.count() == 1)
        return first->d_func()->insertIntoFocusChain(direction, position);
 
    Q_ASSERT(first != last);
    switch (direction) {
    case FocusDirection::Previous:
        if (FOCUS_PREV(position) == last) {
            qCDebug(lcWidgetFocus) << "No-op insertion." << toBeInserted << "is already before"
                             << position;
            return false;
        }
        FOCUS_NEXT(FOCUS_PREV(position)) = first;
        FOCUS_PREV(first) = FOCUS_PREV(position);
        FOCUS_NEXT(last) = position;
        FOCUS_PREV(position) = last;
        qCDebug(lcWidgetFocus) << toBeInserted << "inserted before" << position;
        break;
    case FocusDirection::Next:
        if (FOCUS_PREV(position) == last) {
            qCDebug(lcWidgetFocus) << "No-op insertion." << toBeInserted << "is already after"
                             << position;
            return false;
        }
        FOCUS_PREV(FOCUS_NEXT(position)) = last;
        FOCUS_NEXT(last) = FOCUS_NEXT(position);
        FOCUS_PREV(first) = position;
        FOCUS_NEXT(position) = first;
        qCDebug(lcWidgetFocus) << toBeInserted << "inserted after" << position;
        break;
    }
 
    Q_ASSERT(position->d_func()->isFocusChainConsistent());
    return true;
}
 
QWidgetList focusPath(QWidget *from, QWidget *to, QWidgetPrivate::FocusDirection direction)
{
    QWidgetList path({from});
    if (from == to)
        return path;
 
    QWidget *current = from;
    do {
        switch (direction) {
        case QWidgetPrivate::FocusDirection::Previous:
            current = current->previousInFocusChain();
            break;
        case QWidgetPrivate::FocusDirection::Next:
            current = current->nextInFocusChain();
            break;
        }
        if (path.contains(current))
            return QWidgetList();
        path << current;
    } while (current != to);
 
    return path;
}
 
QWidgetList QWidgetPrivate::takeFromFocusChain(QWidget *from,
                                               QWidget *to,
                                               FocusDirection direction)
{
    // Check if there is a path from->to in direction
    const QWidgetList path = focusPath(from, to , direction);
    if (path.isEmpty()) {
        qCDebug(lcWidgetFocus) << "No-op removal. Focus chain from" << from << "doesn't lead to " << to;
        return QWidgetList();
    }
 
    QWidget *first = path.constFirst();
    QWidget *last = path.constLast();
    if (first == last) {
        first->d_func()->removeFromFocusChain();
        return QWidgetList({first});
    }
 
    FOCUS_NEXT(FOCUS_PREV(first)) = FOCUS_NEXT(last);
    FOCUS_PREV(FOCUS_NEXT(last)) = FOCUS_PREV(first);
    FOCUS_PREV(first) = last;
    FOCUS_NEXT(last) = first;
    qCDebug(lcWidgetFocus) << path << "removed from focus chain";
    return path;
}
 
QWidget *QWidgetPrivate::determineLastFocusChild(QWidget *noFurtherThan)
{
    Q_Q(QWidget);
    // Since we need to repeat the same logic for both 'first' and 'second', we add a function
    // that determines the last focus child for a widget, taking proxies and compound widgets into
    // account. If the target is not a compound widget (it doesn't have a focus proxy that points
    // to a child), 'lastFocusChild' will be set to the target itself.
    QWidget *lastFocusChild = q;
 
    QWidget *focusProxy = deepestFocusProxy();
    if (!focusProxy) {
        // QTBUG-81097: Another case is possible here. We can have a child
        // widget, that sets its focusProxy() to the parent (target).
        // An example of such widget is a QLineEdit, nested into
        // a QAbstractSpinBox. In this case such widget should be considered
        // the last focus child.
        for (auto *object : std::as_const(q->children())) {
            QWidget *w = qobject_cast<QWidget *>(object);
            if (w && w->focusProxy() == q) {
                lastFocusChild = w;
                break;
            }
        }
    } else if (q->isAncestorOf(focusProxy)) {
        lastFocusChild = focusProxy;
        for (QWidget *focusNext = lastFocusChild->nextInFocusChain();
             focusNext != focusProxy && q->isAncestorOf(focusNext)
                          && focusNext->window() == focusProxy->window();
             focusNext = focusNext->nextInFocusChain()) {
            if (focusNext == noFurtherThan)
                break;
            if (focusNext->focusPolicy() != Qt::NoFocus)
                lastFocusChild = focusNext;
        }
    }
    return lastFocusChild;
};
 
bool QWidgetPrivate::isInFocusChain() const
{
    Q_Q(const QWidget);
    return !(FOCUS_NEXT(q) == q && FOCUS_PREV(q) == q);
}
 
bool QWidgetPrivate::isFocusChainConsistent() const
{
    Q_Q(const QWidget);
    const bool skip = !QLoggingCategory("qt.widgets.focus").isDebugEnabled();
    if (skip)
        return true;
 
    if (!isInFocusChain())
        return true;
 
    const QWidget *position = q;
 
    for (int i = 0; i < QApplication::allWidgets().count(); ++i) {
        if (!FOCUS_PREV(position) || !FOCUS_NEXT(position)) {
            qCDebug(lcWidgetFocus) << "Nullptr found at:" << position
                             << "Previous pointing to" << FOCUS_PREV(position)
                             << "Next pointing to" << FOCUS_NEXT(position);
            return false;
        }
        if (!(FOCUS_PREV(FOCUS_NEXT(position)) == position
            && FOCUS_NEXT(FOCUS_PREV(position)) == position)) {
            qCDebug(lcWidgetFocus) << "Inconsistent focus chain at:" << position
                             << "Previous pointing to" << FOCUS_PREV(FOCUS_NEXT(position))
                             << "Next pointing to" << FOCUS_NEXT(FOCUS_PREV(position));
            return false;
        }
        position = FOCUS_NEXT(position);
        if (position == q)
            return true;
 
    }
 
    qCDebug(lcWidgetFocus) << "Focus chain leading from" << q << "to" << position << "is not closed.";
    return false;
}
 
#undef FOCUS_NEXT
#undef FOCUS_PREV
 
 
QT_END_NAMESPACE
 
#include "moc_qwidget.cpp"
#include "moc_qwidget_p.cpp"