// Copyright (C) 2021 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

// Qt-Security score:significant reason:default

#include "qguiapplication.h"

#include "private/qguiapplication_p.h"

#include "private/qabstractfileiconprovider_p.h"

#include <qpa/qplatformintegrationfactory_p.h>

#include "private/qevent_p.h"

#include "private/qeventpoint_p.h"

#include "private/qiconloader_p.h"

#include "qfont.h"

#include "qpointingdevice.h"

#include <qpa/qplatformfontdatabase.h>

#include <qpa/qplatformwindow.h>

#include <qpa/qplatformnativeinterface.h>

#include <qpa/qplatformtheme.h>

#include <qpa/qplatformintegration.h>

#include <qpa/qplatformkeymapper.h>

#include <QtCore/QAbstractEventDispatcher>

#include <QtCore/QFileInfo>

#include <QtCore/QStandardPaths>

#include <QtCore/QVariant>

#include <QtCore/private/qcoreapplication_p.h>

#include <QtCore/private/qabstracteventdispatcher_p.h>

#include <QtCore/private/qminimalflatset_p.h>

#include <QtCore/qmutex.h>

#include <QtCore/private/qthread_p.h>

#include <QtCore/private/qlocking_p.h>

#include <QtCore/private/qflatmap_p.h>

#include <QtCore/qdir.h>

#include <QtCore/qlibraryinfo.h>

#include <QtCore/private/qnumeric_p.h>

#include <QtDebug>

#if QT_CONFIG(accessibility)

#include "qaccessible.h"

#endif

#include <qpalette.h>

#include <qscreen.h>

#include "qsessionmanager.h"

#include <private/qcolortrclut_p.h>

#include <private/qscreen_p.h>

#include <QtGui/qgenericpluginfactory.h>

#include <QtGui/qstylehints.h>

#include <QtGui/private/qstylehints_p.h>

#include <QtGui/qinputmethod.h>

#include <QtGui/qpixmapcache.h>

#include <qpa/qplatforminputcontext.h>

#include <qpa/qplatforminputcontext_p.h>

#include <qpa/qwindowsysteminterface.h>

#include <qpa/qwindowsysteminterface_p.h>

#include "private/qwindow_p.h"

#include "private/qicon_p.h"

#include "private/qcursor_p.h"

#if QT_CONFIG(opengl)

#  include "private/qopenglcontext_p.h"

#endif

#include "private/qinputdevicemanager_p.h"

#include "private/qinputmethod_p.h"

#include "private/qpointingdevice_p.h"

#include <qpa/qplatformthemefactory_p.h>

#if QT_CONFIG(draganddrop)

#include <qpa/qplatformdrag.h>

#include <private/qdnd_p.h>

#endif

#ifndef QT_NO_CURSOR

#include <qpa/qplatformcursor.h>

#endif

#include <QtGui/QPixmap>

#ifndef QT_NO_CLIPBOARD

#include <QtGui/QClipboard>

#endif

#if QT_CONFIG(library)

#include <QtCore/QLibrary>

#endif

#if defined(Q_OS_MAC)

#  include "private/qcore_mac_p.h"

#elif defined(Q_OS_WIN)

#  include <QtCore/qt_windows.h>

#  include <QtCore/QLibraryInfo>

#endif // Q_OS_WIN

#ifdef Q_OS_WASM

#include <emscripten.h>

#endif

#if QT_CONFIG(vulkan)

#include <private/qvulkandefaultinstance_p.h>

#endif

#if QT_CONFIG(thread)

#include <QtCore/QThreadPool>

#endif

#include <qtgui_tracepoints_p.h>

#include <private/qtools_p.h>

#include <limits>

QT_BEGIN_NAMESPACE

Q_LOGGING_CATEGORY(lcPopup, "qt.gui.popup");

Q_LOGGING_CATEGORY(lcVirtualKeyboard, "qt.gui.virtualkeyboard");

using namespace Qt::StringLiterals;

using namespace QtMiscUtils;

// Helper macro for static functions to check on the existence of the application class.

#define CHECK_QAPP_INSTANCE(...) \

    if (Q_LIKELY(QCoreApplication::instance())) { \

    } else { \

        qWarning("Must construct a QGuiApplication first."); \

        return __VA_ARGS__; \

    }

Q_CORE_EXPORT void qt_call_post_routines();

Q_CONSTINIT Q_GUI_EXPORT bool qt_is_tty_app = false;

Q_CONSTINIT Qt::MouseButtons QGuiApplicationPrivate::mouse_buttons = Qt::NoButton;

Q_CONSTINIT Qt::KeyboardModifiers QGuiApplicationPrivate::modifier_buttons = Qt::NoModifier;

Q_CONSTINIT QGuiApplicationPrivate::QLastCursorPosition QGuiApplicationPrivate::lastCursorPosition;

