-
Andreas Hartmetz authored
That feature is a poor man's session management for applications that do not implement any specific session management features. It badly interferes with proper session management support, so applications must be able to disable it. This enables fixing applications with QGuiApplication::quitOnLastWindowClosed() true - the default - dying too early, before they are enumerated for the list of applications to restart on session restore, thus preventing them from being restored. See https://bugs.kde.org/show_bug.cgi?id=354724 [ChangeLog][QtGui] Qt asking to close windows on session exit as a fallback session management mechanism has been made optional. Disabling it fixes session management for applications that implement full session management. See QGuiApplication::isFallbackSessionManagementEnabled(). Task-number: QTBUG-49667 Change-Id: Ib22e58c9c64351dea8b7e2a74db91d26dd7ab7aa Reviewed-by:
Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com> Reviewed-by:
David Faure <david.faure@kdab.com>
e7bf0edf
qguiapplication.cpp 128.35 KiB
/******************************************************************************** Copyright (C) 2015 The Qt Company Ltd.** Contact: http://www.qt.io/licensing/**** This file is part of the QtGui module of the Qt Toolkit.**** $QT_BEGIN_LICENSE:LGPL21$** Commercial License Usage** Licensees holding valid commercial Qt licenses may use this file in** accordance with the commercial license agreement provided with the** Software or, alternatively, in accordance with the terms contained in** a written agreement between you and The Qt Company. For licensing terms** and conditions see http://www.qt.io/terms-conditions. For further** information use the contact form at http://www.qt.io/contact-us.**** GNU Lesser General Public License Usage** Alternatively, this file may be used under the terms of the GNU Lesser** General Public License version 2.1 or version 3 as published by the Free** Software Foundation and appearing in the file LICENSE.LGPLv21 and** LICENSE.LGPLv3 included in the packaging of this file. Please review the** following information to ensure the GNU Lesser General Public License** requirements will be met: https://www.gnu.org/licenses/lgpl.html and** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.**** As a special exception, The Qt Company gives you certain additional** rights. These rights are described in The Qt Company LGPL Exception** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.**** $QT_END_LICENSE$******************************************************************************/#include "qguiapplication.h"#include "private/qguiapplication_p.h"#include <qpa/qplatformintegrationfactory_p.h>#include "private/qevent_p.h"#include "qfont.h"#include <qpa/qplatformfontdatabase.h>#include <qpa/qplatformwindow.h>#include <qpa/qplatformnativeinterface.h>#include <qpa/qplatformtheme.h>#include <qpa/qplatformintegration.h>#include <qpa/qplatformdrag.h>#include <QtCore/QAbstractEventDispatcher>#include <QtCore/QVariant>#include <QtCore/private/qcoreapplication_p.h>#include <QtCore/private/qabstracteventdispatcher_p.h>#include <QtCore/qmutex.h>#include <QtCore/private/qthread_p.h>#include <QtCore/qdir.h>#include <QtCore/qlibraryinfo.h>#include <QtCore/qnumeric.h>#include <QtDebug>#ifndef QT_NO_ACCESSIBILITY#include "qaccessible.h"#endif#include <qpalette.h>#include <qscreen.h>#include "qsessionmanager.h"#include <private/qscreen_p.h>#include <private/qdrawhelper_p.h>#include <QtGui/qgenericpluginfactory.h>#include <QtGui/qstylehints.h>#include <QtGui/qinputmethod.h>#include <QtGui/qpixmapcache.h>#include <qpa/qplatforminputcontext.h>7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
#include <qpa/qplatforminputcontext_p.h>
#include <qpa/qwindowsysteminterface.h>
#include <qpa/qwindowsysteminterface_p.h>
#include "private/qwindow_p.h"
#include "private/qcursor_p.h"
#include "private/qopenglcontext_p.h"
#include "private/qinputdevicemanager_p.h"
#include "private/qdnd_p.h"
#include <qpa/qplatformthemefactory_p.h>
#ifndef QT_NO_CURSOR
#include <qpa/qplatformcursor.h>
#endif
#include <QtGui/QPixmap>
#ifndef QT_NO_CLIPBOARD
#include <QtGui/QClipboard>
#endif
#ifndef QT_NO_LIBRARY
#include <QtCore/QLibrary>
#endif
#if defined(Q_OS_MAC)
# include "private/qcore_mac_p.h"
#elif defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
# include <QtCore/qt_windows.h>
# include <QtCore/QLibraryInfo>
# if defined(Q_OS_WINPHONE)
# include <Objbase.h>
# endif
#endif // Q_OS_WIN && !Q_OS_WINCE
#include <ctype.h>
QT_BEGIN_NAMESPACE
// 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_GUI_EXPORT bool qt_is_gui_used = true;
Qt::MouseButtons QGuiApplicationPrivate::mouse_buttons = Qt::NoButton;
Qt::KeyboardModifiers QGuiApplicationPrivate::modifier_buttons = Qt::NoModifier;
QPointF QGuiApplicationPrivate::lastCursorPosition(qInf(), qInf());
Qt::MouseButtons QGuiApplicationPrivate::tabletState = Qt::NoButton;
QWindow *QGuiApplicationPrivate::tabletPressTarget = 0;
QWindow *QGuiApplicationPrivate::currentMouseWindow = 0;
QString QGuiApplicationPrivate::styleOverride;
Qt::ApplicationState QGuiApplicationPrivate::applicationState = Qt::ApplicationInactive;
bool QGuiApplicationPrivate::highDpiScalingUpdated = false;
QPlatformIntegration *QGuiApplicationPrivate::platform_integration = 0;
QPlatformTheme *QGuiApplicationPrivate::platform_theme = 0;
QList<QObject *> QGuiApplicationPrivate::generic_plugin_list;
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
bool QGuiApplicationPrivate::is_fallback_session_management_enabled = true;
enum ApplicationResourceFlags
{
ApplicationPaletteExplicitlySet = 0x1,
ApplicationFontExplicitlySet = 0x2
};
static unsigned applicationResourceFlags = 0;
QIcon *QGuiApplicationPrivate::app_icon = 0;
QString *QGuiApplicationPrivate::platform_name = 0;
QString *QGuiApplicationPrivate::displayName = 0;
QPalette *QGuiApplicationPrivate::app_pal = 0; // default application palette
Qt::MouseButtons QGuiApplicationPrivate::buttons = Qt::NoButton;
ulong QGuiApplicationPrivate::mousePressTime = 0;
Qt::MouseButton QGuiApplicationPrivate::mousePressButton = Qt::NoButton;
int QGuiApplicationPrivate::mousePressX = 0;
int QGuiApplicationPrivate::mousePressY = 0;
int QGuiApplicationPrivate::mouse_double_click_distance = -1;
QWindow *QGuiApplicationPrivate::currentMousePressWindow = 0;
static Qt::LayoutDirection layout_direction = Qt::LayoutDirectionAuto;
static bool force_reverse = false;
QGuiApplicationPrivate *QGuiApplicationPrivate::self = 0;
QTouchDevice *QGuiApplicationPrivate::m_fakeTouchDevice = 0;
int QGuiApplicationPrivate::m_fakeMouseSourcePointId = 0;
#ifndef QT_NO_CLIPBOARD
QClipboard *QGuiApplicationPrivate::qt_clipboard = 0;
#endif
QList<QScreen *> QGuiApplicationPrivate::screen_list;
QWindowList QGuiApplicationPrivate::window_list;
QWindow *QGuiApplicationPrivate::focus_window = 0;
static QBasicMutex applicationFontMutex;
QFont *QGuiApplicationPrivate::app_font = 0;
QStyleHints *QGuiApplicationPrivate::styleHints = Q_NULLPTR;
bool QGuiApplicationPrivate::obey_desktop_settings = true;
QInputDeviceManager *QGuiApplicationPrivate::m_inputDeviceManager = 0;
static qreal fontSmoothingGamma = 1.7;
extern void qRegisterGuiVariant();
#ifndef QT_NO_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.") == QLatin1String("RTL"));
}
static void initPalette()
{
if (!QGuiApplicationPrivate::app_pal)
if (const QPalette *themePalette = QGuiApplicationPrivate::platformTheme()->palette())
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
QGuiApplicationPrivate::app_pal = new QPalette(*themePalette);
if (!QGuiApplicationPrivate::app_pal)
QGuiApplicationPrivate::app_pal = new QPalette(Qt::gray);
}
static inline void clearPalette()
{
delete QGuiApplicationPrivate::app_pal;
QGuiApplicationPrivate::app_pal = 0;
}
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 = 0;
}
// Geometry specification for top level windows following the convention of the
// -geometry command line arguments in X11 (see XParseGeometry).
struct QWindowGeometrySpecification
{
QWindowGeometrySpecification() : corner(Qt::TopLeftCorner), xOffset(-1), yOffset(-1), width(-1), height(-1) {}
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 int size = a.size();
if (pos >= size)
return -1;
*op = a.at(pos);
if (*op == '+' || *op == '-' || *op == 'x')
pos++;
else if (isdigit(*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 && isdigit(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)
{
281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
QWindowGeometrySpecification result;
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;
/*!
\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.
351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
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().
421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490
\row
\li Event handling
\li exec(),
processEvents(),
exit(),
quit().
sendEvent(),
postEvent(),
sendPostedEvents(),
removePostedEvents(),
hasPendingEvents(),
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
*/
/*!
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.
491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560
The options currently supported are the following:
\list
\li \c{-platform} \e {platformName[:options]}, specifies the
\l{Qt Platform Abstraction} (QPA) plugin.
Overridden by the \c QT_QPA_PLATFORM environment variable.
\li \c{-platformpluginpath} \e path, specifies the path to platform
plugins.
Overridden by the \c QT_QPA_PLATFORM_PLUGIN_PATH environment
variable.
\li \c{-platformtheme} \e platformTheme, specifies the platform theme.
Overridden by the \c QT_QPA_PLATFORMTHEME environment variable.
\li \c{-plugin} \e plugin, specifies additional plugins to load. The argument
may appear multiple times.
Overridden by 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 {dialogs=[xp|none]}, \c xp uses XP-style native dialogs and
\c none disables them.
\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)
561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630
#else
QGuiApplication::QGuiApplication(int &argc, char **argv, int flags)
#endif
: QCoreApplication(*new QGuiApplicationPrivate(argc, argv, flags))
{
d_func()->init();
QCoreApplicationPrivate::eventDispatcher->startingUp();
}
/*!
\internal
*/
QGuiApplication::QGuiApplication(QGuiApplicationPrivate &p)
: QCoreApplication(p)
{
d_func()->init(); }
/*!
Destructs the application.
*/
QGuiApplication::~QGuiApplication()
{
Q_D(QGuiApplication);
d->eventDispatcher->closingDown();
d->eventDispatcher = 0;
#ifndef QT_NO_CLIPBOARD
delete QGuiApplicationPrivate::qt_clipboard;
QGuiApplicationPrivate::qt_clipboard = 0;
#endif
#ifndef QT_NO_SESSIONMANAGER
delete d->session_manager;
d->session_manager = 0;
#endif //QT_NO_SESSIONMANAGER
clearPalette();
QFontDatabase::removeAllApplicationFonts();
#ifndef QT_NO_CURSOR
d->cursor_list.clear();
#endif
delete QGuiApplicationPrivate::app_icon;
QGuiApplicationPrivate::app_icon = 0;
delete QGuiApplicationPrivate::platform_name;
QGuiApplicationPrivate::platform_name = 0;
delete QGuiApplicationPrivate::displayName;
QGuiApplicationPrivate::displayName = 0;
delete QGuiApplicationPrivate::m_inputDeviceManager;
QGuiApplicationPrivate::m_inputDeviceManager = 0;
}
QGuiApplicationPrivate::QGuiApplicationPrivate(int &argc, char **argv, int flags)
: QCoreApplicationPrivate(argc, argv, flags),
inputMethod(0),
lastTouchType(QEvent::TouchEnd),
ownGlobalShareContext(false)
{
self = this;
application_type = QCoreApplicationPrivate::Gui;
#ifndef QT_NO_SESSIONMANAGER
is_session_restored = false;
is_saving_session = false;
#endif
}
/*!
631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700
\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;
*QGuiApplicationPrivate::displayName = name;
}
QString QGuiApplication::applicationDisplayName()
{
return QGuiApplicationPrivate::displayName ? *QGuiApplicationPrivate::displayName : applicationName();
}
/*!
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(Q_NULLPTR)
if (QGuiApplicationPrivate::self->modalWindowList.isEmpty())
return 0;
return QGuiApplicationPrivate::self->modalWindowList.first();
}
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);
foreach (QObject *c, window->children())
if (c->isWindowType())
updateBlockedStatusRecursion(static_cast<QWindow *>(c), shouldBeBlocked);
}
}
void QGuiApplicationPrivate::updateBlockedStatus(QWindow *window)
{
bool shouldBeBlocked = false;
if (!QWindowPrivate::get(window)->isPopup() && !self->modalWindowList.isEmpty())
shouldBeBlocked = self->isWindowBlocked(window);
updateBlockedStatusRecursion(window, shouldBeBlocked);
}
void QGuiApplicationPrivate::showModalWindow(QWindow *modal)
{
self->modalWindowList.prepend(modal);
701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770
// Send leave for currently entered window if it should be blocked
if (currentMouseWindow && !QWindowPrivate::get(currentMouseWindow)->isPopup()) {
bool shouldBeBlocked = self->isWindowBlocked(currentMouseWindow);
if (shouldBeBlocked) {
// Remove the new window from modalWindowList temporarily so leave can go through
self->modalWindowList.removeFirst();
QEvent e(QEvent::Leave);
QGuiApplication::sendEvent(currentMouseWindow, &e);
currentMouseWindow = 0;
self->modalWindowList.prepend(modal);
}
}
QWindowList windows = QGuiApplication::topLevelWindows();
for (int i = 0; i < windows.count(); ++i) {
QWindow *window = windows.at(i);
if (!window->d_func()->blockedByModalWindow)
updateBlockedStatus(window);
}
updateBlockedStatus(modal);
}
void QGuiApplicationPrivate::hideModalWindow(QWindow *window)
{
self->modalWindowList.removeAll(window);
QWindowList windows = QGuiApplication::topLevelWindows();
for (int i = 0; i < windows.count(); ++i) {
QWindow *window = windows.at(i);
if (window->d_func()->blockedByModalWindow)
updateBlockedStatus(window);
}
}
/*
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
{
QWindow *unused = 0;
if (!blockingWindow)
blockingWindow = &unused;
if (modalWindowList.isEmpty()) {
*blockingWindow = 0;
return false;
}
for (int i = 0; i < modalWindowList.count(); ++i) {
QWindow *modalWindow = modalWindowList.at(i);
{
// check if the modal window is our window or a (transient) parent of our window
QWindow *w = window;
while (w) {
if (w == modalWindow) {
*blockingWindow = 0;
return false;
}
QWindow *p = w->parent();
if (!p)
p = w->transientParent();
w = p;
}
}
Qt::WindowModality windowModality = modalWindow->modality();
771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840
switch (windowModality) {
case Qt::ApplicationModal:
{
if (modalWindow != window) {
*blockingWindow = modalWindow;
return true;
}
break;
}
case Qt::WindowModal:
{
QWindow *w = window;
do {
QWindow *m = modalWindow;
do {
if (m == w) {
*blockingWindow = m;
return true;
}
QWindow *p = m->parent();
if (!p)
p = m->transientParent();
m = p;
} while (m);
QWindow *p = w->parent();
if (!p)
p = w->transientParent();
w = p;
} while (w);
break;
}
default:
Q_ASSERT_X(false, "QGuiApplication", "internal error, a modal widget cannot be modeless");
break;
}
}
*blockingWindow = 0;
return false;
}
/*!
Returns the QWindow that receives events tied to focus,
such as key events.
*/
QWindow *QGuiApplication::focusWindow()
{
return QGuiApplicationPrivate::focus_window;
}
/*!
\fn QGuiApplication::focusObjectChanged(QObject *focusObject)
This signal is emitted when final receiver of events tied to focus is changed.
\a focusObject is the new receiver.
\sa focusObject()
*/
/*!
\fn QGuiApplication::focusWindowChanged(QWindow *focusWindow)
This signal is emitted when the focused window changes.
\a focusWindow is the new focused window.
\sa focusWindow()
*/
/*!
Returns the QObject in currently active window that will be final receiver of events
tied to focus, such as key events.
841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910
*/
QObject *QGuiApplication::focusObject()
{
if (focusWindow())
return focusWindow()->focusObject();
return 0;
}
/*!
\fn QGuiApplication::allWindows()
Returns a list of all the windows in the application.
The list is empty if there are no windows.
\sa topLevelWindows()
*/
QWindowList QGuiApplication::allWindows()
{
return QGuiApplicationPrivate::window_list;
}
/*!
\fn QGuiApplication::topLevelWindows()
Returns a list of the top-level windows in the application.
\sa allWindows()
*/
QWindowList QGuiApplication::topLevelWindows()
{
const QWindowList &list = QGuiApplicationPrivate::window_list;
QWindowList topLevelWindows;
for (int i = 0; i < list.size(); i++) {
if (!list.at(i)->parent() && list.at(i)->type() != Qt::Desktop) {
// Top windows of embedded QAxServers do not have QWindow parents,
// but they are not true top level windows, so do not include them.
const bool embedded = list.at(i)->handle() && list.at(i)->handle()->isEmbedded();
if (!embedded)
topLevelWindows.prepend(list.at(i));
}
}
return topLevelWindows;
}
QScreen *QGuiApplication::primaryScreen()
{
if (QGuiApplicationPrivate::screen_list.isEmpty())
return 0;
return QGuiApplicationPrivate::screen_list.at(0);
}
/*!
Returns a list of all the screens associated with the
windowing system the application is connected to.
*/
QList<QScreen *> QGuiApplication::screens()
{
return QGuiApplicationPrivate::screen_list;
}
/*!
\fn void QGuiApplication::screenAdded(QScreen *screen)
This signal is emitted whenever a new screen \a screen has been added to the system.
\sa screens(), primaryScreen, screenRemoved()
*/
/*!
911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980
\fn void QGuiApplication::screenRemoved(QScreen *screen)
This signal is emitted whenever a \a screen is removed from the system. It
provides an opportunity to manage the windows on the screen before Qt falls back
to moving them to the primary screen.
\sa screens(), screenAdded(), QObject::destroyed(), QWindow::setScreen()
\since 5.4
*/
/*!
\property QGuiApplication::primaryScreen
\brief the primary (or default) screen of the application.
This will be the screen where QWindows are initially shown, unless otherwise specified.
The primaryScreenChanged signal was introduced in Qt 5.6.
\sa screens()
*/
/*!
Returns the highest screen device pixel ratio found on
the system. This is the ratio between physical pixels and
device-independent pixels.
Use this function only when you don't know which window you are targeting.
If you do know the target window, use QWindow::devicePixelRatio() instead.
\sa QWindow::devicePixelRatio()
*/
qreal QGuiApplication::devicePixelRatio() const
{
// Cache topDevicePixelRatio, iterate through the screen list once only.
static qreal topDevicePixelRatio = 0.0;
if (!qFuzzyIsNull(topDevicePixelRatio)) {
return topDevicePixelRatio;
}
topDevicePixelRatio = 1.0; // make sure we never return 0.
foreach (QScreen *screen, QGuiApplicationPrivate::screen_list) {
topDevicePixelRatio = qMax(topDevicePixelRatio, screen->devicePixelRatio());
}
return topDevicePixelRatio;
}
/*!
Returns the top level window at the given position \a pos, if any.
*/
QWindow *QGuiApplication::topLevelAt(const QPoint &pos)
{
const QList<QScreen *> screens = QGuiApplication::screens();
if (!screens.isEmpty()) {
const QList<QScreen *> primaryScreens = screens.first()->virtualSiblings();
QScreen *windowScreen = Q_NULLPTR;
// Find the window on the primary virtual desktop first
foreach (QScreen *screen, primaryScreens) {
if (screen->geometry().contains(pos)) {
windowScreen = screen;
break;
}
}
// If the window is not found on primary virtual desktop, find it on all screens
// except the first which was for sure in the previous loop. Some other screens
981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050
// may repeat. Find only when there is more than one virtual desktop.
if (!windowScreen && screens.count() != primaryScreens.count()) {
for (int i = 1; i < screens.size(); ++i) {
QScreen *screen = screens[i];
if (screen->geometry().contains(pos)) {
windowScreen = screen;
break;
}
}
}
if (windowScreen) {
const QPoint devicePosition = QHighDpi::toNativePixels(pos, windowScreen);
return windowScreen->handle()->topLevelAt(devicePosition);
}
}
return Q_NULLPTR;
}
/*!
\property QGuiApplication::platformName
\brief The name of the underlying platform plugin.
The QPA platform plugins are located in \c {qtbase\src\plugins\platforms}.
At the time of writing, the following platform plugin names are supported:
\list
\li \c android
\li \c cocoa is a platform plugin for OS X.
\li \c directfb
\li \c eglfs is a platform plugin for running Qt5 applications on top of
EGL and OpenGL ES 2.0 without an actual windowing system (like X11
or Wayland). For more information, see \l{EGLFS}.
\li \c ios
\li \c kms is an experimental platform plugin using kernel modesetting
and \l{http://dri.freedesktop.org/wiki/DRM}{DRM} (Direct Rendering
Manager).
\li \c linuxfb writes directly to the framebuffer. For more information,
see \l{LinuxFB}.
\li \c minimal is provided as an examples for developers who want to
write their own platform plugins. However, you can use the plugin to
run GUI applications in environments without a GUI, such as servers.
\li \c minimalegl is an example plugin.
\li \c offscreen
\li \c openwfd
\li \c qnx
\li \c windows
\li \c xcb is the X11 plugin used on regular desktop Linux platforms.
\endlist
For more information about the platform plugins for embedded Linux devices,
see \l{Qt for Embedded Linux}.
*/
QString QGuiApplication::platformName()
{
return QGuiApplicationPrivate::platform_name ?
*QGuiApplicationPrivate::platform_name : QString();
}
static void init_platform(const QString &pluginArgument, const QString &platformPluginPath, const QString &platformThemeName, int &argc, char **argv)
{
// Split into platform name and arguments
QStringList arguments = pluginArgument.split(QLatin1Char(':'));
const QString name = arguments.takeFirst().toLower();
QString argumentsKey = name;
argumentsKey[0] = argumentsKey.at(0).toUpper();
arguments.append(QLibraryInfo::platformPluginArguments(argumentsKey));
// Create the platform integration.
1051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120
QGuiApplicationPrivate::platform_integration = QPlatformIntegrationFactory::create(name, arguments, argc, argv, platformPluginPath);
if (QGuiApplicationPrivate::platform_integration) {
QGuiApplicationPrivate::platform_name = new QString(name);
} else {
QStringList keys = QPlatformIntegrationFactory::keys(platformPluginPath);
QString fatalMessage
= QStringLiteral("This application failed to start because it could not find or load the Qt platform plugin \"%1\"\nin \"%2\".\n\n").arg(name, QDir::toNativeSeparators(platformPluginPath));
if (!keys.isEmpty()) {
fatalMessage += QStringLiteral("Available platform plugins are: %1.\n\n").arg(
keys.join(QStringLiteral(", ")));
}
fatalMessage += QStringLiteral("Reinstalling the application may fix this problem.");
#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
// Windows: Display message box unless it is a console application
// or debug build showing an assert box.
if (!QLibraryInfo::isDebugBuild() && !GetConsoleWindow())
MessageBox(0, (LPCTSTR)fatalMessage.utf16(), (LPCTSTR)(QCoreApplication::applicationName().utf16()), MB_OK | MB_ICONERROR);
#endif // Q_OS_WIN && !Q_OS_WINCE && !Q_OS_WINRT
qFatal("%s", qPrintable(fatalMessage));
return;
}
// Many platforms have created QScreens at this point. Finish initializing
// QHighDpiScaling to be prepared for early calls to qt_defaultDpi().
if (QGuiApplication::primaryScreen()) {
QGuiApplicationPrivate::highDpiScalingUpdated = true;
QHighDpiScaling::updateHighDpiScaling();
}
// Create the platform theme:
// 1) Fetch the platform name from the environment if present.
QStringList themeNames;
if (!platformThemeName.isEmpty())
themeNames.append(platformThemeName);
// 2) Ask the platform integration for a list of theme names
themeNames += QGuiApplicationPrivate::platform_integration->themeNames();
// 3) Look for a theme plugin.
foreach (const QString &themeName, themeNames) {
QGuiApplicationPrivate::platform_theme = QPlatformThemeFactory::create(themeName, platformPluginPath);
if (QGuiApplicationPrivate::platform_theme)
break;
}
// 4) If no theme plugin was found ask the platform integration to
// create a theme
if (!QGuiApplicationPrivate::platform_theme) {
foreach (const QString &themeName, themeNames) {
QGuiApplicationPrivate::platform_theme = QGuiApplicationPrivate::platform_integration->createPlatformTheme(themeName);
if (QGuiApplicationPrivate::platform_theme)
break;
}
// No error message; not having a theme plugin is allowed.
}
// 5) Fall back on the built-in "null" platform theme.
if (!QGuiApplicationPrivate::platform_theme)
QGuiApplicationPrivate::platform_theme = new QPlatformTheme;
#ifndef QT_NO_PROPERTIES
// Set arguments as dynamic properties on the native interface as
// boolean 'foo' or strings: 'foo=bar'
if (!arguments.isEmpty()) {
if (QObject *nativeInterface = QGuiApplicationPrivate::platform_integration->nativeInterface()) {
foreach (const QString &argument, arguments) {
const int equalsPos = argument.indexOf(QLatin1Char('='));
const QByteArray name =
equalsPos != -1 ? argument.left(equalsPos).toUtf8() : argument.toUtf8();
1121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190
const QVariant value =
equalsPos != -1 ? QVariant(argument.mid(equalsPos + 1)) : QVariant(true);
nativeInterface->setProperty(name.constData(), value);
}
}
}
#endif
fontSmoothingGamma = QGuiApplicationPrivate::platformIntegration()->styleHint(QPlatformIntegration::FontSmoothingGamma).toReal();
}
static void init_plugins(const QList<QByteArray> &pluginList)
{
for (int i = 0; i < pluginList.count(); ++i) {
QByteArray pluginSpec = pluginList.at(i);
int colonPos = pluginSpec.indexOf(':');
QObject *plugin;
if (colonPos < 0)
plugin = QGenericPluginFactory::create(QLatin1String(pluginSpec), QString());
else
plugin = QGenericPluginFactory::create(QLatin1String(pluginSpec.mid(0, colonPos)),
QLatin1String(pluginSpec.mid(colonPos+1)));
if (plugin)
QGuiApplicationPrivate::generic_plugin_list.append(plugin);
else
qWarning() << "No such plugin for spec " << pluginSpec;
}
}
void QGuiApplicationPrivate::createPlatformIntegration()
{
// Use the Qt menus by default. Platform plugins that
// want to enable a native menu implementation can clear
// this flag.
QCoreApplication::setAttribute(Qt::AA_DontUseNativeMenuBar, true);
QHighDpiScaling::initHighDpiScaling();
// Load the platform integration
QString platformPluginPath = QString::fromLocal8Bit(qgetenv("QT_QPA_PLATFORM_PLUGIN_PATH"));
QByteArray platformName;
#ifdef QT_QPA_DEFAULT_PLATFORM_NAME
platformName = QT_QPA_DEFAULT_PLATFORM_NAME;
#endif
QByteArray platformNameEnv = qgetenv("QT_QPA_PLATFORM");
if (!platformNameEnv.isEmpty()) {
platformName = platformNameEnv;
}
QString platformThemeName = QString::fromLocal8Bit(qgetenv("QT_QPA_PLATFORMTHEME"));
// Get command line params
QString icon;
int j = argc ? 1 : 0;
for (int i=1; i<argc; i++) {
if (!argv[i])
continue;
if (*argv[i] != '-') {
argv[j++] = argv[i];
continue;
}
const bool isXcb = platformName == "xcb";
const char *arg = argv[i];
if (arg[1] == '-') // startsWith("--")
++arg;
1191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260
if (strcmp(arg, "-platformpluginpath") == 0) {
if (++i < argc)
platformPluginPath = QString::fromLocal8Bit(argv[i]);
} else if (strcmp(arg, "-platform") == 0) {
if (++i < argc)
platformName = argv[i];
} else if (strcmp(arg, "-platformtheme") == 0) {
if (++i < argc)
platformThemeName = QString::fromLocal8Bit(argv[i]);
} else if (strcmp(arg, "-qwindowgeometry") == 0 || (isXcb && strcmp(arg, "-geometry") == 0)) {
if (++i < argc)
windowGeometrySpecification = QWindowGeometrySpecification::fromArgument(argv[i]);
} else if (strcmp(arg, "-qwindowtitle") == 0 || (isXcb && strcmp(arg, "-title") == 0)) {
if (++i < argc)
firstWindowTitle = QString::fromLocal8Bit(argv[i]);
} else if (strcmp(arg, "-qwindowicon") == 0 || (isXcb && strcmp(arg, "-icon") == 0)) {
if (++i < argc) {
icon = QString::fromLocal8Bit(argv[i]);
}
} else {
argv[j++] = argv[i];
}
}
if (j < argc) {
argv[j] = 0;
argc = j;
}
init_platform(QLatin1String(platformName), platformPluginPath, platformThemeName, argc, argv);
if (!icon.isEmpty())
forcedWindowIcon = QDir::isAbsolutePath(icon) ? QIcon(icon) : QIcon::fromTheme(icon);
}
/*!
Called from QCoreApplication::init()
Responsible for creating an event dispatcher when QCoreApplication
decides that it needs one (because a custom one has not been set).
*/
void QGuiApplicationPrivate::createEventDispatcher()
{
Q_ASSERT(!eventDispatcher);
if (platform_integration == 0)
createPlatformIntegration();
// The platform integration should not mess with the event dispatcher
Q_ASSERT(!eventDispatcher);
eventDispatcher = platform_integration->createEventDispatcher();
}
void QGuiApplicationPrivate::eventDispatcherReady()
{
if (platform_integration == 0)
createPlatformIntegration();
platform_integration->initialize();
// All platforms should have added screens at this point. Finish
// QHighDpiScaling initialization if it has not been done so already.
if (!QGuiApplicationPrivate::highDpiScalingUpdated)
QHighDpiScaling::updateHighDpiScaling();
}
void QGuiApplicationPrivate::init()
{
QCoreApplicationPrivate::is_app_running = false; // Starting up.
1261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330
bool loadTestability = false;
QList<QByteArray> pluginList;
// Get command line params
#ifndef QT_NO_SESSIONMANAGER
QString session_id;
QString session_key;
# if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
wchar_t guidstr[40];
GUID guid;
CoCreateGuid(&guid);
StringFromGUID2(guid, guidstr, 40);
session_id = QString::fromWCharArray(guidstr);
CoCreateGuid(&guid);
StringFromGUID2(guid, guidstr, 40);
session_key = QString::fromWCharArray(guidstr);
# endif
#endif
QString s;
int j = argc ? 1 : 0;
for (int i=1; i<argc; i++) {
if (!argv[i])
continue;
if (*argv[i] != '-') {
argv[j++] = argv[i];
continue;
}
const char *arg = argv[i];
if (arg[1] == '-') // startsWith("--")
++arg;
if (strcmp(arg, "-plugin") == 0) {
if (++i < argc)
pluginList << argv[i];
} else if (strcmp(arg, "-reverse") == 0) {
force_reverse = true;
#ifdef Q_OS_MAC
} else if (strncmp(arg, "-psn_", 5) == 0) {
// eat "-psn_xxxx" on Mac, which is passed when starting an app from Finder.
// special hack to change working directory (for an app bundle) when running from finder
if (QDir::currentPath() == QLatin1String("/")) {
QCFType<CFURLRef> bundleURL(CFBundleCopyBundleURL(CFBundleGetMainBundle()));
QString qbundlePath = QCFString(CFURLCopyFileSystemPath(bundleURL,
kCFURLPOSIXPathStyle));
if (qbundlePath.endsWith(QLatin1String(".app")))
QDir::setCurrent(qbundlePath.section(QLatin1Char('/'), 0, -2));
}
#endif
#ifndef QT_NO_SESSIONMANAGER
} else if (strcmp(arg, "-session") == 0 && i < argc - 1) {
++i;
if (argv[i] && *argv[i]) {
session_id = QString::fromLatin1(argv[i]);
int p = session_id.indexOf(QLatin1Char('_'));
if (p >= 0) {
session_key = session_id.mid(p +1);
session_id = session_id.left(p);
}
is_session_restored = true;
}
#endif
} else if (strcmp(arg, "-testability") == 0) {
loadTestability = true;
} else if (strncmp(arg, "-style=", 7) == 0) {
s = QString::fromLocal8Bit(arg + 7).toLower();
} else if (strcmp(arg, "-style") == 0 && i < argc - 1) {
s = QString::fromLocal8Bit(argv[++i]).toLower();
} else {
argv[j++] = argv[i];
}
1331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400
if (!s.isEmpty())
styleOverride = s;
}
if (j < argc) {
argv[j] = 0;
argc = j;
}
// Load environment exported generic plugins
QByteArray envPlugins = qgetenv("QT_QPA_GENERIC_PLUGINS");
if (!envPlugins.isEmpty()) {
foreach (const QByteArray &plugin, envPlugins.split(','))
pluginList << plugin;
}
if (platform_integration == 0)
createPlatformIntegration();
initPalette();
QFont::initialize();
mouse_double_click_distance = platformTheme()->themeHint(QPlatformTheme::MouseDoubleClickDistance).toInt();
#ifndef QT_NO_CURSOR
QCursorData::initialize();
#endif
// trigger registering of QVariant's GUI types
qRegisterGuiVariant();
#ifndef QT_NO_ANIMATION
// trigger registering of animation interpolators
qRegisterGuiGetInterpolator();
#endif
// set a global share context when enabled unless there is already one
#ifndef QT_NO_OPENGL
if (qApp->testAttribute(Qt::AA_ShareOpenGLContexts) && !qt_gl_global_share_context()) {
QOpenGLContext *ctx = new QOpenGLContext;
ctx->setFormat(QSurfaceFormat::defaultFormat());
ctx->create();
qt_gl_set_global_share_context(ctx);
ownGlobalShareContext = true;
}
#endif
QWindowSystemInterfacePrivate::eventTime.start();
is_app_running = true;
init_plugins(pluginList);
QWindowSystemInterface::flushWindowSystemEvents();
#ifndef QT_NO_SESSIONMANAGER
Q_Q(QGuiApplication);
// connect to the session manager
session_manager = new QSessionManager(q, session_id, session_key);
#endif
#ifndef QT_NO_LIBRARY
if (qEnvironmentVariableIntValue("QT_LOAD_TESTABILITY") > 0)
loadTestability = true;
if (loadTestability) {
QLibrary testLib(QStringLiteral("qttestability"));
if (testLib.load()) {
typedef void (*TasInitialize)(void);
TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
if (initFunction) {
1401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470
initFunction();
} else {
qCritical() << "Library qttestability resolve failed!";
}
} else {
qCritical() << "Library qttestability load failed:" << testLib.errorString();
}
}
#else
Q_UNUSED(loadTestability);
#endif // QT_NO_LIBRARY
if (layout_direction == Qt::LayoutDirectionAuto || force_reverse)
QGuiApplication::setLayoutDirection(qt_detectRTLLanguage() ? Qt::RightToLeft : Qt::LeftToRight);
}
extern void qt_cleanupFontDatabase();
QGuiApplicationPrivate::~QGuiApplicationPrivate()
{
is_app_closing = true;
is_app_running = false;
for (int i = 0; i < generic_plugin_list.count(); ++i)
delete generic_plugin_list.at(i);
generic_plugin_list.clear();
clearFontUnlocked();
QFont::cleanup();
#ifndef QT_NO_CURSOR
QCursorData::cleanup();
#endif
layout_direction = Qt::LeftToRight;
cleanupThreadData();
delete QGuiApplicationPrivate::styleHints;
QGuiApplicationPrivate::styleHints = Q_NULLPTR;
delete inputMethod;
qt_cleanupFontDatabase();
QPixmapCache::clear();
#ifndef QT_NO_OPENGL
if (ownGlobalShareContext) {
delete qt_gl_global_share_context();
qt_gl_set_global_share_context(0);
}
#endif
platform_integration->destroy();
delete platform_theme;
platform_theme = 0;
delete platform_integration;
platform_integration = 0;
delete m_gammaTables.load();
window_list.clear();
}
#if 0
#ifndef QT_NO_CURSOR
QCursor *overrideCursor();
void setOverrideCursor(const QCursor &);
void changeOverrideCursor(const QCursor &);
1471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540
void restoreOverrideCursor();
#endif
static QFont font();
static QFont font(const QWidget*);
static QFont font(const char *className);
static void setFont(const QFont &, const char* className = 0);
static QFontMetrics fontMetrics();
#ifndef QT_NO_CLIPBOARD
static QClipboard *clipboard();
#endif
#endif
/*!
Returns the current state of the modifier keys on the keyboard. The current
state is updated sychronously as the event queue is emptied of events that
will spontaneously change the keyboard state (QEvent::KeyPress and
QEvent::KeyRelease events).
It should be noted this may not reflect the actual keys held on the input
device at the time of calling but rather the modifiers as last reported in
one of the above events. If no keys are being held Qt::NoModifier is
returned.
\sa mouseButtons(), queryKeyboardModifiers()
*/
Qt::KeyboardModifiers QGuiApplication::keyboardModifiers()
{
return QGuiApplicationPrivate::modifier_buttons;
}
/*!
\fn Qt::KeyboardModifiers QGuiApplication::queryKeyboardModifiers()
Queries and returns the state of the modifier keys on the keyboard.
Unlike keyboardModifiers, this method returns the actual keys held
on the input device at the time of calling the method.
It does not rely on the keypress events having been received by this
process, which makes it possible to check the modifiers while moving
a window, for instance. Note that in most cases, you should use
keyboardModifiers(), which is faster and more accurate since it contains
the state of the modifiers as they were when the currently processed
event was received.
\sa keyboardModifiers()
*/
Qt::KeyboardModifiers QGuiApplication::queryKeyboardModifiers()
{
CHECK_QAPP_INSTANCE(Qt::KeyboardModifiers(0))
QPlatformIntegration *pi = QGuiApplicationPrivate::platformIntegration();
return pi->queryKeyboardModifiers();
}
/*!
Returns the current state of the buttons on the mouse. The current state is
updated syncronously as the event queue is emptied of events that will
spontaneously change the mouse state (QEvent::MouseButtonPress and
QEvent::MouseButtonRelease events).
It should be noted this may not reflect the actual buttons held on the
input device at the time of calling but rather the mouse buttons as last
reported in one of the above events. If no mouse buttons are being held
Qt::NoButton is returned.
\sa keyboardModifiers()
*/
Qt::MouseButtons QGuiApplication::mouseButtons()
{
1541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610
return QGuiApplicationPrivate::mouse_buttons;
}
/*!
Returns the platform's native interface, for platform specific
functionality.
*/
QPlatformNativeInterface *QGuiApplication::platformNativeInterface()
{
QPlatformIntegration *pi = QGuiApplicationPrivate::platformIntegration();
return pi ? pi->nativeInterface() : 0;
}
/*!
Returns a function pointer from the platformplugin matching \a function
*/
QFunctionPointer QGuiApplication::platformFunction(const QByteArray &function)
{
QPlatformIntegration *pi = QGuiApplicationPrivate::platformIntegration();
if (!pi) {
qWarning() << "QGuiApplication::platformFunction(): Must construct a QGuiApplication before accessing a platform function";
return Q_NULLPTR;
}
return pi->nativeInterface() ? pi->nativeInterface()->platformFunction(function) : Q_NULLPTR;
}
/*!
Enters the main event loop and waits until exit() is called, and then
returns the value that was set to exit() (which is 0 if exit() is called
via quit()).
It is necessary to call this function to start event handling. The main
event loop receives events from the window system and dispatches these to
the application widgets.
Generally, no user interaction can take place before calling exec().
To make your application perform idle processing, e.g., executing a special
function whenever there are no pending events, use a QTimer with 0 timeout.
More advanced idle processing schemes can be achieved using processEvents().
We recommend that you connect clean-up code to the
\l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in your
application's \c{main()} function. This is because, on some platforms, the
QApplication::exec() call may not return.
\sa quitOnLastWindowClosed, quit(), exit(), processEvents(),
QCoreApplication::exec()
*/
int QGuiApplication::exec()
{
#ifndef QT_NO_ACCESSIBILITY
QAccessible::setRootObject(qApp);
#endif
return QCoreApplication::exec();
}
/*! \reimp
*/
bool QGuiApplication::notify(QObject *object, QEvent *event)
{
if (object->isWindowType())
QGuiApplicationPrivate::sendQWindowEventToQPlatformWindow(static_cast<QWindow *>(object), event);
return QCoreApplication::notify(object, event);
}
/*! \reimp
*/
bool QGuiApplication::event(QEvent *e)
1611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680
{
if(e->type() == QEvent::LanguageChange) {
setLayoutDirection(qt_detectRTLLanguage()?Qt::RightToLeft:Qt::LeftToRight);
}
return QCoreApplication::event(e);
}
/*!
\internal
*/
bool QGuiApplication::compressEvent(QEvent *event, QObject *receiver, QPostEventList *postedEvents)
{
return QCoreApplication::compressEvent(event, receiver, postedEvents);
}
void QGuiApplicationPrivate::sendQWindowEventToQPlatformWindow(QWindow *window, QEvent *event)
{
if (!window)
return;
QPlatformWindow *platformWindow = window->handle();
if (!platformWindow)
return;
// spontaneous events come from the platform integration already, we don't need to send the events back
if (event->spontaneous())
return;
// let the platform window do any handling it needs to as well
platformWindow->windowEvent(event);
}
bool QGuiApplicationPrivate::processNativeEvent(QWindow *window, const QByteArray &eventType, void *message, long *result)
{
return window->nativeEvent(eventType, message, result);
}
void QGuiApplicationPrivate::processWindowSystemEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *e)
{
switch(e->type) {
case QWindowSystemInterfacePrivate::FrameStrutMouse:
case QWindowSystemInterfacePrivate::Mouse:
QGuiApplicationPrivate::processMouseEvent(static_cast<QWindowSystemInterfacePrivate::MouseEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Wheel:
QGuiApplicationPrivate::processWheelEvent(static_cast<QWindowSystemInterfacePrivate::WheelEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Key:
QGuiApplicationPrivate::processKeyEvent(static_cast<QWindowSystemInterfacePrivate::KeyEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Touch:
QGuiApplicationPrivate::processTouchEvent(static_cast<QWindowSystemInterfacePrivate::TouchEvent *>(e));
break;
case QWindowSystemInterfacePrivate::GeometryChange:
QGuiApplicationPrivate::processGeometryChangeEvent(static_cast<QWindowSystemInterfacePrivate::GeometryChangeEvent*>(e));
break;
case QWindowSystemInterfacePrivate::Enter:
QGuiApplicationPrivate::processEnterEvent(static_cast<QWindowSystemInterfacePrivate::EnterEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Leave:
QGuiApplicationPrivate::processLeaveEvent(static_cast<QWindowSystemInterfacePrivate::LeaveEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ActivatedWindow:
QGuiApplicationPrivate::processActivatedEvent(static_cast<QWindowSystemInterfacePrivate::ActivatedWindowEvent *>(e));
break;
case QWindowSystemInterfacePrivate::WindowStateChanged:
QGuiApplicationPrivate::processWindowStateChangedEvent(static_cast<QWindowSystemInterfacePrivate::WindowStateChangedEvent *>(e));
break;
case QWindowSystemInterfacePrivate::WindowScreenChanged:
QGuiApplicationPrivate::processWindowScreenChangedEvent(static_cast<QWindowSystemInterfacePrivate::WindowScreenChangedEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ApplicationStateChanged: {
QWindowSystemInterfacePrivate::ApplicationStateChangedEvent * changeEvent = static_cast<QWindowSystemInterfacePrivate::ApplicationStateChangedEvent *>(e);
1681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750
QGuiApplicationPrivate::setApplicationState(changeEvent->newState, changeEvent->forcePropagate); }
break;
case QWindowSystemInterfacePrivate::FlushEvents: {
QWindowSystemInterfacePrivate::FlushEventsEvent *flushEventsEvent = static_cast<QWindowSystemInterfacePrivate::FlushEventsEvent *>(e);
QWindowSystemInterface::deferredFlushWindowSystemEvents(flushEventsEvent->flags); }
break;
case QWindowSystemInterfacePrivate::Close:
QGuiApplicationPrivate::processCloseEvent(
static_cast<QWindowSystemInterfacePrivate::CloseEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ScreenOrientation:
QGuiApplicationPrivate::reportScreenOrientationChange(
static_cast<QWindowSystemInterfacePrivate::ScreenOrientationEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ScreenGeometry:
QGuiApplicationPrivate::reportGeometryChange(
static_cast<QWindowSystemInterfacePrivate::ScreenGeometryEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ScreenLogicalDotsPerInch:
QGuiApplicationPrivate::reportLogicalDotsPerInchChange(
static_cast<QWindowSystemInterfacePrivate::ScreenLogicalDotsPerInchEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ScreenRefreshRate:
QGuiApplicationPrivate::reportRefreshRateChange(
static_cast<QWindowSystemInterfacePrivate::ScreenRefreshRateEvent *>(e));
break;
case QWindowSystemInterfacePrivate::ThemeChange:
QGuiApplicationPrivate::processThemeChanged(
static_cast<QWindowSystemInterfacePrivate::ThemeChangeEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Expose:
QGuiApplicationPrivate::processExposeEvent(static_cast<QWindowSystemInterfacePrivate::ExposeEvent *>(e));
break;
case QWindowSystemInterfacePrivate::Tablet:
QGuiApplicationPrivate::processTabletEvent(
static_cast<QWindowSystemInterfacePrivate::TabletEvent *>(e));
break;
case QWindowSystemInterfacePrivate::TabletEnterProximity:
QGuiApplicationPrivate::processTabletEnterProximityEvent(
static_cast<QWindowSystemInterfacePrivate::TabletEnterProximityEvent *>(e));
break;
case QWindowSystemInterfacePrivate::TabletLeaveProximity:
QGuiApplicationPrivate::processTabletLeaveProximityEvent(
static_cast<QWindowSystemInterfacePrivate::TabletLeaveProximityEvent *>(e));
break;
#ifndef QT_NO_GESTURES
case QWindowSystemInterfacePrivate::Gesture:
QGuiApplicationPrivate::processGestureEvent(
static_cast<QWindowSystemInterfacePrivate::GestureEvent *>(e));
break;
#endif
case QWindowSystemInterfacePrivate::PlatformPanel:
QGuiApplicationPrivate::processPlatformPanelEvent(
static_cast<QWindowSystemInterfacePrivate::PlatformPanelEvent *>(e));
break;
case QWindowSystemInterfacePrivate::FileOpen:
QGuiApplicationPrivate::processFileOpenEvent(
static_cast<QWindowSystemInterfacePrivate::FileOpenEvent *>(e));
break;
#ifndef QT_NO_CONTEXTMENU
case QWindowSystemInterfacePrivate::ContextMenu:
QGuiApplicationPrivate::processContextMenuEvent(
static_cast<QWindowSystemInterfacePrivate::ContextMenuEvent *>(e));
break;
#endif
case QWindowSystemInterfacePrivate::EnterWhatsThisMode:
QGuiApplication::postEvent(QGuiApplication::instance(), new QEvent(QEvent::EnterWhatsThisMode));
break;
default:
qWarning() << "Unknown user input event type:" << e->type;
1751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820
break;
}
}
void QGuiApplicationPrivate::processMouseEvent(QWindowSystemInterfacePrivate::MouseEvent *e)
{
QEvent::Type type;
Qt::MouseButtons stateChange = e->buttons ^ buttons;
if (e->globalPos != QGuiApplicationPrivate::lastCursorPosition && (stateChange != Qt::NoButton)) {
// A mouse event should not change both position and buttons at the same time. Instead we
// should first send a move event followed by a button changed event. Since this is not the case
// with the current event, we split it in two.
QWindowSystemInterfacePrivate::MouseEvent mouseButtonEvent(
e->window.data(), e->timestamp, e->type, e->localPos, e->globalPos, e->buttons, e->modifiers, e->source);
if (e->flags & QWindowSystemInterfacePrivate::WindowSystemEvent::Synthetic)
mouseButtonEvent.flags |= QWindowSystemInterfacePrivate::WindowSystemEvent::Synthetic;
e->buttons = buttons;
processMouseEvent(e);
processMouseEvent(&mouseButtonEvent);
return;
}
QWindow *window = e->window.data();
modifier_buttons = e->modifiers;
QPointF localPoint = e->localPos;
QPointF globalPoint = e->globalPos;
if (e->nullWindow()) {
window = QGuiApplication::topLevelAt(globalPoint.toPoint());
if (window) {
// Moves and the release following a press must go to the same
// window, even if the cursor has moved on over another window.
if (e->buttons != Qt::NoButton) {
if (!currentMousePressWindow)
currentMousePressWindow = window;
else
window = currentMousePressWindow;
} else if (currentMousePressWindow) {
window = currentMousePressWindow;
currentMousePressWindow = 0;
}
QPointF delta = globalPoint - globalPoint.toPoint();
localPoint = window->mapFromGlobal(globalPoint.toPoint()) + delta;
}
}
Qt::MouseButton button = Qt::NoButton;
bool doubleClick = false;
const bool frameStrut = e->type == QWindowSystemInterfacePrivate::FrameStrutMouse;
if (QGuiApplicationPrivate::lastCursorPosition != globalPoint) {
type = frameStrut ? QEvent::NonClientAreaMouseMove : QEvent::MouseMove;
QGuiApplicationPrivate::lastCursorPosition = globalPoint;
if (qAbs(globalPoint.x() - mousePressX) > mouse_double_click_distance||
qAbs(globalPoint.y() - mousePressY) > mouse_double_click_distance)
mousePressButton = Qt::NoButton;
} else { // Check to see if a new button has been pressed/released.
for (int check = Qt::LeftButton;
check <= int(Qt::MaxMouseButton);
check = check << 1) {
if (check & stateChange) {
button = Qt::MouseButton(check);
break;
}
}
if (button == Qt::NoButton) {
// Ignore mouse events that don't change the current state.
return;
}
1821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890
mouse_buttons = buttons = e->buttons;
if (button & e->buttons) {
ulong doubleClickInterval = static_cast<ulong>(QGuiApplication::styleHints()->mouseDoubleClickInterval());
doubleClick = e->timestamp - mousePressTime < doubleClickInterval && button == mousePressButton;
type = frameStrut ? QEvent::NonClientAreaMouseButtonPress : QEvent::MouseButtonPress;
mousePressTime = e->timestamp;
mousePressButton = button;
const QPoint point = QGuiApplicationPrivate::lastCursorPosition.toPoint();
mousePressX = point.x();
mousePressY = point.y();
} else {
type = frameStrut ? QEvent::NonClientAreaMouseButtonRelease : QEvent::MouseButtonRelease;
}
}
if (!window)
return;
#ifndef QT_NO_CURSOR
if (!e->synthetic()) {
if (const QScreen *screen = window->screen())
if (QPlatformCursor *cursor = screen->handle()->cursor()) {
const QPointF nativeLocalPoint = QHighDpi::toNativePixels(localPoint, screen);
const QPointF nativeGlobalPoint = QHighDpi::toNativePixels(globalPoint, screen);
QMouseEvent ev(type, nativeLocalPoint, nativeLocalPoint, nativeGlobalPoint,
button, buttons, e->modifiers, e->source);
ev.setTimestamp(e->timestamp);
cursor->pointerEvent(ev);
}
}
#endif
QMouseEvent ev(type, localPoint, localPoint, globalPoint, button, buttons, e->modifiers, e->source);
ev.setTimestamp(e->timestamp);
if (window->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow mouse events through
return;
}
if (doubleClick && (ev.type() == QEvent::MouseButtonPress)) {
// QtBUG-25831, used to suppress delivery in qwidgetwindow.cpp
setMouseEventFlags(&ev, ev.flags() | Qt::MouseEventCreatedDoubleClick);
}
QGuiApplication::sendSpontaneousEvent(window, &ev);
e->eventAccepted = ev.isAccepted();
if (!e->synthetic() && !ev.isAccepted()
&& !frameStrut
&& qApp->testAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents)) {
if (!m_fakeTouchDevice) {
m_fakeTouchDevice = new QTouchDevice;
QWindowSystemInterface::registerTouchDevice(m_fakeTouchDevice);
}
QList<QWindowSystemInterface::TouchPoint> points;
QWindowSystemInterface::TouchPoint point;
point.id = 1;
point.area = QRectF(globalPoint.x() - 2, globalPoint.y() - 2, 4, 4);
// only translate left button related events to
// avoid strange touch event sequences when several
// buttons are pressed
if (type == QEvent::MouseButtonPress && button == Qt::LeftButton) {
point.state = Qt::TouchPointPressed;
} else if (type == QEvent::MouseButtonRelease && button == Qt::LeftButton) {
point.state = Qt::TouchPointReleased;
} else if (type == QEvent::MouseMove && (buttons & Qt::LeftButton)) {
point.state = Qt::TouchPointMoved;
} else {
return;
1891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960
}
points << point;
QEvent::Type type;
QList<QTouchEvent::TouchPoint> touchPoints = QWindowSystemInterfacePrivate::fromNativeTouchPoints(points, window, &type);
QWindowSystemInterfacePrivate::TouchEvent fake(window, e->timestamp, type, m_fakeTouchDevice, touchPoints, e->modifiers);
fake.flags |= QWindowSystemInterfacePrivate::WindowSystemEvent::Synthetic;
processTouchEvent(&fake);
}
if (doubleClick) {
mousePressButton = Qt::NoButton;
if (!e->window.isNull() || e->nullWindow()) { // QTBUG-36364, check if window closed in response to press
const QEvent::Type doubleClickType = frameStrut ? QEvent::NonClientAreaMouseButtonDblClick : QEvent::MouseButtonDblClick;
QMouseEvent dblClickEvent(doubleClickType, localPoint, localPoint, globalPoint,
button, buttons, e->modifiers, e->source);
dblClickEvent.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(window, &dblClickEvent);
}
}
}
void QGuiApplicationPrivate::processWheelEvent(QWindowSystemInterfacePrivate::WheelEvent *e)
{
#ifndef QT_NO_WHEELEVENT
QWindow *window = e->window.data();
QPointF globalPoint = e->globalPos;
QPointF localPoint = e->localPos;
if (e->nullWindow()) {
window = QGuiApplication::topLevelAt(globalPoint.toPoint());
if (window) {
QPointF delta = globalPoint - globalPoint.toPoint();
localPoint = window->mapFromGlobal(globalPoint.toPoint()) + delta;
}
}
if (!window)
return;
QGuiApplicationPrivate::lastCursorPosition = globalPoint;
modifier_buttons = e->modifiers;
if (window->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow wheel events through
return;
}
QWheelEvent ev(localPoint, globalPoint, e->pixelDelta, e->angleDelta, e->qt4Delta, e->qt4Orientation, buttons, e->modifiers, e->phase, e->source);
ev.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(window, &ev);
#endif /* ifndef QT_NO_WHEELEVENT */
}
// Remember, Qt convention is: keyboard state is state *before*
void QGuiApplicationPrivate::processKeyEvent(QWindowSystemInterfacePrivate::KeyEvent *e)
{
QWindow *window = e->window.data();
modifier_buttons = e->modifiers;
if (e->nullWindow()
#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_NO_SDK)
|| e->key == Qt::Key_Back || e->key == Qt::Key_Menu
#endif
) {
window = QGuiApplication::focusWindow();
}
#if !defined(Q_OS_OSX)
1961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030
// FIXME: Include OS X in this code path by passing the key event through
// QPlatformInputContext::filterEvent().
if (e->keyType == QEvent::KeyPress && window) {
if (QWindowSystemInterface::handleShortcutEvent(window, e->timestamp, e->key, e->modifiers,
e->nativeScanCode, e->nativeVirtualKey, e->nativeModifiers, e->unicode, e->repeat, e->repeatCount))
return;
}
#endif
QKeyEvent ev(e->keyType, e->key, e->modifiers,
e->nativeScanCode, e->nativeVirtualKey, e->nativeModifiers,
e->unicode, e->repeat, e->repeatCount);
ev.setTimestamp(e->timestamp);
// only deliver key events when we have a window, and no modal window is blocking this window
if (window && !window->d_func()->blockedByModalWindow)
QGuiApplication::sendSpontaneousEvent(window, &ev);
#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_NO_SDK)
else
ev.setAccepted(false);
static bool backKeyPressAccepted = false;
static bool menuKeyPressAccepted = false;
if (e->keyType == QEvent::KeyPress) {
backKeyPressAccepted = e->key == Qt::Key_Back && ev.isAccepted();
menuKeyPressAccepted = e->key == Qt::Key_Menu && ev.isAccepted();
} else if (e->keyType == QEvent::KeyRelease) {
if (e->key == Qt::Key_Back && !backKeyPressAccepted && !ev.isAccepted()) {
if (window)
QWindowSystemInterface::handleCloseEvent(window);
} else if (e->key == Qt::Key_Menu && !menuKeyPressAccepted && !ev.isAccepted()) {
platform_theme->showPlatformMenuBar();
}
}
#endif
e->eventAccepted = ev.isAccepted();
}
void QGuiApplicationPrivate::processEnterEvent(QWindowSystemInterfacePrivate::EnterEvent *e)
{
if (!e->enter)
return;
if (e->enter.data()->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow enter events through
return;
}
currentMouseWindow = e->enter;
QEnterEvent event(e->localPos, e->localPos, e->globalPos);
QCoreApplication::sendSpontaneousEvent(e->enter.data(), &event);
}
void QGuiApplicationPrivate::processLeaveEvent(QWindowSystemInterfacePrivate::LeaveEvent *e)
{
if (!e->leave)
return;
if (e->leave.data()->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow leave events through
return;
}
currentMouseWindow = 0;
QEvent event(QEvent::Leave);
QCoreApplication::sendSpontaneousEvent(e->leave.data(), &event);
}
void QGuiApplicationPrivate::processActivatedEvent(QWindowSystemInterfacePrivate::ActivatedWindowEvent *e)
2031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100
{
QWindow *previous = QGuiApplicationPrivate::focus_window;
QWindow *newFocus = e->activated.data();
if (previous == newFocus)
return;
if (newFocus)
if (QPlatformWindow *platformWindow = newFocus->handle())
if (platformWindow->isAlertState())
platformWindow->setAlertState(false);
QObject *previousFocusObject = previous ? previous->focusObject() : 0;
if (previous) {
QFocusEvent focusAboutToChange(QEvent::FocusAboutToChange);
QCoreApplication::sendSpontaneousEvent(previous, &focusAboutToChange);
}
QGuiApplicationPrivate::focus_window = newFocus;
if (!qApp)
return;
if (previous) {
Qt::FocusReason r = e->reason;
if ((r == Qt::OtherFocusReason || r == Qt::ActiveWindowFocusReason) &&
newFocus && (newFocus->flags() & Qt::Popup) == Qt::Popup)
r = Qt::PopupFocusReason;
QFocusEvent focusOut(QEvent::FocusOut, r);
QCoreApplication::sendSpontaneousEvent(previous, &focusOut);
QObject::disconnect(previous, SIGNAL(focusObjectChanged(QObject*)),
qApp, SLOT(_q_updateFocusObject(QObject*)));
} else if (!platformIntegration()->hasCapability(QPlatformIntegration::ApplicationState)) {
setApplicationState(Qt::ApplicationActive);
}
if (QGuiApplicationPrivate::focus_window) {
Qt::FocusReason r = e->reason;
if ((r == Qt::OtherFocusReason || r == Qt::ActiveWindowFocusReason) &&
previous && (previous->flags() & Qt::Popup) == Qt::Popup)
r = Qt::PopupFocusReason;
QFocusEvent focusIn(QEvent::FocusIn, r);
QCoreApplication::sendSpontaneousEvent(QGuiApplicationPrivate::focus_window, &focusIn);
QObject::connect(QGuiApplicationPrivate::focus_window, SIGNAL(focusObjectChanged(QObject*)),
qApp, SLOT(_q_updateFocusObject(QObject*)));
} else if (!platformIntegration()->hasCapability(QPlatformIntegration::ApplicationState)) {
setApplicationState(Qt::ApplicationInactive);
}
if (self) {
self->notifyActiveWindowChange(previous);
if (previousFocusObject != qApp->focusObject())
self->_q_updateFocusObject(qApp->focusObject());
}
emit qApp->focusWindowChanged(newFocus);
if (previous)
emit previous->activeChanged();
if (newFocus)
emit newFocus->activeChanged();
}
void QGuiApplicationPrivate::processWindowStateChangedEvent(QWindowSystemInterfacePrivate::WindowStateChangedEvent *wse)
{
if (QWindow *window = wse->window.data()) {
QWindowStateChangeEvent e(window->windowState());
window->d_func()->windowState = wse->newState;
QGuiApplication::sendSpontaneousEvent(window, &e);
}
2101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170
}
void QGuiApplicationPrivate::processWindowScreenChangedEvent(QWindowSystemInterfacePrivate::WindowScreenChangedEvent *wse)
{
if (QWindow *window = wse->window.data()) {
if (window->isTopLevel()) {
if (QScreen *screen = wse->screen.data())
window->d_func()->setTopLevelScreen(screen, false /* recreate */);
else // Fall back to default behavior, and try to find some appropriate screen
window->setScreen(0);
}
// we may have changed scaling, so trigger resize event if needed
if (window->handle()) {
QWindowSystemInterfacePrivate::GeometryChangeEvent gce(window, QHighDpi::fromNativePixels(window->handle()->geometry(), window), QRect());
processGeometryChangeEvent(&gce);
}
}
}
void QGuiApplicationPrivate::processThemeChanged(QWindowSystemInterfacePrivate::ThemeChangeEvent *tce)
{
if (self)
self->notifyThemeChanged();
if (QWindow *window = tce->window.data()) {
QEvent e(QEvent::ThemeChange);
QGuiApplication::sendSpontaneousEvent(window, &e);
}
}
void QGuiApplicationPrivate::processGeometryChangeEvent(QWindowSystemInterfacePrivate::GeometryChangeEvent *e)
{
if (e->tlw.isNull())
return;
QWindow *window = e->tlw.data();
if (!window)
return;
QRect newRect = e->newGeometry;
QRect oldRect = e->oldGeometry.isNull() ? window->d_func()->geometry : e->oldGeometry;
bool isResize = oldRect.size() != newRect.size();
bool isMove = oldRect.topLeft() != newRect.topLeft();
window->d_func()->geometry = newRect;
if (isResize || window->d_func()->resizeEventPending) {
QResizeEvent e(newRect.size(), oldRect.size());
QGuiApplication::sendSpontaneousEvent(window, &e);
window->d_func()->resizeEventPending = false;
if (oldRect.width() != newRect.width())
window->widthChanged(newRect.width());
if (oldRect.height() != newRect.height())
window->heightChanged(newRect.height());
}
if (isMove) {
//### frame geometry
QMoveEvent e(newRect.topLeft(), oldRect.topLeft());
QGuiApplication::sendSpontaneousEvent(window, &e);
if (oldRect.x() != newRect.x())
window->xChanged(newRect.x());
if (oldRect.y() != newRect.y())
window->yChanged(newRect.y());
}
}
2171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240
void QGuiApplicationPrivate::processCloseEvent(QWindowSystemInterfacePrivate::CloseEvent *e)
{
if (e->window.isNull())
return;
if (e->window.data()->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow close events through
return;
}
QCloseEvent event;
QGuiApplication::sendSpontaneousEvent(e->window.data(), &event);
if (e->accepted) {
*(e->accepted) = event.isAccepted();
}
}
void QGuiApplicationPrivate::processFileOpenEvent(QWindowSystemInterfacePrivate::FileOpenEvent *e)
{
if (e->url.isEmpty())
return;
QFileOpenEvent event(e->url);
QGuiApplication::sendSpontaneousEvent(qApp, &event);
}
void QGuiApplicationPrivate::processTabletEvent(QWindowSystemInterfacePrivate::TabletEvent *e)
{
#ifndef QT_NO_TABLETEVENT
QEvent::Type type = QEvent::TabletMove;
if (e->buttons != tabletState)
type = (e->buttons > tabletState) ? QEvent::TabletPress : QEvent::TabletRelease;
QWindow *window = e->window.data();
modifier_buttons = e->modifiers;
bool localValid = true;
// If window is null, pick one based on the global position and make sure all
// subsequent events up to the release are delivered to that same window.
// If window is given, just send to that.
if (type == QEvent::TabletPress) {
if (e->nullWindow()) {
window = QGuiApplication::topLevelAt(e->global.toPoint());
localValid = false;
}
if (!window)
return;
tabletPressTarget = window;
} else {
if (e->nullWindow()) {
window = tabletPressTarget;
localValid = false;
}
if (type == QEvent::TabletRelease)
tabletPressTarget = 0;
if (!window)
return;
}
QPointF local = e->local;
if (!localValid) {
QPointF delta = e->global - e->global.toPoint();
local = window->mapFromGlobal(e->global.toPoint()) + delta;
}
Qt::MouseButtons stateChange = e->buttons ^ tabletState;
Qt::MouseButton button = Qt::NoButton;
for (int check = Qt::LeftButton; check <= int(Qt::MaxMouseButton); check = check << 1) {
if (check & stateChange) {
button = Qt::MouseButton(check);
break;
}
}
2241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310
QTabletEvent ev(type, local, e->global,
e->device, e->pointerType, e->pressure, e->xTilt, e->yTilt,
e->tangentialPressure, e->rotation, e->z,
e->modifiers, e->uid, button, e->buttons);
ev.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(window, &ev);
tabletState = e->buttons;
#else
Q_UNUSED(e)
#endif
}
void QGuiApplicationPrivate::processTabletEnterProximityEvent(QWindowSystemInterfacePrivate::TabletEnterProximityEvent *e)
{
#ifndef QT_NO_TABLETEVENT
QTabletEvent ev(QEvent::TabletEnterProximity, QPointF(), QPointF(),
e->device, e->pointerType, 0, 0, 0,
0, 0, 0,
Qt::NoModifier, e->uid, Qt::NoButton, tabletState);
ev.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(qGuiApp, &ev);
#else
Q_UNUSED(e)
#endif
}
void QGuiApplicationPrivate::processTabletLeaveProximityEvent(QWindowSystemInterfacePrivate::TabletLeaveProximityEvent *e)
{
#ifndef QT_NO_TABLETEVENT
QTabletEvent ev(QEvent::TabletLeaveProximity, QPointF(), QPointF(),
e->device, e->pointerType, 0, 0, 0,
0, 0, 0,
Qt::NoModifier, e->uid, Qt::NoButton, tabletState);
ev.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(qGuiApp, &ev);
#else
Q_UNUSED(e)
#endif
}
#ifndef QT_NO_GESTURES
void QGuiApplicationPrivate::processGestureEvent(QWindowSystemInterfacePrivate::GestureEvent *e)
{
if (e->window.isNull())
return;
QNativeGestureEvent ev(e->type, e->pos, e->pos, e->globalPos, e->realValue, e->sequenceId, e->intValue);
ev.setTimestamp(e->timestamp);
QGuiApplication::sendSpontaneousEvent(e->window, &ev);
}
#endif // QT_NO_GESTURES
void QGuiApplicationPrivate::processPlatformPanelEvent(QWindowSystemInterfacePrivate::PlatformPanelEvent *e)
{
if (!e->window)
return;
if (e->window->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow events through
return;
}
QEvent ev(QEvent::PlatformPanel);
QGuiApplication::sendSpontaneousEvent(e->window.data(), &ev);
}
#ifndef QT_NO_CONTEXTMENU
void QGuiApplicationPrivate::processContextMenuEvent(QWindowSystemInterfacePrivate::ContextMenuEvent *e)
{
// Widgets do not care about mouse triggered context menu events. Also, do not forward event
2311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380
// to a window blocked by a modal window.
if (!e->window || e->mouseTriggered || e->window->d_func()->blockedByModalWindow)
return;
QContextMenuEvent ev(QContextMenuEvent::Keyboard, e->pos, e->globalPos, e->modifiers);
QGuiApplication::sendSpontaneousEvent(e->window.data(), &ev);
}
#endif
Q_GUI_EXPORT uint qHash(const QGuiApplicationPrivate::ActiveTouchPointsKey &k)
{
return qHash(k.device) + k.touchPointId;
}
Q_GUI_EXPORT bool operator==(const QGuiApplicationPrivate::ActiveTouchPointsKey &a,
const QGuiApplicationPrivate::ActiveTouchPointsKey &b)
{
return a.device == b.device
&& a.touchPointId == b.touchPointId;
}
void QGuiApplicationPrivate::processTouchEvent(QWindowSystemInterfacePrivate::TouchEvent *e)
{
QGuiApplicationPrivate *d = self;
modifier_buttons = e->modifiers;
if (e->touchType == QEvent::TouchCancel) {
// The touch sequence has been canceled (e.g. by the compositor).
// Send the TouchCancel to all windows with active touches and clean up.
QTouchEvent touchEvent(QEvent::TouchCancel, e->device, e->modifiers);
touchEvent.setTimestamp(e->timestamp);
QHash<ActiveTouchPointsKey, ActiveTouchPointsValue>::const_iterator it
= self->activeTouchPoints.constBegin(), ite = self->activeTouchPoints.constEnd();
QSet<QWindow *> windowsNeedingCancel;
while (it != ite) {
QWindow *w = it->window.data();
if (w)
windowsNeedingCancel.insert(w);
++it;
}
for (QSet<QWindow *>::const_iterator winIt = windowsNeedingCancel.constBegin(),
winItEnd = windowsNeedingCancel.constEnd(); winIt != winItEnd; ++winIt) {
touchEvent.setWindow(*winIt);
QGuiApplication::sendSpontaneousEvent(*winIt, &touchEvent);
}
if (!self->synthesizedMousePoints.isEmpty() && !e->synthetic()) {
for (QHash<QWindow *, SynthesizedMouseData>::const_iterator synthIt = self->synthesizedMousePoints.constBegin(),
synthItEnd = self->synthesizedMousePoints.constEnd(); synthIt != synthItEnd; ++synthIt) {
if (!synthIt->window)
continue;
QWindowSystemInterfacePrivate::MouseEvent fake(synthIt->window.data(),
e->timestamp,
synthIt->pos,
synthIt->screenPos,
buttons & ~Qt::LeftButton,
e->modifiers,
Qt::MouseEventSynthesizedByQt);
fake.flags |= QWindowSystemInterfacePrivate::WindowSystemEvent::Synthetic;
processMouseEvent(&fake);
}
self->synthesizedMousePoints.clear();
}
self->activeTouchPoints.clear();
self->lastTouchType = e->touchType;
return;
}
// Prevent sending ill-formed event sequences: Cancel can only be followed by a Begin.
if (self->lastTouchType == QEvent::TouchCancel && e->touchType != QEvent::TouchBegin)
return;
2381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450
self->lastTouchType = e->touchType;
QWindow *window = e->window.data();
typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints;
QHash<QWindow *, StatesAndTouchPoints> windowsNeedingEvents;
for (int i = 0; i < e->points.count(); ++i) {
QTouchEvent::TouchPoint touchPoint = e->points.at(i);
// explicitly detach from the original touch point that we got, so even
// if the touchpoint structs are reused, we will make a copy that we'll
// deliver to the user (which might want to store the struct for later use).
touchPoint.d = touchPoint.d->detach();
// update state
QPointer<QWindow> w;
QTouchEvent::TouchPoint previousTouchPoint;
ActiveTouchPointsKey touchInfoKey(e->device, touchPoint.id());
ActiveTouchPointsValue &touchInfo = d->activeTouchPoints[touchInfoKey];
switch (touchPoint.state()) {
case Qt::TouchPointPressed:
if (e->device->type() == QTouchDevice::TouchPad) {
// on touch-pads, send all touch points to the same widget
w = d->activeTouchPoints.isEmpty()
? QPointer<QWindow>()
: d->activeTouchPoints.constBegin().value().window;
}
if (!w) {
// determine which window this event will go to
if (!window)
window = QGuiApplication::topLevelAt(touchPoint.screenPos().toPoint());
if (!window)
continue;
w = window;
}
touchInfo.window = w;
touchPoint.d->startScreenPos = touchPoint.screenPos();
touchPoint.d->lastScreenPos = touchPoint.screenPos();
touchPoint.d->startNormalizedPos = touchPoint.normalizedPos();
touchPoint.d->lastNormalizedPos = touchPoint.normalizedPos();
if (touchPoint.pressure() < qreal(0.))
touchPoint.d->pressure = qreal(1.);
touchInfo.touchPoint = touchPoint;
break;
case Qt::TouchPointReleased:
w = touchInfo.window;
if (!w)
continue;
previousTouchPoint = touchInfo.touchPoint;
touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
touchPoint.d->startPos = previousTouchPoint.startPos();
touchPoint.d->lastPos = previousTouchPoint.pos();
touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
if (touchPoint.pressure() < qreal(0.))
touchPoint.d->pressure = qreal(0.);
break;
default:
w = touchInfo.window;
if (!w)
continue;
2451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520
previousTouchPoint = touchInfo.touchPoint;
touchPoint.d->startScreenPos = previousTouchPoint.startScreenPos();
touchPoint.d->lastScreenPos = previousTouchPoint.screenPos();
touchPoint.d->startPos = previousTouchPoint.startPos();
touchPoint.d->lastPos = previousTouchPoint.pos();
touchPoint.d->startNormalizedPos = previousTouchPoint.startNormalizedPos();
touchPoint.d->lastNormalizedPos = previousTouchPoint.normalizedPos();
if (touchPoint.pressure() < qreal(0.))
touchPoint.d->pressure = qreal(1.);
// Stationary points might not be delivered down to the receiving item
// and get their position transformed, keep the old values instead.
if (touchPoint.state() != Qt::TouchPointStationary)
touchInfo.touchPoint = touchPoint;
break;
}
Q_ASSERT(w.data() != 0);
// make the *scene* functions return the same as the *screen* functions
touchPoint.d->sceneRect = touchPoint.screenRect();
touchPoint.d->startScenePos = touchPoint.startScreenPos();
touchPoint.d->lastScenePos = touchPoint.lastScreenPos();
StatesAndTouchPoints &maskAndPoints = windowsNeedingEvents[w.data()];
maskAndPoints.first |= touchPoint.state();
maskAndPoints.second.append(touchPoint);
}
if (windowsNeedingEvents.isEmpty())
return;
QHash<QWindow *, StatesAndTouchPoints>::ConstIterator it = windowsNeedingEvents.constBegin();
const QHash<QWindow *, StatesAndTouchPoints>::ConstIterator end = windowsNeedingEvents.constEnd();
for (; it != end; ++it) {
QWindow *w = it.key();
QEvent::Type eventType;
switch (it.value().first) {
case Qt::TouchPointPressed:
eventType = QEvent::TouchBegin;
break;
case Qt::TouchPointReleased:
eventType = QEvent::TouchEnd;
break;
case Qt::TouchPointStationary:
// don't send the event if nothing changed
continue;
default:
eventType = QEvent::TouchUpdate;
break;
}
if (w->d_func()->blockedByModalWindow) {
// a modal window is blocking this window, don't allow touch events through
// QTBUG-37371 temporary fix; TODO: revisit in 5.4 when we have a forwarding solution
if (eventType == QEvent::TouchEnd) {
// but don't leave dangling state: e.g.
// QQuickWindowPrivate::itemForTouchPointId needs to be cleared.
QTouchEvent touchEvent(QEvent::TouchCancel,
e->device,
e->modifiers);
touchEvent.setTimestamp(e->timestamp);
touchEvent.setWindow(w);
QGuiApplication::sendSpontaneousEvent(w, &touchEvent);
}
continue;
}
2521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590
QTouchEvent touchEvent(eventType,
e->device,
e->modifiers,
it.value().first,
it.value().second);
touchEvent.setTimestamp(e->timestamp);
touchEvent.setWindow(w);
const int pointCount = touchEvent.touchPoints().count();
for (int i = 0; i < pointCount; ++i) {
QTouchEvent::TouchPoint &touchPoint = touchEvent._touchPoints[i];
// preserve the sub-pixel resolution
QRectF rect = touchPoint.screenRect();
const QPointF screenPos = rect.center();
const QPointF delta = screenPos - screenPos.toPoint();
rect.moveCenter(w->mapFromGlobal(screenPos.toPoint()) + delta);
touchPoint.d->rect = rect;
if (touchPoint.state() == Qt::TouchPointPressed) {
touchPoint.d->startPos = w->mapFromGlobal(touchPoint.startScreenPos().toPoint()) + delta;
touchPoint.d->lastPos = w->mapFromGlobal(touchPoint.lastScreenPos().toPoint()) + delta;
}
}
QGuiApplication::sendSpontaneousEvent(w, &touchEvent);
if (!e->synthetic() && !touchEvent.isAccepted() && qApp->testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents)) {
// exclude devices which generate their own mouse events
if (!(touchEvent.device()->capabilities() & QTouchDevice::MouseEmulation)) {
Qt::MouseButtons b = eventType == QEvent::TouchEnd ? Qt::NoButton : Qt::LeftButton;
if (b == Qt::NoButton)
self->synthesizedMousePoints.clear();
QList<QTouchEvent::TouchPoint> touchPoints = touchEvent.touchPoints();
if (eventType == QEvent::TouchBegin)
m_fakeMouseSourcePointId = touchPoints.first().id();
for (int i = 0; i < touchPoints.count(); ++i) {
const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
if (touchPoint.id() == m_fakeMouseSourcePointId) {
if (b != Qt::NoButton)
self->synthesizedMousePoints.insert(w, SynthesizedMouseData(
touchPoint.pos(), touchPoint.screenPos(), w));
QWindowSystemInterfacePrivate::MouseEvent fake(w, e->timestamp,
touchPoint.pos(),
touchPoint.screenPos(),
b | (buttons & ~Qt::LeftButton),
e->modifiers,
Qt::MouseEventSynthesizedByQt);
fake.flags |= QWindowSystemInterfacePrivate::WindowSystemEvent::Synthetic;
processMouseEvent(&fake);
break;
}
}
}
}
}
// Remove released points from the hash table only after the event is
// delivered. When the receiver is a widget, QApplication will access
// activeTouchPoints during delivery and therefore nothing can be removed
// before sending the event.
for (int i = 0; i < e->points.count(); ++i) {
QTouchEvent::TouchPoint touchPoint = e->points.at(i);
if (touchPoint.state() == Qt::TouchPointReleased)
d->activeTouchPoints.remove(ActiveTouchPointsKey(e->device, touchPoint.id()));
}
}
void QGuiApplicationPrivate::reportScreenOrientationChange(QWindowSystemInterfacePrivate::ScreenOrientationEvent *e)
2591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660
{
// This operation only makes sense after the QGuiApplication constructor runs
if (QCoreApplication::startingUp())
return;
if (!e->screen)
return;
QScreen *s = e->screen.data();
s->d_func()->orientation = e->orientation;
updateFilteredScreenOrientation(s);
}
void QGuiApplicationPrivate::updateFilteredScreenOrientation(QScreen *s)
{
Qt::ScreenOrientation o = s->d_func()->orientation;
if (o == Qt::PrimaryOrientation)
o = s->primaryOrientation();
o = Qt::ScreenOrientation(o & s->orientationUpdateMask());
if (o == Qt::PrimaryOrientation)
return;
if (o == s->d_func()->filteredOrientation)
return;
s->d_func()->filteredOrientation = o;
reportScreenOrientationChange(s);
}
void QGuiApplicationPrivate::reportScreenOrientationChange(QScreen *s)
{
emit s->orientationChanged(s->orientation());
QScreenOrientationChangeEvent event(s, s->orientation());
QCoreApplication::sendEvent(QCoreApplication::instance(), &event);
}
void QGuiApplicationPrivate::reportGeometryChange(QWindowSystemInterfacePrivate::ScreenGeometryEvent *e)
{
// This operation only makes sense after the QGuiApplication constructor runs
if (QCoreApplication::startingUp())
return;
if (!e->screen)
return;
QScreen *s = e->screen.data();
bool geometryChanged = e->geometry != s->d_func()->geometry;
s->d_func()->geometry = e->geometry;
bool availableGeometryChanged = e->availableGeometry != s->d_func()->availableGeometry;
s->d_func()->availableGeometry = e->availableGeometry;
if (geometryChanged) {
Qt::ScreenOrientation primaryOrientation = s->primaryOrientation();
s->d_func()->updatePrimaryOrientation();
emit s->geometryChanged(s->geometry());
emit s->physicalSizeChanged(s->physicalSize());
emit s->physicalDotsPerInchChanged(s->physicalDotsPerInch());
emit s->logicalDotsPerInchChanged(s->logicalDotsPerInch());
if (s->primaryOrientation() != primaryOrientation)
emit s->primaryOrientationChanged(s->primaryOrientation());
if (s->d_func()->orientation == Qt::PrimaryOrientation)
updateFilteredScreenOrientation(s);
}
if (availableGeometryChanged)
2661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730
emit s->availableGeometryChanged(s->availableGeometry());
if (geometryChanged || availableGeometryChanged) {
foreach (QScreen* sibling, s->virtualSiblings())
emit sibling->virtualGeometryChanged(sibling->virtualGeometry());
}
}
void QGuiApplicationPrivate::reportLogicalDotsPerInchChange(QWindowSystemInterfacePrivate::ScreenLogicalDotsPerInchEvent *e)
{
// This operation only makes sense after the QGuiApplication constructor runs
if (QCoreApplication::startingUp())
return;
if (!e->screen)
return;
QScreen *s = e->screen.data();
s->d_func()->logicalDpi = QDpi(e->dpiX, e->dpiY);
emit s->logicalDotsPerInchChanged(s->logicalDotsPerInch());
}
void QGuiApplicationPrivate::reportRefreshRateChange(QWindowSystemInterfacePrivate::ScreenRefreshRateEvent *e)
{
// This operation only makes sense after the QGuiApplication constructor runs
if (QCoreApplication::startingUp())
return;
if (!e->screen)
return;
QScreen *s = e->screen.data();
qreal rate = e->rate;
// safeguard ourselves against buggy platform behavior...
if (rate < 1.0)
rate = 60.0;
if (!qFuzzyCompare(s->d_func()->refreshRate, rate)) {
s->d_func()->refreshRate = rate;
emit s->refreshRateChanged(s->refreshRate());
}
}
void QGuiApplicationPrivate::processExposeEvent(QWindowSystemInterfacePrivate::ExposeEvent *e)
{
if (!e->exposed)
return;
QWindow *window = e->exposed.data();
if (!window)
return;
QWindowPrivate *p = qt_window_private(window);
if (!p->receivedExpose) {
if (p->resizeEventPending) {
// as a convenience for plugins, send a resize event before the first expose event if they haven't done so
// window->geometry() should have a valid size as soon as a handle exists.
QResizeEvent e(window->geometry().size(), p->geometry.size());
QGuiApplication::sendSpontaneousEvent(window, &e);
p->resizeEventPending = false;
}
p->receivedExpose = true;
}
p->exposed = e->isExposed && window->screen();
QExposeEvent exposeEvent(e->region);
QCoreApplication::sendSpontaneousEvent(window, &exposeEvent);
2731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800
}
#ifndef QT_NO_DRAGANDDROP
QPlatformDragQtResponse QGuiApplicationPrivate::processDrag(QWindow *w, const QMimeData *dropData, const QPoint &p, Qt::DropActions supportedActions)
{
static QPointer<QWindow> currentDragWindow;
static Qt::DropAction lastAcceptedDropAction = Qt::IgnoreAction;
QPlatformDrag *platformDrag = platformIntegration()->drag();
if (!platformDrag) {
lastAcceptedDropAction = Qt::IgnoreAction;
return QPlatformDragQtResponse(false, lastAcceptedDropAction, QRect());
}
if (!dropData) {
if (currentDragWindow.data() == w)
currentDragWindow = 0;
QDragLeaveEvent e;
QGuiApplication::sendEvent(w, &e);
lastAcceptedDropAction = Qt::IgnoreAction;
return QPlatformDragQtResponse(false, lastAcceptedDropAction, QRect());
}
QDragMoveEvent me(p, supportedActions, dropData,
QGuiApplication::mouseButtons(), QGuiApplication::keyboardModifiers());
if (w != currentDragWindow) {
lastAcceptedDropAction = Qt::IgnoreAction;
if (currentDragWindow) {
QDragLeaveEvent e;
QGuiApplication::sendEvent(currentDragWindow, &e);
}
currentDragWindow = w;
QDragEnterEvent e(p, supportedActions, dropData,
QGuiApplication::mouseButtons(), QGuiApplication::keyboardModifiers());
QGuiApplication::sendEvent(w, &e);
if (e.isAccepted() && e.dropAction() != Qt::IgnoreAction)
lastAcceptedDropAction = e.dropAction();
}
// Handling 'DragEnter' should suffice for the application.
if (lastAcceptedDropAction != Qt::IgnoreAction
&& (supportedActions & lastAcceptedDropAction)) {
me.setDropAction(lastAcceptedDropAction);
me.accept();
}
QGuiApplication::sendEvent(w, &me);
lastAcceptedDropAction = me.isAccepted() ?
me.dropAction() : Qt::IgnoreAction;
return QPlatformDragQtResponse(me.isAccepted(), lastAcceptedDropAction, me.answerRect());
}
QPlatformDropQtResponse QGuiApplicationPrivate::processDrop(QWindow *w, const QMimeData *dropData, const QPoint &p, Qt::DropActions supportedActions)
{
QDropEvent de(p, supportedActions, dropData,
QGuiApplication::mouseButtons(), QGuiApplication::keyboardModifiers());
QGuiApplication::sendEvent(w, &de);
Qt::DropAction acceptedAction = de.isAccepted() ? de.dropAction() : Qt::IgnoreAction;
QPlatformDropQtResponse response(de.isAccepted(),acceptedAction);
return response;
}
#endif // QT_NO_DRAGANDDROP
#ifndef QT_NO_CLIPBOARD
/*!
Returns the object for interacting with the clipboard.
*/
QClipboard * QGuiApplication::clipboard()
{
2801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870
if (QGuiApplicationPrivate::qt_clipboard == 0) {
if (!qApp) {
qWarning("QGuiApplication: Must construct a QGuiApplication before accessing a QClipboard");
return 0;
}
QGuiApplicationPrivate::qt_clipboard = new QClipboard(0);
}
return QGuiApplicationPrivate::qt_clipboard;
}
#endif
/*!
\since 5.4
\fn void QGuiApplication::paletteChanged(const QPalette &palette)
This signal is emitted when the \a palette of the application changes.
\sa palette()
*/
/*!
Returns the default application palette.
\sa setPalette()
*/
QPalette QGuiApplication::palette()
{
initPalette();
return *QGuiApplicationPrivate::app_pal;
}
/*!
Changes the default application palette to \a pal.
\sa palette()
*/
void QGuiApplication::setPalette(const QPalette &pal)
{
if (QGuiApplicationPrivate::app_pal && pal.isCopyOf(*QGuiApplicationPrivate::app_pal))
return;
if (!QGuiApplicationPrivate::app_pal)
QGuiApplicationPrivate::app_pal = new QPalette(pal);
else
*QGuiApplicationPrivate::app_pal = pal;
applicationResourceFlags |= ApplicationPaletteExplicitlySet;
QCoreApplication::setAttribute(Qt::AA_SetPalette);
emit qGuiApp->paletteChanged(*QGuiApplicationPrivate::app_pal);
}
void QGuiApplicationPrivate::applyWindowGeometrySpecificationTo(QWindow *window)
{
windowGeometrySpecification.applyTo(window);
}
/*!
Returns the default application font.
\sa setFont()
*/
QFont QGuiApplication::font()
{
Q_ASSERT_X(QGuiApplicationPrivate::self, "QGuiApplication::font()", "no QGuiApplication instance");
QMutexLocker locker(&applicationFontMutex);
initFontUnlocked();
return *QGuiApplicationPrivate::app_font;
}
/*!
Changes the default application font to \a font.
2871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940
\sa font()
*/
void QGuiApplication::setFont(const QFont &font)
{
QMutexLocker locker(&applicationFontMutex);
if (!QGuiApplicationPrivate::app_font)
QGuiApplicationPrivate::app_font = new QFont(font);
else
*QGuiApplicationPrivate::app_font = font;
applicationResourceFlags |= ApplicationFontExplicitlySet;
}
/*!
\fn bool QGuiApplication::isRightToLeft()
Returns \c true if the application's layout direction is
Qt::RightToLeft; otherwise returns \c false.
\sa layoutDirection(), isLeftToRight()
*/
/*!
\fn bool QGuiApplication::isLeftToRight()
Returns \c true if the application's layout direction is
Qt::LeftToRight; otherwise returns \c false.
\sa layoutDirection(), isRightToLeft()
*/
void QGuiApplicationPrivate::notifyLayoutDirectionChange()
{
const QWindowList list = QGuiApplication::topLevelWindows();
for (int i = 0; i < list.size(); ++i) {
QEvent ev(QEvent::ApplicationLayoutDirectionChange);
QCoreApplication::sendEvent(list.at(i), &ev);
}
}
void QGuiApplicationPrivate::notifyActiveWindowChange(QWindow *)
{
}
/*!
\property QGuiApplication::windowIcon
\brief the default window icon
\sa QWindow::setIcon(), {Setting the Application Icon}
*/
QIcon QGuiApplication::windowIcon()
{
return QGuiApplicationPrivate::app_icon ? *QGuiApplicationPrivate::app_icon : QIcon();
}
void QGuiApplication::setWindowIcon(const QIcon &icon)
{
if (!QGuiApplicationPrivate::app_icon)
QGuiApplicationPrivate::app_icon = new QIcon();
*QGuiApplicationPrivate::app_icon = icon;
if (QGuiApplicationPrivate::platform_integration
&& QGuiApplicationPrivate::platform_integration->hasCapability(QPlatformIntegration::ApplicationIcon))
QGuiApplicationPrivate::platform_integration->setApplicationIcon(icon);
if (QGuiApplicationPrivate::is_app_running && !QGuiApplicationPrivate::is_app_closing)
QGuiApplicationPrivate::self->notifyWindowIconChanged();
}
void QGuiApplicationPrivate::notifyWindowIconChanged()
{
QEvent ev(QEvent::ApplicationWindowIconChange);
2941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010
const QWindowList list = QGuiApplication::topLevelWindows();
for (int i = 0; i < list.size(); ++i)
QCoreApplication::sendEvent(list.at(i), &ev);
}
/*!
\property QGuiApplication::quitOnLastWindowClosed
\brief whether the application implicitly quits when the last window is
closed.
The default is \c true.
If this property is \c true, the applications quits when the last visible
primary window (i.e. window with no parent) is closed.
\sa quit(), QWindow::close()
*/
void QGuiApplication::setQuitOnLastWindowClosed(bool quit)
{
QCoreApplication::setQuitLockEnabled(quit);
}
bool QGuiApplication::quitOnLastWindowClosed()
{
return QCoreApplication::isQuitLockEnabled();
}
/*!
\fn void QGuiApplication::lastWindowClosed()
This signal is emitted from exec() when the last visible
primary window (i.e. window with no parent) is closed.
By default, QGuiApplication quits after this signal is emitted. This feature
can be turned off by setting \l quitOnLastWindowClosed to \c false.
\sa QWindow::close(), QWindow::isTopLevel()
*/
void QGuiApplicationPrivate::emitLastWindowClosed()
{
if (qGuiApp && qGuiApp->d_func()->in_exec) {
emit qGuiApp->lastWindowClosed();
}
}
bool QGuiApplicationPrivate::shouldQuit()
{
const QWindowList processedWindows;
return shouldQuitInternal(processedWindows);
}
bool QGuiApplicationPrivate::shouldQuitInternal(const QWindowList &processedWindows)
{
/* if there is no visible top-level window left, we allow the quit */
QWindowList list = QGuiApplication::topLevelWindows();
for (int i = 0; i < list.size(); ++i) {
QWindow *w = list.at(i);
if (processedWindows.contains(w))
continue;
if (w->isVisible() && !w->transientParent())
return false;
}
3011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080
return true;
}
bool QGuiApplicationPrivate::tryCloseAllWindows()
{
return tryCloseRemainingWindows(QWindowList());
}
bool QGuiApplicationPrivate::tryCloseRemainingWindows(QWindowList processedWindows)
{
QWindowList list = QGuiApplication::topLevelWindows();
for (int i = 0; i < list.size(); ++i) {
QWindow *w = list.at(i);
if (w->isVisible() && !processedWindows.contains(w)) {
if (!w->close())
return false;
processedWindows.append(w);
list = QGuiApplication::topLevelWindows();
i = -1;
}
}
return true;
}
/*!
\since 5.2
\fn Qt::ApplicationState QGuiApplication::applicationState()
Returns the current state of the application.
You can react to application state changes to perform actions such as
stopping/resuming CPU-intensive tasks, freeing/loading resources or
saving/restoring application data.
*/
Qt::ApplicationState QGuiApplication::applicationState()
{
return QGuiApplicationPrivate::applicationState;
}
/*!
\since 5.2
\fn void QGuiApplication::applicationStateChanged(Qt::ApplicationState state)
This signal is emitted when the \a state of the application changes.
\sa applicationState()
*/
void QGuiApplicationPrivate::setApplicationState(Qt::ApplicationState state, bool forcePropagate)
{
if ((applicationState == state) && !forcePropagate)
return;
applicationState = state;
switch (state) {
case Qt::ApplicationActive: {
QEvent appActivate(QEvent::ApplicationActivate);
QCoreApplication::sendSpontaneousEvent(qApp, &appActivate);
break; }
case Qt::ApplicationInactive: {
QEvent appDeactivate(QEvent::ApplicationDeactivate);
QCoreApplication::sendSpontaneousEvent(qApp, &appDeactivate);
break; }
default:
break;
}
3081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150
QApplicationStateChangeEvent event(applicationState);
QCoreApplication::sendSpontaneousEvent(qApp, &event);
emit qApp->applicationStateChanged(applicationState);
}
// ### Qt6: consider removing the feature or making it less intrusive
/*!
\since 5.6
Returns whether QGuiApplication will use fallback session management.
The default is \c true.
If this is \c true and the session manager allows user interaction,
QGuiApplication will try to close toplevel windows after
commitDataRequest() has been emitted. If a window cannot be closed, session
shutdown will be canceled and the application will keep running.
Fallback session management only benefits applications that have an
"are you sure you want to close this window?" feature or other logic that
prevents closing a toplevel window depending on certain conditions, and
that do nothing to explicitly implement session management. In applications
that \e do implement session management using the proper session management
API, fallback session management interferes and may break session
management logic.
\warning If all windows \e are closed due to fallback session management
and quitOnLastWindowClosed() is \c true, the application will quit before
it is explicitly instructed to quit through the platform's session
management protocol. That violation of protocol may prevent the platform
session manager from saving application state.
\sa setFallbackSessionManagementEnabled(),
QSessionManager::allowsInteraction(), saveStateRequest(),
commitDataRequest(), {Session Management}
*/
bool QGuiApplication::isFallbackSessionManagementEnabled()
{
return QGuiApplicationPrivate::is_fallback_session_management_enabled;
}
/*!
\since 5.6
Sets whether QGuiApplication will use fallback session management to
\a enabled.
\sa isFallbackSessionManagementEnabled()
*/
void QGuiApplication::setFallbackSessionManagementEnabled(bool enabled)
{
QGuiApplicationPrivate::is_fallback_session_management_enabled = enabled;
}
/*!
\since 4.2
\fn void QGuiApplication::commitDataRequest(QSessionManager &manager)
This signal deals with \l{Session Management}{session management}. It is
emitted when the QSessionManager wants the application to commit all its
data.
Usually this means saving all open files, after getting permission from
the user. Furthermore you may want to provide a means by which the user
can cancel the shutdown.
You should not exit the application within this signal. Instead,
the session manager may or may not do this afterwards, depending on the
context.
3151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220
\warning Within this signal, no user interaction is possible, \e
unless you ask the \a manager for explicit permission. See
QSessionManager::allowsInteraction() and
QSessionManager::allowsErrorInteraction() for details and example
usage.
\note You should use Qt::DirectConnection when connecting to this signal.
\sa setFallbackSessionManagementEnabled(), isSessionRestored(),
sessionId(), saveStateRequest(), {Session Management}
*/
/*!
\since 4.2
\fn void QGuiApplication::saveStateRequest(QSessionManager &manager)
This signal deals with \l{Session Management}{session management}. It is
invoked when the \l{QSessionManager}{session manager} wants the application
to preserve its state for a future session.
For example, a text editor would create a temporary file that includes the
current contents of its edit buffers, the location of the cursor and other
aspects of the current editing session.
You should never exit the application within this signal. Instead, the
session manager may or may not do this afterwards, depending on the
context. Futhermore, most session managers will very likely request a saved
state immediately after the application has been started. This permits the
session manager to learn about the application's restart policy.
\warning Within this signal, no user interaction is possible, \e
unless you ask the \a manager for explicit permission. See
QSessionManager::allowsInteraction() and
QSessionManager::allowsErrorInteraction() for details.
\note You should use Qt::DirectConnection when connecting to this signal.
\sa isSessionRestored(), sessionId(), commitDataRequest(), {Session Management}
*/
/*!
\fn bool QGuiApplication::isSessionRestored() const
Returns \c true if the application has been restored from an earlier
\l{Session Management}{session}; otherwise returns \c false.
\sa sessionId(), commitDataRequest(), saveStateRequest()
*/
/*!
\since 5.0
\fn bool QGuiApplication::isSavingSession() const
Returns \c true if the application is currently saving the
\l{Session Management}{session}; otherwise returns \c false.
This is \c true when commitDataRequest() and saveStateRequest() are emitted,
but also when the windows are closed afterwards by session management.
\sa sessionId(), commitDataRequest(), saveStateRequest()
*/
/*!
\fn QString QGuiApplication::sessionId() const
Returns the current \l{Session Management}{session's} identifier.
If the application has been restored from an earlier session, this
identifier is the same as it was in that previous session. The session
3221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290
identifier is guaranteed to be unique both for different applications
and for different instances of the same application.
\sa isSessionRestored(), sessionKey(), commitDataRequest(), saveStateRequest()
*/
/*!
\fn QString QGuiApplication::sessionKey() const
Returns the session key in the current \l{Session Management}{session}.
If the application has been restored from an earlier session, this key is
the same as it was when the previous session ended.
The session key changes every time the session is saved. If the shutdown process
is cancelled, another session key will be used when shutting down again.
\sa isSessionRestored(), sessionId(), commitDataRequest(), saveStateRequest()
*/
#ifndef QT_NO_SESSIONMANAGER
bool QGuiApplication::isSessionRestored() const
{
Q_D(const QGuiApplication);
return d->is_session_restored;
}
QString QGuiApplication::sessionId() const
{
Q_D(const QGuiApplication);
return d->session_manager->sessionId();
}
QString QGuiApplication::sessionKey() const
{
Q_D(const QGuiApplication);
return d->session_manager->sessionKey();
}
bool QGuiApplication::isSavingSession() const
{
Q_D(const QGuiApplication);
return d->is_saving_session;
}
/*!
\since 5.2
Function that can be used to sync Qt state with the Window Systems state.
This function will first empty Qts events by calling QCoreApplication::processEvents(),
then the platform plugin will sync up with the windowsystem, and finally Qts events
will be delived by another call to QCoreApplication::processEvents();
This function is timeconsuming and its use is discouraged.
*/
void QGuiApplication::sync()
{
QCoreApplication::processEvents();
if (QGuiApplicationPrivate::platform_integration
&& QGuiApplicationPrivate::platform_integration->hasCapability(QPlatformIntegration::SyncState)) {
QGuiApplicationPrivate::platform_integration->sync();
QCoreApplication::processEvents();
QWindowSystemInterface::flushWindowSystemEvents();
}
}
void QGuiApplicationPrivate::commitData()
{
Q_Q(QGuiApplication);
is_saving_session = true;
3291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360
emit q->commitDataRequest(*session_manager);
if (is_fallback_session_management_enabled && session_manager->allowsInteraction()
&& !tryCloseAllWindows()) {
session_manager->cancel();
}
is_saving_session = false;
}
void QGuiApplicationPrivate::saveState()
{
Q_Q(QGuiApplication);
is_saving_session = true;
emit q->saveStateRequest(*session_manager);
is_saving_session = false;
}
#endif //QT_NO_SESSIONMANAGER
/*!
\property QGuiApplication::layoutDirection
\brief the default layout direction for this application
On system start-up, the default layout direction depends on the
application's language.
The notifier signal was introduced in Qt 5.4.
\sa QWidget::layoutDirection, isLeftToRight(), isRightToLeft()
*/
void QGuiApplication::setLayoutDirection(Qt::LayoutDirection direction)
{
if (layout_direction == direction || direction == Qt::LayoutDirectionAuto)
return;
layout_direction = direction;
if (qGuiApp) {
emit qGuiApp->layoutDirectionChanged(direction);
QGuiApplicationPrivate::self->notifyLayoutDirectionChange();
}
}
Qt::LayoutDirection QGuiApplication::layoutDirection()
{
// layout_direction is only ever Qt::LayoutDirectionAuto if setLayoutDirection
// was never called, or called with Qt::LayoutDirectionAuto (which is a no-op).
// In that case we return the default LeftToRight.
return layout_direction == Qt::LayoutDirectionAuto ? Qt::LeftToRight : layout_direction;
}
/*!
\fn QCursor *QGuiApplication::overrideCursor()
Returns the active application override cursor.
This function returns 0 if no application cursor has been defined (i.e. the
internal cursor stack is empty).
\sa setOverrideCursor(), restoreOverrideCursor()
*/
#ifndef QT_NO_CURSOR
QCursor *QGuiApplication::overrideCursor()
{
CHECK_QAPP_INSTANCE(Q_NULLPTR)
return qGuiApp->d_func()->cursor_list.isEmpty() ? 0 : &qGuiApp->d_func()->cursor_list.first();
}
3361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430
/*!
Changes the currently active application override cursor to \a cursor.
This function has no effect if setOverrideCursor() was not called.
\sa setOverrideCursor(), overrideCursor(), restoreOverrideCursor(),
QWidget::setCursor()
*/
void QGuiApplication::changeOverrideCursor(const QCursor &cursor)
{
CHECK_QAPP_INSTANCE()
if (qGuiApp->d_func()->cursor_list.isEmpty())
return;
qGuiApp->d_func()->cursor_list.removeFirst();
setOverrideCursor(cursor);
}
#endif
#ifndef QT_NO_CURSOR
static inline void applyCursor(QWindow *w, QCursor c)
{
if (const QScreen *screen = w->screen())
if (QPlatformCursor *cursor = screen->handle()->cursor())
cursor->changeCursor(&c, w);
}
static inline void unsetCursor(QWindow *w)
{
if (const QScreen *screen = w->screen())
if (QPlatformCursor *cursor = screen->handle()->cursor())
cursor->changeCursor(0, w);
}
static inline void applyCursor(const QList<QWindow *> &l, const QCursor &c)
{
for (int i = 0; i < l.size(); ++i) {
QWindow *w = l.at(i);
if (w->handle() && w->type() != Qt::Desktop)
applyCursor(w, c);
}
}
static inline void applyWindowCursor(const QList<QWindow *> &l)
{
for (int i = 0; i < l.size(); ++i) {
QWindow *w = l.at(i);
if (w->handle() && w->type() != Qt::Desktop) {
if (qt_window_private(w)->hasCursor) {
applyCursor(w, w->cursor());
} else {
unsetCursor(w);
}
}
}
}
/*!
\fn void QGuiApplication::setOverrideCursor(const QCursor &cursor)
Sets the application override cursor to \a cursor.
Application override cursors are intended for showing the user that the
application is in a special state, for example during an operation that
might take some time.
This cursor will be displayed in all the application's widgets until
restoreOverrideCursor() or another setOverrideCursor() is called.
Application cursors are stored on an internal stack. setOverrideCursor()
3431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500
pushes the cursor onto the stack, and restoreOverrideCursor() pops the
active cursor off the stack. changeOverrideCursor() changes the curently
active application override cursor.
Every setOverrideCursor() must eventually be followed by a corresponding
restoreOverrideCursor(), otherwise the stack will never be emptied.
Example:
\snippet code/src_gui_kernel_qguiapplication_x11.cpp 0
\sa overrideCursor(), restoreOverrideCursor(), changeOverrideCursor(),
QWidget::setCursor()
*/
void QGuiApplication::setOverrideCursor(const QCursor &cursor)
{
CHECK_QAPP_INSTANCE()
qGuiApp->d_func()->cursor_list.prepend(cursor);
applyCursor(QGuiApplicationPrivate::window_list, cursor);
}
/*!
\fn void QGuiApplication::restoreOverrideCursor()
Undoes the last setOverrideCursor().
If setOverrideCursor() has been called twice, calling
restoreOverrideCursor() will activate the first cursor set. Calling this
function a second time restores the original widgets' cursors.
\sa setOverrideCursor(), overrideCursor()
*/
void QGuiApplication::restoreOverrideCursor()
{
CHECK_QAPP_INSTANCE()
if (qGuiApp->d_func()->cursor_list.isEmpty())
return;
qGuiApp->d_func()->cursor_list.removeFirst();
if (qGuiApp->d_func()->cursor_list.size() > 0) {
QCursor c(qGuiApp->d_func()->cursor_list.value(0));
applyCursor(QGuiApplicationPrivate::window_list, c);
} else {
applyWindowCursor(QGuiApplicationPrivate::window_list);
}
}
#endif// QT_NO_CURSOR
/*!
Returns the application's style hints.
The style hints encapsulate a set of platform dependent properties
such as double click intervals, full width selection and others.
The hints can be used to integrate tighter with the underlying platform.
\sa QStyleHints
*/
QStyleHints *QGuiApplication::styleHints()
{
if (!QGuiApplicationPrivate::styleHints)
QGuiApplicationPrivate::styleHints = new QStyleHints();
return QGuiApplicationPrivate::styleHints;
}
/*!
Sets whether Qt should use the system's standard colors, fonts, etc., to
\a on. By default, this is \c true.
This function must be called before creating the QGuiApplication object, like
this:
3501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570
\snippet code/src_gui_kernel_qguiapplication.cpp 0
\sa desktopSettingsAware()
*/
void QGuiApplication::setDesktopSettingsAware(bool on)
{
QGuiApplicationPrivate::obey_desktop_settings = on;
}
/*!
Returns \c true if Qt is set to use the system's standard colors, fonts, etc.;
otherwise returns \c false. The default is \c true.
\sa setDesktopSettingsAware()
*/
bool QGuiApplication::desktopSettingsAware()
{
return QGuiApplicationPrivate::obey_desktop_settings;
}
/*!
returns the input method.
The input method returns properties about the state and position of
the virtual keyboard. It also provides information about the position of the
current focused input element.
\sa QInputMethod
*/
QInputMethod *QGuiApplication::inputMethod()
{
CHECK_QAPP_INSTANCE(Q_NULLPTR)
if (!qGuiApp->d_func()->inputMethod)
qGuiApp->d_func()->inputMethod = new QInputMethod();
return qGuiApp->d_func()->inputMethod;
}
/*!
\fn void QGuiApplication::fontDatabaseChanged()
This signal is emitted when application fonts are loaded or removed.
\sa QFontDatabase::addApplicationFont(),
QFontDatabase::addApplicationFontFromData(),
QFontDatabase::removeAllApplicationFonts(),
QFontDatabase::removeApplicationFont()
*/
QPixmap QGuiApplicationPrivate::getPixmapCursor(Qt::CursorShape cshape)
{
Q_UNUSED(cshape);
return QPixmap();
}
void QGuiApplicationPrivate::notifyThemeChanged()
{
if (!(applicationResourceFlags & ApplicationPaletteExplicitlySet)) {
clearPalette();
initPalette();
}
if (!(applicationResourceFlags & ApplicationFontExplicitlySet)) {
QMutexLocker locker(&applicationFontMutex);
clearFontUnlocked();
initFontUnlocked();
}
}
#ifndef QT_NO_DRAGANDDROP
void QGuiApplicationPrivate::notifyDragStarted(const QDrag *drag)
{
3571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640
Q_UNUSED(drag)
}
#endif
const QDrawHelperGammaTables *QGuiApplicationPrivate::gammaTables()
{
QDrawHelperGammaTables *result = m_gammaTables.load();
if (!result){
QDrawHelperGammaTables *tables = new QDrawHelperGammaTables(fontSmoothingGamma);
if (!m_gammaTables.testAndSetRelease(0, tables))
delete tables;
result = m_gammaTables.load();
}
return result;
}
void QGuiApplicationPrivate::_q_updateFocusObject(QObject *object)
{
Q_Q(QGuiApplication);
QPlatformInputContext *inputContext = platformIntegration()->inputContext();
bool enabled = false;
if (object && inputContext) {
QInputMethodQueryEvent query(Qt::ImEnabled | Qt::ImHints);
QGuiApplication::sendEvent(object, &query);
enabled = query.value(Qt::ImEnabled).toBool();
if (enabled) {
static const bool supportsHiddenText = inputContext->hasCapability(QPlatformInputContext::HiddenTextCapability);
const Qt::InputMethodHints hints = static_cast<Qt::InputMethodHints>(query.value(Qt::ImHints).toInt());
if ((hints & Qt::ImhHiddenText) && !supportsHiddenText)
enabled = false;
}
}
QPlatformInputContextPrivate::setInputMethodAccepted(enabled);
if (inputContext)
inputContext->setFocusObject(object);
emit q->focusObjectChanged(object);
}
enum {
MouseCapsMask = 0xFF,
MouseSourceMaskDst = 0xFF00,
MouseSourceMaskSrc = MouseCapsMask,
MouseSourceShift = 8,
MouseFlagsCapsMask = 0xFF0000,
MouseFlagsShift = 16
};
int QGuiApplicationPrivate::mouseEventCaps(QMouseEvent *event)
{
return event->caps & MouseCapsMask;
}
QVector2D QGuiApplicationPrivate::mouseEventVelocity(QMouseEvent *event)
{
return event->velocity;
}
void QGuiApplicationPrivate::setMouseEventCapsAndVelocity(QMouseEvent *event, int caps, const QVector2D &velocity)
{
Q_ASSERT(caps <= MouseCapsMask);
event->caps &= ~MouseCapsMask;
event->caps |= caps & MouseCapsMask;
event->velocity = velocity;
}
Qt::MouseEventSource QGuiApplicationPrivate::mouseEventSource(const QMouseEvent *event)
{
36413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681
return Qt::MouseEventSource((event->caps & MouseSourceMaskDst) >> MouseSourceShift);
}
void QGuiApplicationPrivate::setMouseEventSource(QMouseEvent *event, Qt::MouseEventSource source)
{
// Mouse event synthesization status is encoded in the caps field because
// QTouchDevice::CapabilityFlag uses only 6 bits from it.
int value = source;
Q_ASSERT(value <= MouseSourceMaskSrc);
event->caps &= ~MouseSourceMaskDst;
event->caps |= (value & MouseSourceMaskSrc) << MouseSourceShift;
}
Qt::MouseEventFlags QGuiApplicationPrivate::mouseEventFlags(const QMouseEvent *event)
{
return Qt::MouseEventFlags((event->caps & MouseFlagsCapsMask) >> MouseFlagsShift);
}
void QGuiApplicationPrivate::setMouseEventFlags(QMouseEvent *event, Qt::MouseEventFlags flags)
{
// use the 0x00FF0000 byte from caps (containing up to 7 mouse event flags)
unsigned int value = flags;
Q_ASSERT(value <= Qt::MouseEventFlagMask);
event->caps &= ~MouseFlagsCapsMask;
event->caps |= (value & Qt::MouseEventFlagMask) << MouseFlagsShift;
}
QInputDeviceManager *QGuiApplicationPrivate::inputDeviceManager()
{
Q_ASSERT(QGuiApplication::instance());
if (!m_inputDeviceManager)
m_inputDeviceManager = new QInputDeviceManager(QGuiApplication::instance());
return m_inputDeviceManager;
}
#include "moc_qguiapplication.cpp"
QT_END_NAMESPACE