Q_CONSTINIT QWindow *QGuiApplicationPrivate::currentMouseWindow = nullptr;

Q_CONSTINIT QString QGuiApplicationPrivate::styleOverride;

Q_CONSTINIT Qt::ApplicationState QGuiApplicationPrivate::applicationState = Qt::ApplicationInactive;

Q_CONSTINIT Qt::HighDpiScaleFactorRoundingPolicy QGuiApplicationPrivate::highDpiScaleFactorRoundingPolicy =

    Qt::HighDpiScaleFactorRoundingPolicy::PassThrough;

Q_CONSTINIT QPointer<QWindow> QGuiApplicationPrivate::currentDragWindow;

Q_CONSTINIT QList<QGuiApplicationPrivate::TabletPointData> QGuiApplicationPrivate::tabletDevicePoints; // TODO remove

Q_CONSTINIT QPlatformIntegration *QGuiApplicationPrivate::platform_integration = nullptr;

Q_CONSTINIT QPlatformTheme *QGuiApplicationPrivate::platform_theme = nullptr;

Q_CONSTINIT QList<QObject *> QGuiApplicationPrivate::generic_plugin_list;

enum ApplicationResourceFlags

{

    ApplicationFontExplicitlySet = 0x2

};

Q_CONSTINIT static unsigned applicationResourceFlags = 0;

Q_CONSTINIT QIcon *QGuiApplicationPrivate::app_icon = nullptr;

Q_CONSTINIT QString *QGuiApplicationPrivate::platform_name = nullptr;

Q_CONSTINIT QString *QGuiApplicationPrivate::displayName = nullptr;

Q_CONSTINIT QString *QGuiApplicationPrivate::desktopFileName = nullptr;

Q_CONSTINIT QPalette *QGuiApplicationPrivate::app_pal = nullptr;        // default application palette

Q_CONSTINIT Qt::MouseButton QGuiApplicationPrivate::mousePressButton = Qt::NoButton;

Q_CONSTINIT static int mouseDoubleClickDistance = 0;

Q_CONSTINIT static int touchDoubleTapDistance = 0;

Q_CONSTINIT QWindow *QGuiApplicationPrivate::currentMousePressWindow = nullptr;

Q_CONSTINIT static Qt::LayoutDirection layout_direction = Qt::LayoutDirectionAuto;

Q_CONSTINIT static Qt::LayoutDirection effective_layout_direction = Qt::LeftToRight;

Q_CONSTINIT static bool force_reverse = false;

Q_DECL_DEPRECATED_X("Use QGuiApplicationPrivate::instance() instead")

Q_CONSTINIT QGuiApplicationPrivate *QGuiApplicationPrivate::self = nullptr;

Q_CONSTINIT int QGuiApplicationPrivate::m_fakeMouseSourcePointId = -1;

#ifndef QT_NO_CLIPBOARD

Q_CONSTINIT QClipboard *QGuiApplicationPrivate::qt_clipboard = nullptr;

#endif

Q_CONSTINIT QList<QScreen *> QGuiApplicationPrivate::screen_list;

Q_CONSTINIT QWindowList QGuiApplicationPrivate::window_list;

Q_CONSTINIT QWindowList QGuiApplicationPrivate::popup_list;

Q_CONSTINIT const QWindow *QGuiApplicationPrivate::active_popup_on_press = nullptr;

Q_CONSTINIT QWindow *QGuiApplicationPrivate::focus_window = nullptr;

Q_CONSTINIT static QBasicMutex applicationFontMutex;

Q_CONSTINIT QFont *QGuiApplicationPrivate::app_font = nullptr;

Q_CONSTINIT QStyleHints *QGuiApplicationPrivate::styleHints = nullptr;

Q_CONSTINIT bool QGuiApplicationPrivate::obey_desktop_settings = true;

Q_CONSTINIT bool QGuiApplicationPrivate::popup_closed_on_press = false;

Q_CONSTINIT QInputDeviceManager *QGuiApplicationPrivate::m_inputDeviceManager = nullptr;

Q_CONSTINIT qreal QGuiApplicationPrivate::m_maxDevicePixelRatio = 0.0;

Q_CONSTINIT QBasicAtomicInt QGuiApplicationPrivate::m_primaryScreenDpis = Q_BASIC_ATOMIC_INITIALIZER(0);

Q_CONSTINIT static qreal fontSmoothingGamma = 1.7;

Q_CONSTINIT bool QGuiApplicationPrivate::quitOnLastWindowClosed = true;

extern void qRegisterGuiVariant();

#if QT_CONFIG(animation)

extern void qRegisterGuiGetInterpolator();

#endif

static bool qt_detectRTLLanguage()

{

    return force_reverse ^

        (QGuiApplication::tr("QT_LAYOUT_DIRECTION",

                         "Translate this string to the string 'LTR' in left-to-right"

                         " languages or to 'RTL' in right-to-left languages (such as Hebrew"

                         " and Arabic) to get proper widget layout.") == "RTL"_L1);

}

static void initFontUnlocked()

{

    if (!QGuiApplicationPrivate::app_font) {

        if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme())

            if (const QFont *font = theme->font(QPlatformTheme::SystemFont))

                QGuiApplicationPrivate::app_font = new QFont(*font);

    }

    if (!QGuiApplicationPrivate::app_font)

        QGuiApplicationPrivate::app_font =

            new QFont(QGuiApplicationPrivate::platformIntegration()->fontDatabase()->defaultFont());

}

static inline void clearFontUnlocked()

{

    delete QGuiApplicationPrivate::app_font;

    QGuiApplicationPrivate::app_font = nullptr;

}

static void initThemeHints()

{

    mouseDoubleClickDistance = QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::MouseDoubleClickDistance).toInt();

    touchDoubleTapDistance = QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::TouchDoubleTapDistance).toInt();

}

#if defined(Q_OS_UNIX) && !defined(Q_OS_DARWIN)

static bool checkNeedPortalSupport()

{

#if QT_CONFIG(dbus)

    return QFileInfo::exists("/.flatpak-info"_L1) || qEnvironmentVariableIsSet("SNAP");

#else

    return false;

#endif // QT_CONFIG(dbus)

}

#endif

// Using aggregate initialization instead of ctor so we can have a POD global static

#define Q_WINDOW_GEOMETRY_SPECIFICATION_INITIALIZER { Qt::TopLeftCorner, -1, -1, -1, -1 }

// Geometry specification for top level windows following the convention of the

// -geometry command line arguments in X11 (see XParseGeometry).

struct QWindowGeometrySpecification

{

    static QWindowGeometrySpecification fromArgument(const QByteArray &a);

    void applyTo(QWindow *window) const;

    Qt::Corner corner;

    int xOffset;

    int yOffset;

    int width;

    int height;

};

// Parse a token of a X11 geometry specification "200x100+10-20".

static inline int nextGeometryToken(const QByteArray &a, int &pos, char *op)

{

    *op = 0;

    const qsizetype size = a.size();

    if (pos >= size)

        return -1;

    *op = a.at(pos);

    if (*op == '+' || *op == '-' || *op == 'x')

        pos++;

    else if (isAsciiDigit(*op))

        *op = 'x'; // If it starts with a digit, it is supposed to be a width specification.

    else

        return -1;

    const int numberPos = pos;

    for ( ; pos < size && isAsciiDigit(a.at(pos)); ++pos) ;

    bool ok;

    const int result = a.mid(numberPos, pos - numberPos).toInt(&ok);

    return ok ? result : -1;

}

QWindowGeometrySpecification QWindowGeometrySpecification::fromArgument(const QByteArray &a)

{

    QWindowGeometrySpecification result = Q_WINDOW_GEOMETRY_SPECIFICATION_INITIALIZER;

    int pos = 0;

    for (int i = 0; i < 4; ++i) {

        char op;

        const int value = nextGeometryToken(a, pos, &op);

        if (value < 0)

            break;

        switch (op) {

        case 'x':

            (result.width >= 0 ? result.height : result.width) = value;

            break;

        case '+':

        case '-':

            if (result.xOffset >= 0) {

                result.yOffset = value;

                if (op == '-')

                    result.corner = result.corner == Qt::TopRightCorner ? Qt::BottomRightCorner : Qt::BottomLeftCorner;

            } else {

                result.xOffset = value;

                if (op == '-')

                    result.corner = Qt::TopRightCorner;

            }

        }

    }

    return result;

}

void QWindowGeometrySpecification::applyTo(QWindow *window) const

{

    QRect windowGeometry = window->frameGeometry();

    QSize size = windowGeometry.size();

    if (width >= 0 || height >= 0) {

        const QSize windowMinimumSize = window->minimumSize();

        const QSize windowMaximumSize = window->maximumSize();

        if (width >= 0)

            size.setWidth(qBound(windowMinimumSize.width(), width, windowMaximumSize.width()));

        if (height >= 0)

            size.setHeight(qBound(windowMinimumSize.height(), height, windowMaximumSize.height()));

        window->resize(size);

    }

    if (xOffset >= 0 || yOffset >= 0) {

        const QRect availableGeometry = window->screen()->virtualGeometry();

        QPoint topLeft = windowGeometry.topLeft();

        if (xOffset >= 0) {

            topLeft.setX(corner == Qt::TopLeftCorner || corner == Qt::BottomLeftCorner ?

                         xOffset :

                         qMax(availableGeometry.right() - size.width() - xOffset, availableGeometry.left()));

        }

        if (yOffset >= 0) {

            topLeft.setY(corner == Qt::TopLeftCorner || corner == Qt::TopRightCorner ?

                         yOffset :

                         qMax(availableGeometry.bottom() - size.height() - yOffset, availableGeometry.top()));

        }

        window->setFramePosition(topLeft);

    }

}

static QWindowGeometrySpecification windowGeometrySpecification = Q_WINDOW_GEOMETRY_SPECIFICATION_INITIALIZER;

/*!

    \macro qGuiApp

    \relates QGuiApplication

    A global pointer referring to the unique application object.

    Only valid for use when that object is a QGuiApplication.

    \sa QCoreApplication::instance(), qApp

*/

/*!

    \class QGuiApplication

    \brief The QGuiApplication class manages the GUI application's control

    flow and main settings.

    \inmodule QtGui

    \since 5.0

    QGuiApplication contains the main event loop, where all events from the window

    system and other sources are processed and dispatched. It also handles the

    application's initialization and finalization, and provides session management.

    In addition, QGuiApplication handles most of the system-wide and application-wide

    settings.

    For any GUI application using Qt, there is precisely \b one QGuiApplication

    object no matter whether the application has 0, 1, 2 or more windows at

    any given time. For non-GUI Qt applications, use QCoreApplication instead,

    as it does not depend on the Qt GUI module. For QWidget based Qt applications,

    use QApplication instead, as it provides some functionality needed for creating

    QWidget instances.

    The QGuiApplication object is accessible through the instance() function, which

    returns a pointer equivalent to the global \l qApp pointer.

    QGuiApplication's main areas of responsibility are:

        \list

            \li  It initializes the application with the user's desktop settings,

                such as palette(), font() and styleHints(). It keeps

                track of these properties in case the user changes the desktop

                globally, for example, through some kind of control panel.

            \li  It performs event handling, meaning that it receives events

                from the underlying window system and dispatches them to the

                relevant widgets. You can send your own events to windows by

                using sendEvent() and postEvent().

            \li  It parses common command line arguments and sets its internal

                state accordingly. See the \l{QGuiApplication::QGuiApplication()}

                {constructor documentation} below for more details.

            \li  It provides localization of strings that are visible to the

                user via translate().

            \li  It provides some magical objects like the clipboard().

            \li  It knows about the application's windows. You can ask which

                window is at a certain position using topLevelAt(), get a list of

                topLevelWindows(), etc.

            \li  It manages the application's mouse cursor handling, see

                setOverrideCursor()

            \li  It provides support for sophisticated \l{Session Management}

                {session management}. This makes it possible for applications

                to terminate gracefully when the user logs out, to cancel a

                shutdown process if termination isn't possible and even to

                preserve the entire application's state for a future session.

                See isSessionRestored(), sessionId() and commitDataRequest() and

                saveStateRequest() for details.

        \endlist

    Since the QGuiApplication object does so much initialization, it \e{must} be

    created before any other objects related to the user interface are created.

    QGuiApplication also deals with common command line arguments. Hence, it is

    usually a good idea to create it \e before any interpretation or

    modification of \c argv is done in the application itself.

    \table

    \header

        \li{2,1} Groups of functions

        \row

        \li  System settings

        \li  desktopSettingsAware(),

            setDesktopSettingsAware(),

            styleHints(),

            palette(),

            setPalette(),

            font(),

            setFont().

        \row

        \li  Event handling

        \li  exec(),

            processEvents(),

            exit(),

            quit().

            sendEvent(),

            postEvent(),

            sendPostedEvents(),

            removePostedEvents(),

            notify().

        \row

        \li  Windows

        \li  allWindows(),

            topLevelWindows(),

            focusWindow(),

            clipboard(),

            topLevelAt().

        \row

        \li  Advanced cursor handling

        \li  overrideCursor(),

            setOverrideCursor(),

            restoreOverrideCursor().

        \row

        \li  Session management

        \li  isSessionRestored(),

            sessionId(),

            commitDataRequest(),

            saveStateRequest().

        \row

        \li  Miscellaneous

        \li  startingUp(),

            closingDown().

    \endtable

    \sa QCoreApplication, QAbstractEventDispatcher, QEventLoop

*/

/*!

    \class QGuiApplicationPrivate

    \inmodule QtGui

    \internal

*/

/*!

    Initializes the window system and constructs an application object with

    \a argc command line arguments in \a argv.

    \warning The data referred to by \a argc and \a argv must stay valid for

    the entire lifetime of the QGuiApplication object. In addition, \a argc must

    be greater than zero and \a argv must contain at least one valid character

    string.

    The global \c qApp pointer refers to this application object. Only one

    application object should be created.

    This application object must be constructed before any \l{QPaintDevice}

    {paint devices} (including pixmaps, bitmaps etc.).

    \note \a argc and \a argv might be changed as Qt removes command line

    arguments that it recognizes.

    \section1 Supported Command Line Options

    All Qt programs automatically support a set of command-line options that

    allow modifying the way Qt will interact with the windowing system. Some of

    the options are also accessible via environment variables, which are the

    preferred form if the application can launch GUI sub-processes or other

    applications (environment variables will be inherited by child processes).

    When in doubt, use the environment variables.

    The options currently supported are the following:

    \list

        \li \c{-platform} \e {platformName[:options]}, specifies the

            \l{Qt Platform Abstraction} (QPA) plugin.

            Overrides the \c QT_QPA_PLATFORM environment variable.

        \li \c{-platformpluginpath} \e path, specifies the path to platform

            plugins.

            Overrides the \c QT_QPA_PLATFORM_PLUGIN_PATH environment variable.

        \li \c{-platformtheme} \e platformTheme, specifies the platform theme.

            Overrides the \c QT_QPA_PLATFORMTHEME environment variable.

        \li \c{-plugin} \e plugin, specifies additional plugins to load. The argument

            may appear multiple times.

            Concatenated with the plugins in the \c QT_QPA_GENERIC_PLUGINS environment

            variable.

        \li \c{-qmljsdebugger=}, activates the QML/JS debugger with a specified port.

            The value must be of format \c{port:1234}\e{[,block]}, where

            \e block is optional

            and will make the application wait until a debugger connects to it.

        \li \c {-qwindowgeometry} \e geometry, specifies window geometry for

            the main window using the X11-syntax. For example:

            \c {-qwindowgeometry 100x100+50+50}

        \li \c {-qwindowicon}, sets the default window icon

        \li \c {-qwindowtitle}, sets the title of the first window

        \li \c{-reverse}, sets the application's layout direction to

            Qt::RightToLeft. This option is intended to aid debugging and should

            not be used in production. The default value is automatically detected

            from the user's locale (see also QLocale::textDirection()).

        \li \c{-session} \e session, restores the application from an earlier

            \l{Session Management}{session}.

    \endlist

    The following standard command line options are available for X11:

    \list

        \li \c {-display} \e {hostname:screen_number}, switches displays on X11.

             Overrides the \c DISPLAY environment variable.

        \li \c {-geometry} \e geometry, same as \c {-qwindowgeometry}.

    \endlist

    \section1 Platform-Specific Arguments

    You can specify platform-specific arguments for the \c{-platform} option.

    Place them after the platform plugin name following a colon as a

    comma-separated list. For example,

    \c{-platform windows:dialogs=xp,fontengine=freetype}.

    The following parameters are available for \c {-platform windows}:

    \list

        \li \c {altgr}, detect the key \c {AltGr} found on some keyboards as

               Qt::GroupSwitchModifier (since Qt 5.12).

        \li \c {darkmode=[0|1|2]} controls how Qt responds to the activation

               of the \e{Dark Mode for applications} introduced in Windows 10

               1903 (since Qt 5.15).

               A value of 0 disables dark mode support.

               A value of 1 causes Qt to switch the window borders to black

               when \e{Dark Mode for applications} is activated and no High

               Contrast Theme is in use. This is intended for applications

               that implement their own theming.

               A value of 2 will in addition cause the Windows Vista style to

               be deactivated and switch to the Windows style using a

               simplified palette in dark mode. This is currently

               experimental pending the introduction of new style that

               properly adapts to dark mode.

               As of Qt 6.5, the default value is 2; to disable dark mode

               support, set the value to 0 or 1.

        \li \c {dialogs=[xp|none]}, \c xp uses XP-style native dialogs and

            \c none disables them.

        \li \c {fontengine=freetype}, uses the FreeType font engine.

        \li \c {fontengine=gdi}, uses the legacy GDI-based

               font database and defaults to using the GDI font

               engine (which is otherwise only used for some font types

               or font properties.) (Since Qt 6.8).

        \li \c {menus=[native|none]}, controls the use of native menus.

               Native menus are implemented using Win32 API and are simpler than

               QMenu-based menus in for example that they do allow for placing

               widgets on them or changing properties like fonts and do not

               provide hover signals. They are mainly intended for Qt Quick.

               By default, they will be used if the application is not an

               instance of QApplication or for Qt Quick Controls 2

               applications (since Qt 5.10).

        \li \c {nocolorfonts} Turn off DirectWrite Color fonts

               (since Qt 5.8).

        \li \c {nodirectwrite} Turn off DirectWrite fonts (since Qt 5.8). This implicitly

               also selects the GDI font engine.

        \li \c {nomousefromtouch} Ignores mouse events synthesized

               from touch events by the operating system.

        \li \c {nowmpointer} Switches from Pointer Input Messages handling

               to legacy mouse handling (since Qt 5.12).

        \li \c {reverse} Activates Right-to-left mode (experimental).

               Windows title bars will be shown accordingly in Right-to-left locales

               (since Qt 5.13).

        \li \c {tabletabsoluterange=<value>} Sets a value for mouse mode detection

               of WinTab tablets (Legacy, since Qt 5.3).

    \endlist

    The following parameter is available for \c {-platform cocoa} (on macOS):

    \list

        \li \c {fontengine=freetype}, uses the FreeType font engine.

    \endlist

    For more information about the platform-specific arguments available for

    embedded Linux platforms, see \l{Qt for Embedded Linux}.

    \sa arguments(), QGuiApplication::platformName

*/

#ifdef Q_QDOC

QGuiApplication::QGuiApplication(int &argc, char **argv)

#else

QGuiApplication::QGuiApplication(int &argc, char **argv, int)

#endif

    : QCoreApplication(*new QGuiApplicationPrivate(argc, argv))

{

    d_func()->init();

    QCoreApplicationPrivate::eventDispatcher->startingUp();

}

/*!

    \internal

*/

QGuiApplication::QGuiApplication(QGuiApplicationPrivate &p)

    : QCoreApplication(p)

{

}

/*!

    Destructs the application.

*/

QGuiApplication::~QGuiApplication()

{

    Q_D(QGuiApplication);

    qt_call_post_routines();

    d->eventDispatcher->closingDown();

    d->eventDispatcher = nullptr;

#ifndef QT_NO_CLIPBOARD

    delete QGuiApplicationPrivate::qt_clipboard;

    QGuiApplicationPrivate::qt_clipboard = nullptr;

#endif

#ifndef QT_NO_SESSIONMANAGER

    delete d->session_manager;

    d->session_manager = nullptr;

#endif //QT_NO_SESSIONMANAGER

    QGuiApplicationPrivate::clearPalette();

    QFontDatabase::removeAllApplicationFonts();

#ifndef QT_NO_CURSOR

    d->cursor_list.clear();

#endif

#if QT_CONFIG(qtgui_threadpool)

    // Synchronize and stop the gui thread pool threads.

    QThreadPool *guiThreadPool = nullptr;

    QT_TRY {

        guiThreadPool = QGuiApplicationPrivate::qtGuiThreadPool();

    } QT_CATCH (...) {

        // swallow the exception, since destructors shouldn't throw

    }

    if (guiThreadPool) {

        guiThreadPool->waitForDone();

        delete guiThreadPool;

    }

#endif

    delete QGuiApplicationPrivate::app_icon;

    QGuiApplicationPrivate::app_icon = nullptr;

    delete QGuiApplicationPrivate::platform_name;

    QGuiApplicationPrivate::platform_name = nullptr;

    delete QGuiApplicationPrivate::displayName;

    QGuiApplicationPrivate::displayName = nullptr;

    delete QGuiApplicationPrivate::m_inputDeviceManager;

    QGuiApplicationPrivate::m_inputDeviceManager = nullptr;

    delete QGuiApplicationPrivate::desktopFileName;

    QGuiApplicationPrivate::desktopFileName = nullptr;

    QGuiApplicationPrivate::mouse_buttons = Qt::NoButton;

    QGuiApplicationPrivate::modifier_buttons = Qt::NoModifier;

    QGuiApplicationPrivate::lastCursorPosition.reset();

    QGuiApplicationPrivate::currentMousePressWindow = QGuiApplicationPrivate::currentMouseWindow = nullptr;

    QGuiApplicationPrivate::applicationState = Qt::ApplicationInactive;

    QGuiApplicationPrivate::highDpiScaleFactorRoundingPolicy = Qt::HighDpiScaleFactorRoundingPolicy::PassThrough;

    QGuiApplicationPrivate::currentDragWindow = nullptr;

    QGuiApplicationPrivate::tabletDevicePoints.clear();

    QGuiApplicationPrivate::m_primaryScreenDpis.storeRelaxed(0);

}

QGuiApplicationPrivate::QGuiApplicationPrivate(int &argc, char **argv)

    : QCoreApplicationPrivate(argc, argv),

      inputMethod(nullptr),

      lastTouchType(QEvent::TouchEnd)

{

    // Note: Not same as QCoreApplication::self

    QT_IGNORE_DEPRECATIONS(QGuiApplicationPrivate::self = this;)

    application_type = QCoreApplicationPrivate::Gui;

#ifndef QT_NO_SESSIONMANAGER

    is_session_restored = false;

    is_saving_session = false;

#endif

}

/*!

    \property QGuiApplication::applicationDisplayName

    \brief the user-visible name of this application

    \since 5.0

    This name is shown to the user, for instance in window titles.

    It can be translated, if necessary.

    If not set, the application display name defaults to the application name.

    \sa applicationName

*/

void QGuiApplication::setApplicationDisplayName(const QString &name)

{

    if (!QGuiApplicationPrivate::displayName) {

        QGuiApplicationPrivate::displayName = new QString(name);

        if (qGuiApp) {

            disconnect(qGuiApp, &QGuiApplication::applicationNameChanged,

                    qGuiApp, &QGuiApplication::applicationDisplayNameChanged);

            if (*QGuiApplicationPrivate::displayName != applicationName())

                emit qGuiApp->applicationDisplayNameChanged();

        }

    } else if (name != *QGuiApplicationPrivate::displayName) {

        *QGuiApplicationPrivate::displayName = name;

        if (qGuiApp)

            emit qGuiApp->applicationDisplayNameChanged();

    }

}

QString QGuiApplication::applicationDisplayName()

{

    return QGuiApplicationPrivate::displayName ? *QGuiApplicationPrivate::displayName : applicationName();

}

/*!

    Sets the application's badge to \a number.

    Useful for providing feedback to the user about the number

    of unread messages or similar.

    The badge will be overlaid on the application's icon in the Dock

    on \macos, the home screen icon on iOS, or the task bar on Windows

    and Linux.

    If the number is outside the range supported by the platform, the

    number will be clamped to the supported range. If the number does

    not fit within the badge, the number may be visually elided.

    Setting the number to 0 will clear the badge.

    \since 6.5

    \sa applicationName

*/

void QGuiApplication::setBadgeNumber(qint64 number)

{

    QGuiApplicationPrivate::platformIntegration()->setApplicationBadge(number);

}

/*!

    \property QGuiApplication::desktopFileName

    \brief the base name of the desktop entry for this application

    \since 5.7

    This is the file name, without the full path or the trailing ".desktop"

    extension of the desktop entry that represents this application

    according to the freedesktop desktop entry specification.

    This property gives a precise indication of what desktop entry represents

    the application and it is needed by the windowing system to retrieve

    such information without resorting to imprecise heuristics.

    The latest version of the freedesktop desktop entry specification can be obtained

    \l{http://standards.freedesktop.org/desktop-entry-spec/latest/}{here}.

*/

void QGuiApplication::setDesktopFileName(const QString &name)

{

    if (!QGuiApplicationPrivate::desktopFileName)

        QGuiApplicationPrivate::desktopFileName = new QString;

    *QGuiApplicationPrivate::desktopFileName = name;

    if (name.endsWith(QLatin1String(".desktop"))) { // ### Qt 7: remove

        const QString filePath = QStandardPaths::locate(QStandardPaths::ApplicationsLocation, name);

        if (!filePath.isEmpty()) {

            qWarning("QGuiApplication::setDesktopFileName: the specified desktop file name "

                     "ends with .desktop. For compatibility reasons, the .desktop suffix will "

                     "be removed. Please specify a desktop file name without .desktop suffix");

            (*QGuiApplicationPrivate::desktopFileName).chop(8);

        }

    }

}

QString QGuiApplication::desktopFileName()

{

    return QGuiApplicationPrivate::desktopFileName ? *QGuiApplicationPrivate::desktopFileName : QString();

}

/*!

    Returns the most recently shown modal window. If no modal windows are

    visible, this function returns zero.

    A modal window is a window which has its

    \l{QWindow::modality}{modality} property set to Qt::WindowModal

    or Qt::ApplicationModal. A modal window must be closed before the user can

    continue with other parts of the program.

    Modal window are organized in a stack. This function returns the modal

    window at the top of the stack.

    \sa Qt::WindowModality, QWindow::setModality()

*/

QWindow *QGuiApplication::modalWindow()

{

    CHECK_QAPP_INSTANCE(nullptr)

    const auto &modalWindows = QGuiApplicationPrivate::instance()->modalWindowList;

    if (modalWindows.isEmpty())

        return nullptr;

    return modalWindows.constFirst();

}

static void updateBlockedStatusRecursion(QWindow *window, bool shouldBeBlocked)

{

    QWindowPrivate *p = qt_window_private(window);

    if (p->blockedByModalWindow != shouldBeBlocked) {

        p->blockedByModalWindow = shouldBeBlocked;

        QEvent e(shouldBeBlocked ? QEvent::WindowBlocked : QEvent::WindowUnblocked);

        QGuiApplication::sendEvent(window, &e);

        for (QObject *c : window->children()) {

            if (c->isWindowType())

                updateBlockedStatusRecursion(static_cast<QWindow *>(c), shouldBeBlocked);

        }

    }

}

void QGuiApplicationPrivate::updateBlockedStatus(QWindow *window)

{

    bool shouldBeBlocked = false;

    const bool popupType = (window->type() == Qt::ToolTip) || (window->type() == Qt::Popup);

    if (!popupType && !QGuiApplicationPrivate::instance()->modalWindowList.isEmpty())

        shouldBeBlocked = QGuiApplicationPrivate::instance()->isWindowBlocked(window);

    updateBlockedStatusRecursion(window, shouldBeBlocked);

}

// Return whether the window needs to be notified about window blocked events.

// As opposed to QGuiApplication::topLevelWindows(), embedded windows are

// included in this list (QTBUG-18099).

static inline bool needsWindowBlockedEvent(const QWindow *w)

{

    return w->isTopLevel();

}

void QGuiApplicationPrivate::showModalWindow(QWindow *modal)

{

    auto *guiAppPrivate = QGuiApplicationPrivate::instance();

    guiAppPrivate->modalWindowList.prepend(modal);

    // Send leave for currently entered window if it should be blocked

    if (currentMouseWindow && !QWindowPrivate::get(currentMouseWindow)->isPopup()) {

        bool shouldBeBlocked = guiAppPrivate->isWindowBlocked(currentMouseWindow);

        if (shouldBeBlocked) {

            // Remove the new window from modalWindowList temporarily so leave can go through

            guiAppPrivate->modalWindowList.removeFirst();

            QEvent e(QEvent::Leave);

            QGuiApplication::sendEvent(currentMouseWindow, &e);

            currentMouseWindow = nullptr;

            guiAppPrivate->modalWindowList.prepend(modal);

        }

    }

    for (QWindow *window : std::as_const(QGuiApplicationPrivate::window_list)) {

        if (needsWindowBlockedEvent(window) && !window->d_func()->blockedByModalWindow)

            updateBlockedStatus(window);

    }

    updateBlockedStatus(modal);

}

void QGuiApplicationPrivate::hideModalWindow(QWindow *window)

{

    QGuiApplicationPrivate::instance()->modalWindowList.removeAll(window);

    for (QWindow *window : std::as_const(QGuiApplicationPrivate::window_list)) {

        if (needsWindowBlockedEvent(window) && window->d_func()->blockedByModalWindow)

            updateBlockedStatus(window);

    }

}

Qt::WindowModality QGuiApplicationPrivate::defaultModality() const

{

    return Qt::NonModal;

}

bool QGuiApplicationPrivate::windowNeverBlocked(QWindow *window) const

{

    Q_UNUSED(window);

    return false;

}

/*

    Returns \c true if \a window is blocked by a modal window. If \a

    blockingWindow is non-zero, *blockingWindow will be set to the blocking

    window (or to zero if \a window is not blocked).

*/

bool QGuiApplicationPrivate::isWindowBlocked(QWindow *window, QWindow **blockingWindow) const

{

    Q_ASSERT_X(window, Q_FUNC_INFO, "The window must not be null");

    QWindow *unused = nullptr;

    if (!blockingWindow)

        blockingWindow = &unused;

    *blockingWindow = nullptr;

    if (modalWindowList.isEmpty() || windowNeverBlocked(window))

        return false;

    for (int i = 0; i < modalWindowList.size(); ++i) {

        QWindow *modalWindow = modalWindowList.at(i);

        // A window is not blocked by another modal window if the two are

        // the same, or if the window is a child of the modal window.

        if (window == modalWindow || modalWindow->isAncestorOf(window, QWindow::IncludeTransients))

            return false;

        switch (modalWindow->modality() == Qt::NonModal ? defaultModality()

                                                        : modalWindow->modality()) {

        case Qt::ApplicationModal:

            *blockingWindow = modalWindow;

            return true;

        case Qt::WindowModal: {

            // Find the nearest ancestor of window which is also an ancestor of modal window to

            // determine if the modal window blocks the window.

            auto *current = window;

            do {

                if (current->isAncestorOf(modalWindow, QWindow::IncludeTransients)) {

                    *blockingWindow = modalWindow;

                    return true;

                }

                current = current->parent(QWindow::IncludeTransients);

            } while (current);

            break;

        }

        default:

            Q_ASSERT_X(false, "QGuiApplication", "internal error, a modal widget cannot be modeless");

            break;

        }

    }

    return false;

}

QWindow *QGuiApplicationPrivate::activePopupWindow()

{

    // might be the same as focusWindow() if that's a popup

    return QGuiApplicationPrivate::popup_list.isEmpty() ?

            nullptr : QGuiApplicationPrivate::popup_list.constLast();

}

void QGuiApplicationPrivate::activatePopup(QWindow *popup)

{

    if (!popup->isVisible())

        return;

    popup_list.removeOne(popup); // ensure that there's only one entry, and it's the last

    qCDebug(lcPopup) << "appending popup" << popup << "to existing" << popup_list;

    popup_list.append(popup);

}

bool QGuiApplicationPrivate::closePopup(QWindow *popup)