amass/qt6windows7
1
0
Fork 0
mirror of https://github.com/crystalidea/qt6windows7.git synced 2024-11-24 12:30:32 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
85d238dfda
qt6windows7/tests/auto/gui/kernel/qguiapplication/tst_qguiapplication.cpp
kleuter 85d238dfda qt 6.5.1 original
2023-10-29 23:33:08 +01:00

1339 lines
48 KiB
C++
Raw Blame History

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include <QTest>
#include <QSignalSpy>
#include <QtGui/QGuiApplication>
#include <QtGui/QWindow>
#include <QtGui/QScreen>
#include <QtGui/QCursor>
#include <QtGui/QFont>
#include <QtGui/QPalette>
#include <QtGui/QStyleHints>
#include <qpa/qplatformintegration.h>
#include <qpa/qwindowsysteminterface.h>
#include <qgenericplugin.h>
#include <private/qguiapplication_p.h>
#if defined(Q_OS_QNX)
#include <QOpenGLContext>
#endif
#include <QtGui/private/qopenglcontext_p.h>
#include <QDebug>
#include "tst_qcoreapplication.h"
enum { spacing = 50, windowSize = 200 };
class tst_QGuiApplication: public tst_QCoreApplication
{
Q_OBJECT
private slots:
void initTestCase();
void cleanup();
void displayName();
void desktopFileName();
void firstWindowTitle();
void windowIcon();
void focusObject();
void allWindows();
void topLevelWindows();
void abortQuitOnShow();
void changeFocusWindow();
void keyboardModifiers();
void palette();
void font();
void modalWindow();
void quitOnLastWindowClosed();
void quitOnLastWindowClosedMulti();
void dontQuitOnLastWindowClosed();
void quitOnLastWindowClosedWithEventLoopLocker();
void genericPluginsAndWindowSystemEvents();
void layoutDirection();
void globalShareContext();
void testSetPaletteAttribute();
void staticFunctions();
void settableStyleHints_data();
void settableStyleHints(); // Needs to run last as it changes style hints.
};
void tst_QGuiApplication::initTestCase()
{
#ifdef QT_QPA_DEFAULT_PLATFORM_NAME
if ((QString::compare(QStringLiteral(QT_QPA_DEFAULT_PLATFORM_NAME),
QStringLiteral("eglfs"), Qt::CaseInsensitive) == 0) ||
(QString::compare(QString::fromLatin1(qgetenv("QT_QPA_PLATFORM")),
QStringLiteral("eglfs"), Qt::CaseInsensitive) == 0)) {
// Set env variables to disable input and cursor because eglfs is single fullscreen window
// and trying to initialize input and cursor will crash test.
qputenv("QT_QPA_EGLFS_DISABLE_INPUT", "1");
qputenv("QT_QPA_EGLFS_HIDECURSOR", "1");
}
#endif
}
void tst_QGuiApplication::cleanup()
{
QVERIFY(QGuiApplication::allWindows().isEmpty());
}
void tst_QGuiApplication::displayName()
{
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
QSignalSpy spy(&app, &QGuiApplication::applicationDisplayNameChanged);
QCOMPARE(::qAppName(), QString::fromLatin1("tst_qguiapplication"));
QCOMPARE(QGuiApplication::applicationName(), QString::fromLatin1("tst_qguiapplication"));
QCOMPARE(QGuiApplication::applicationDisplayName(), QString::fromLatin1("tst_qguiapplication"));
QGuiApplication::setApplicationName("The Core Application");
QCOMPARE(QGuiApplication::applicationName(), QString::fromLatin1("The Core Application"));
QCOMPARE(QGuiApplication::applicationDisplayName(), QString::fromLatin1("The Core Application"));
QCOMPARE(spy.size(), 1);
QGuiApplication::setApplicationDisplayName("The GUI Application");
QCOMPARE(QGuiApplication::applicationDisplayName(), QString::fromLatin1("The GUI Application"));
QCOMPARE(spy.size(), 2);
QGuiApplication::setApplicationName("The Core Application 2");
QCOMPARE(QGuiApplication::applicationName(), QString::fromLatin1("The Core Application 2"));
QCOMPARE(QGuiApplication::applicationDisplayName(), QString::fromLatin1("The GUI Application"));
QCOMPARE(spy.size(), 2);
QGuiApplication::setApplicationDisplayName("The GUI Application 2");
QCOMPARE(QGuiApplication::applicationDisplayName(), QString::fromLatin1("The GUI Application 2"));
QCOMPARE(spy.size(), 3);
}
void tst_QGuiApplication::desktopFileName()
{
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
QCOMPARE(QGuiApplication::desktopFileName(), QString());
QGuiApplication::setDesktopFileName("io.qt.QGuiApplication.desktop");
QCOMPARE(QGuiApplication::desktopFileName(), QString::fromLatin1("io.qt.QGuiApplication.desktop"));
QGuiApplication::setDesktopFileName(QString());
QCOMPARE(QGuiApplication::desktopFileName(), QString());
}
void tst_QGuiApplication::firstWindowTitle()
{
int argc = 3;
char *argv[] = { const_cast<char*>("tst_qguiapplication"), const_cast<char*>("-qwindowtitle"), const_cast<char*>("User Title") };
QGuiApplication app(argc, argv);
QWindow window;
window.setTitle("Application Title");
window.show();
QCOMPARE(window.title(), QString("User Title"));
}
void tst_QGuiApplication::windowIcon()
{
int argc = 3;
char *argv[] = { const_cast<char*>("tst_qguiapplication"), const_cast<char*>("-qwindowicon"), const_cast<char*>(":/icons/usericon.png") };
QGuiApplication app(argc, argv);
QIcon appIcon(":/icons/appicon.png");
app.setWindowIcon(appIcon);
QWindow window;
window.show();
QIcon userIcon(":/icons/usericon.png");
// Comparing icons is hard. cacheKey() differs because the icon was independently loaded.
// So we use availableSizes, after making sure that the app and user icons do have different sizes.
QVERIFY(userIcon.availableSizes() != appIcon.availableSizes());
QCOMPARE(window.icon().availableSizes(), userIcon.availableSizes());
}
class DummyWindow : public QWindow
{
public:
DummyWindow() : m_focusObject(nullptr) {}
virtual QObject *focusObject() const override
{
return m_focusObject;
}
void setFocusObject(QObject *object)
{
m_focusObject = object;
emit focusObjectChanged(object);
}
QObject *m_focusObject;
};
void tst_QGuiApplication::focusObject()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::WindowActivation))
QSKIP("QWindow::requestActivate() is not supported.");
QObject obj1, obj2, obj3;
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
DummyWindow window1;
#if defined(Q_OS_QNX)
window1.setSurfaceType(QSurface::OpenGLSurface);
#endif
window1.resize(windowSize, windowSize);
window1.setTitle(QStringLiteral("focusObject:window1"));
window1.setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
DummyWindow window2;
window2.resize(windowSize, windowSize);
window2.setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
window2.setTitle(QStringLiteral("focusObject:window2"));
window1.show();
#if defined(Q_OS_QNX) // We either need to create a eglSurface or a create a backing store
// and then post the window in order for screen to show the window
QOpenGLContext context;
context.create();
context.makeCurrent(&window1);
QVERIFY(QTest::qWaitForWindowExposed(&window1)); // Buffer swap only succeeds with exposed window
context.swapBuffers(&window1);
#endif
QSignalSpy spy(&app, SIGNAL(focusObjectChanged(QObject*)));
// verify active window focus propagates to qguiapplication
window1.requestActivate();
QVERIFY(QTest::qWaitForWindowActive(&window1));
QCOMPARE(app.focusWindow(), &window1);
window1.setFocusObject(&obj1);
QCOMPARE(app.focusObject(), &obj1);
QCOMPARE(spy.size(), 1);
spy.clear();
window1.setFocusObject(&obj2);
QCOMPARE(app.focusObject(), &obj2);
QCOMPARE(spy.size(), 1);
spy.clear();
window2.setFocusObject(&obj3);
QCOMPARE(app.focusObject(), &obj2); // not yet changed
window2.show();
QVERIFY(QTest::qWaitForWindowExposed(&window2));
QTRY_COMPARE(app.focusWindow(), &window2);
QCOMPARE(app.focusObject(), &obj3);
QCOMPARE(spy.size(), 1);
// focus change on unfocused window does not show
spy.clear();
window1.setFocusObject(&obj1);
QCOMPARE(spy.size(), 0);
QCOMPARE(app.focusObject(), &obj3);
}
void tst_QGuiApplication::allWindows()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
QWindow *window1 = new QWindow;
QWindow *window2 = new QWindow(window1);
QVERIFY(app.allWindows().contains(window1));
QVERIFY(app.allWindows().contains(window2));
QCOMPARE(app.allWindows().size(), 2);
delete window1;
window1 = nullptr;
window2 = nullptr;
QVERIFY(!app.allWindows().contains(window2));
QVERIFY(!app.allWindows().contains(window1));
QCOMPARE(app.allWindows().size(), 0);
}
void tst_QGuiApplication::topLevelWindows()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
QWindow *window1 = new QWindow;
QWindow *window2 = new QWindow(window1);
QVERIFY(app.topLevelWindows().contains(window1));
QVERIFY(!app.topLevelWindows().contains(window2));
QCOMPARE(app.topLevelWindows().size(), 1);
delete window1;
window1 = nullptr;
window2 = nullptr;
QVERIFY(!app.topLevelWindows().contains(window2));
QVERIFY(!app.topLevelWindows().contains(window1));
QCOMPARE(app.topLevelWindows().size(), 0);
}
class ShowCloseShowWindow : public QWindow
{
Q_OBJECT
public:
ShowCloseShowWindow(bool showAgain, QWindow *parent = nullptr)
: QWindow(parent), showAgain(showAgain)
{
QTimer::singleShot(0, this, SLOT(doClose()));
QTimer::singleShot(500, this, SLOT(exitApp()));
}
private slots:
void doClose() {
close();
if (showAgain)
show();
}
void exitApp() {
qApp->exit(1);
}
private:
bool showAgain;
};
void tst_QGuiApplication::abortQuitOnShow()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
QScopedPointer<QWindow> window1(new ShowCloseShowWindow(false));
window1->resize(windowSize, windowSize);
window1->setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
window1->setTitle(QStringLiteral("abortQuitOnShow:window1"));
window1->show();
QCOMPARE(app.exec(), 0);
QScopedPointer<QWindow> window2(new ShowCloseShowWindow(true));
window2->setTitle(QStringLiteral("abortQuitOnShow:window2"));
window2->resize(windowSize, windowSize);
window2->setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
window2->show();
QCOMPARE(app.exec(), 1);
}
class FocusChangeWindow: public QWindow
{
protected:
virtual bool event(QEvent *ev) override
{
if (ev->type() == QEvent::FocusAboutToChange)
windowDuringFocusAboutToChange = qGuiApp->focusWindow();
return QWindow::event(ev);
}
virtual void focusOutEvent(QFocusEvent *) override
{
windowDuringFocusOut = qGuiApp->focusWindow();
}
public:
FocusChangeWindow() : QWindow(), windowDuringFocusAboutToChange(nullptr), windowDuringFocusOut(nullptr) {}
QWindow *windowDuringFocusAboutToChange;
QWindow *windowDuringFocusOut;
};
void tst_QGuiApplication::changeFocusWindow()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::WindowActivation))
QSKIP("QWindow::requestActivate() is not supported.");
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
// focus is changed between FocusAboutToChange and FocusChanged
FocusChangeWindow window1;
#if defined(Q_OS_QNX)
window1.setSurfaceType(QSurface::OpenGLSurface);
#endif
window1.resize(windowSize, windowSize);
window1.setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
window1.setTitle(QStringLiteral("changeFocusWindow:window1"));
window1.show();
#if defined(Q_OS_QNX) // We either need to create a eglSurface or a create a backing store
// and then post the window in order for screen to show the window
QOpenGLContext context;
context.create();
context.makeCurrent(&window1);
QVERIFY(QTest::qWaitForWindowExposed(&window1)); // Buffer swap only succeeds with exposed window
context.swapBuffers(&window1);
#endif
FocusChangeWindow window2;
#if defined(Q_OS_QNX)
window2.setSurfaceType(QSurface::OpenGLSurface);
#endif
window2.resize(windowSize, windowSize);
window2.setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
window2.setTitle(QStringLiteral("changeFocusWindow:window2"));
window2.show();
#if defined(Q_OS_QNX) // We either need to create a eglSurface or a create a backing store
// and then post the window in order for screen to show the window
context.makeCurrent(&window2);
QVERIFY(QTest::qWaitForWindowExposed(&window2)); // Buffer swap only succeeds with exposed window
context.swapBuffers(&window2);
#endif
QVERIFY(QTest::qWaitForWindowExposed(&window1));
QVERIFY(QTest::qWaitForWindowExposed(&window2));
window1.requestActivate();
QTRY_COMPARE(app.focusWindow(), &window1);
window2.requestActivate();
QTRY_COMPARE(app.focusWindow(), &window2);
QCOMPARE(window1.windowDuringFocusAboutToChange, &window1);
QCOMPARE(window1.windowDuringFocusOut, &window2);
}
void tst_QGuiApplication::keyboardModifiers()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
QScopedPointer<QWindow> window(new QWindow);
window->resize(windowSize, windowSize);
window->setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
window->setTitle(QStringLiteral("keyboardModifiers"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window.data()));
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
// mouse events
QPoint center = window->geometry().center();
QTest::mouseEvent(QTest::MousePress, window.data(), Qt::LeftButton, Qt::NoModifier, center);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::mouseEvent(QTest::MouseRelease, window.data(), Qt::LeftButton, Qt::NoModifier, center);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::mouseEvent(QTest::MousePress, window.data(), Qt::RightButton, Qt::ControlModifier, center);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
QTest::mouseEvent(QTest::MouseRelease, window.data(), Qt::RightButton, Qt::ControlModifier, center);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
// shortcut events
QTest::keyEvent(QTest::Shortcut, window.data(), Qt::Key_5, Qt::MetaModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::MetaModifier);
QTest::keyEvent(QTest::Shortcut, window.data(), Qt::Key_Period, Qt::NoModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::keyEvent(QTest::Shortcut, window.data(), Qt::Key_0, Qt::ControlModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
// key events
QTest::keyEvent(QTest::Press, window.data(), Qt::Key_C);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::keyEvent(QTest::Release, window.data(), Qt::Key_C);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::keyEvent(QTest::Press, window.data(), Qt::Key_U, Qt::ControlModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
QTest::keyEvent(QTest::Release, window.data(), Qt::Key_U, Qt::ControlModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
QTest::keyEvent(QTest::Press, window.data(), Qt::Key_T);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::keyEvent(QTest::Release, window.data(), Qt::Key_T);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QTest::keyEvent(QTest::Press, window.data(), Qt::Key_E, Qt::ControlModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
QTest::keyEvent(QTest::Release, window.data(), Qt::Key_E, Qt::ControlModifier);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
// wheel events
QPoint global = window->mapToGlobal(center);
QPoint delta(0, 1);
QWindowSystemInterface::handleWheelEvent(window.data(), center, global, delta, delta, Qt::NoModifier);
QWindowSystemInterface::sendWindowSystemEvents(QEventLoop::AllEvents);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
QWindowSystemInterface::handleWheelEvent(window.data(), center, global, delta, delta, Qt::AltModifier);
QWindowSystemInterface::sendWindowSystemEvents(QEventLoop::AllEvents);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::AltModifier);
QWindowSystemInterface::handleWheelEvent(window.data(), center, global, delta, delta, Qt::ControlModifier);
QWindowSystemInterface::sendWindowSystemEvents(QEventLoop::AllEvents);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::ControlModifier);
// touch events
QPointingDevice touchDevice(QLatin1String("test touchscreen"), 0,
QInputDevice::DeviceType::TouchScreen, QPointingDevice::PointerType::Finger,
QPointingDevice::Capability::Position, 10, 0);
QWindowSystemInterface::registerInputDevice(&touchDevice);
QTest::touchEvent(window.data(), &touchDevice).press(1, center).release(1, center);
QCOMPARE(QGuiApplication::keyboardModifiers(), Qt::NoModifier);
window->close();
}
/*
Compare actual against expected but ignore unset roles.
Comparing palettes via operator== will compare all roles.
*/
static bool palettesMatch(const QPalette &actual, const QPalette &expected)
{
if (actual.resolveMask() != expected.resolveMask())
return false;
for (int i = 0; i < QPalette::NColorGroups; i++) {
for (int j = 0; j < QPalette::NColorRoles; j++) {
const auto g = QPalette::ColorGroup(i);
const auto r = QPalette::ColorRole(j);
if (expected.isBrushSet(g, r)) {
if (actual.brush(g, r) != expected.brush(g, r))
return false;
}
}
}
return true;
}
void tst_QGuiApplication::palette()
{
// Getting the palette before application construction should work
QPalette paletteBeforeAppConstruction = QGuiApplication::palette();
// And should be reflected in the default constructed palette
QCOMPARE(paletteBeforeAppConstruction, QPalette());
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
// The same should be true after application construction
QCOMPARE(QGuiApplication::palette(), QPalette());
// The default application palette is not resolved
QVERIFY(!QGuiApplication::palette().resolveMask());
// TODO: add event processing instead of the signal
#if QT_DEPRECATED_SINCE(6, 0)
QSignalSpy signalSpy(&app, SIGNAL(paletteChanged(QPalette)));
#endif
QPalette oldPalette = QGuiApplication::palette();
QPalette newPalette = QPalette(Qt::red);
QGuiApplication::setPalette(newPalette);
QVERIFY(palettesMatch(QGuiApplication::palette(), newPalette));
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 1);
QVERIFY(palettesMatch(signalSpy.at(0).at(0).value<QPalette>(), newPalette));
#endif
QCOMPARE(QGuiApplication::palette(), QPalette());
QGuiApplication::setPalette(oldPalette);
QVERIFY(palettesMatch(QGuiApplication::palette(), oldPalette));
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 2);
QVERIFY(palettesMatch(signalSpy.at(1).at(0).value<QPalette>(), oldPalette));
#endif
QCOMPARE(QGuiApplication::palette(), QPalette());
QGuiApplication::setPalette(oldPalette);
QVERIFY(palettesMatch(QGuiApplication::palette(), oldPalette));
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 2);
#endif
QCOMPARE(QGuiApplication::palette(), QPalette());
}
void tst_QGuiApplication::font()
{
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
#if QT_DEPRECATED_SINCE(6, 0)
QSignalSpy signalSpy(&app, SIGNAL(fontChanged(QFont)));
#endif
QFont oldFont = QGuiApplication::font();
QFont newFont = QFont("BogusFont", 33);
QGuiApplication::setFont(newFont);
QCOMPARE(QGuiApplication::font(), newFont);
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 1);
QCOMPARE(signalSpy.at(0).at(0), QVariant(newFont));
#endif
QGuiApplication::setFont(oldFont);
QCOMPARE(QGuiApplication::font(), oldFont);
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 2);
QCOMPARE(signalSpy.at(1).at(0), QVariant(oldFont));
#endif
QGuiApplication::setFont(oldFont);
QCOMPARE(QGuiApplication::font(), oldFont);
#if QT_DEPRECATED_SINCE(6, 0)
QCOMPARE(signalSpy.size(), 2);
#endif
}
class BlockableWindow : public QWindow
{
Q_OBJECT
public:
int blocked;
int leaves;
int enters;
inline explicit BlockableWindow(QWindow *parent = nullptr)
: QWindow(parent), blocked(false), leaves(0), enters(0) {}
bool event(QEvent *e) override
{
switch (e->type()) {
case QEvent::WindowBlocked:
++blocked;
break;
case QEvent::WindowUnblocked:
--blocked;
break;
case QEvent::Leave:
leaves++;
break;
case QEvent::Enter:
enters++;
break;
default:
break;
}
return QWindow::event(e);
}
void resetCounts()
{
leaves = 0;
enters = 0;
}
};
void tst_QGuiApplication::modalWindow()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
int x = screenGeometry.left() + spacing;
int y = screenGeometry.top() + spacing;
QScopedPointer<BlockableWindow> window1(new BlockableWindow);
window1->setTitle(QStringLiteral("window1"));
window1->resize(windowSize, windowSize);
window1->setFramePosition(QPoint(x, y));
BlockableWindow *childWindow1 = new BlockableWindow(window1.data());
childWindow1->resize(windowSize / 2, windowSize / 2);
x += spacing + windowSize;
QScopedPointer<BlockableWindow> window2(new BlockableWindow);
window2->setTitle(QStringLiteral("window2"));
window2->setFlags(window2->flags() & Qt::Tool); // QTBUG-32433, don't be fooled by unusual window flags.
window2->resize(windowSize, windowSize);
window2->setFramePosition(QPoint(x, y));
x += spacing + windowSize;
QScopedPointer<BlockableWindow> windowModalWindow1(new BlockableWindow);
windowModalWindow1->setTitle(QStringLiteral("windowModalWindow1"));
windowModalWindow1->setTransientParent(window1.data());
windowModalWindow1->setModality(Qt::WindowModal);
windowModalWindow1->resize(windowSize, windowSize);
windowModalWindow1->setFramePosition(QPoint(x, y));
x += spacing + windowSize;
QScopedPointer<BlockableWindow> windowModalWindow2(new BlockableWindow);
windowModalWindow2->setTitle(QStringLiteral("windowModalWindow2"));
windowModalWindow2->setTransientParent(windowModalWindow1.data());
windowModalWindow2->setModality(Qt::WindowModal);
windowModalWindow2->resize(windowSize, windowSize);
windowModalWindow2->setFramePosition(QPoint(x, y));
x = screenGeometry.left() + spacing;
y += spacing + windowSize;
QScopedPointer<BlockableWindow> applicationModalWindow1(new BlockableWindow);
applicationModalWindow1->setTitle(QStringLiteral("applicationModalWindow1"));
applicationModalWindow1->setModality(Qt::ApplicationModal);
applicationModalWindow1->resize(windowSize, windowSize);
applicationModalWindow1->setFramePosition(QPoint(x, y));
#ifndef QT_NO_CURSOR // Get the mouse cursor out of the way since we are manually sending enter/leave.
QCursor::setPos(QPoint(x + 2 * spacing + windowSize, y));
#endif
// show the 2 windows, nothing is blocked
window1->show();
window2->show();
QVERIFY(QTest::qWaitForWindowExposed(window1.data()));
QVERIFY(QTest::qWaitForWindowExposed(window2.data()));
QCOMPARE(app.modalWindow(), static_cast<QWindow *>(nullptr));
QCOMPARE(window1->blocked, 0);
QCOMPARE(childWindow1->blocked, 0);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// enter mouse in window1
QWindowSystemInterface::handleEnterEvent(window1.data());
QGuiApplication::processEvents();
QCOMPARE(window1->enters, 1);
QCOMPARE(window1->leaves, 0);
// show applicationModalWindow1, everything is blocked
applicationModalWindow1->show();
QCOMPARE(app.modalWindow(), applicationModalWindow1.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(childWindow1->blocked, 1); // QTBUG-32242, blocked status needs to be set on children as well.
QCOMPARE(window2->blocked, 1);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 1);
QCOMPARE(applicationModalWindow1->blocked, 0);
// opening modal causes leave for previously entered window, but not others
QGuiApplication::processEvents();
QCOMPARE(window1->enters, 1);
QCOMPARE(window1->leaves, 1);
QCOMPARE(window2->enters, 0);
QCOMPARE(window2->leaves, 0);
QCOMPARE(applicationModalWindow1->enters, 0);
QCOMPARE(applicationModalWindow1->leaves, 0);
window1->resetCounts();
// Try entering/leaving blocked window2 - no events should reach it
QWindowSystemInterface::handleEnterEvent(window2.data());
QGuiApplication::processEvents();
QWindowSystemInterface::handleLeaveEvent(window2.data());
QGuiApplication::processEvents();
QCOMPARE(window2->enters, 0);
QCOMPARE(window2->leaves, 0);
// everything is unblocked when applicationModalWindow1 is hidden
applicationModalWindow1->hide();
QCOMPARE(app.modalWindow(), static_cast<QWindow *>(nullptr));
QCOMPARE(window1->blocked, 0);
QCOMPARE(childWindow1->blocked, 0); // QTBUG-32242, blocked status needs to be set on children as well.
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// Enter window2 - should not be blocked
QWindowSystemInterface::handleEnterEvent(window2.data());
QGuiApplication::processEvents();
QCOMPARE(window2->enters, 1);
QCOMPARE(window2->leaves, 0);
// show the windowModalWindow1, only window1 is blocked
windowModalWindow1->show();
QCOMPARE(app.modalWindow(), windowModalWindow1.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// opening window modal window doesn't cause leave for unblocked window
QGuiApplication::processEvents();
QCOMPARE(window1->enters, 0);
QCOMPARE(window1->leaves, 0);
QCOMPARE(window2->enters, 1);
QCOMPARE(window2->leaves, 0);
QCOMPARE(windowModalWindow1->enters, 0);
QCOMPARE(windowModalWindow1->leaves, 0);
// show the windowModalWindow2, windowModalWindow1 is blocked as well
windowModalWindow2->show();
QCOMPARE(app.modalWindow(), windowModalWindow2.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// hide windowModalWindow1, nothing is unblocked
windowModalWindow1->hide();
QCOMPARE(app.modalWindow(), windowModalWindow2.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// hide windowModalWindow2, windowModalWindow1 and window1 are unblocked
windowModalWindow2->hide();
QCOMPARE(app.modalWindow(), static_cast<QWindow *>(nullptr));
QCOMPARE(window1->blocked, 0);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// show windowModalWindow1 again, window1 is blocked
windowModalWindow1->show();
QCOMPARE(app.modalWindow(), windowModalWindow1.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// show windowModalWindow2 again, windowModalWindow1 is also blocked
windowModalWindow2->show();
QCOMPARE(app.modalWindow(), windowModalWindow2.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// show applicationModalWindow1, everything is blocked
applicationModalWindow1->show();
QCOMPARE(app.modalWindow(), applicationModalWindow1.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 1);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 1);
QCOMPARE(applicationModalWindow1->blocked, 0);
// window2 gets finally the leave
QGuiApplication::processEvents();
QCOMPARE(window1->enters, 0);
QCOMPARE(window1->leaves, 0);
QCOMPARE(window2->enters, 1);
QCOMPARE(window2->leaves, 1);
QCOMPARE(windowModalWindow1->enters, 0);
QCOMPARE(windowModalWindow1->leaves, 0);
QCOMPARE(applicationModalWindow1->enters, 0);
QCOMPARE(applicationModalWindow1->leaves, 0);
// hide applicationModalWindow1, windowModalWindow1 and window1 are blocked
applicationModalWindow1->hide();
QCOMPARE(app.modalWindow(), windowModalWindow2.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 1);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// hide windowModalWindow2, window1 is blocked
windowModalWindow2->hide();
QCOMPARE(app.modalWindow(), windowModalWindow1.data());
QCOMPARE(window1->blocked, 1);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
// hide windowModalWindow1, everything is unblocked
windowModalWindow1->hide();
QCOMPARE(app.modalWindow(), static_cast<QWindow *>(nullptr));
QCOMPARE(window1->blocked, 0);
QCOMPARE(window2->blocked, 0);
QCOMPARE(windowModalWindow1->blocked, 0);
QCOMPARE(windowModalWindow2->blocked, 0);
QCOMPARE(applicationModalWindow1->blocked, 0);
window2->hide();
window1->hide();
}
void tst_QGuiApplication::quitOnLastWindowClosed()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
QTimer timer;
timer.setInterval(100);
QSignalSpy spyAboutToQuit(&app, &QCoreApplication::aboutToQuit);
QSignalSpy spyTimeout(&timer, &QTimer::timeout);
QWindow mainWindow;
mainWindow.setTitle(QStringLiteral("quitOnLastWindowClosedMainWindow"));
mainWindow.resize(windowSize, windowSize);
mainWindow.setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
QWindow dialog;
dialog.setTransientParent(&mainWindow);
dialog.setTitle(QStringLiteral("quitOnLastWindowClosedDialog"));
dialog.resize(windowSize, windowSize);
dialog.setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
QVERIFY(app.quitOnLastWindowClosed());
mainWindow.show();
dialog.show();
QVERIFY(QTest::qWaitForWindowExposed(&dialog));
timer.start();
QTimer::singleShot(1000, &mainWindow, &QWindow::close); // This should quit the application
QTimer::singleShot(2000, &app, QCoreApplication::quit); // This makes sure we quit even if it didn't
app.exec();
QCOMPARE(spyAboutToQuit.size(), 1);
// Should be around 10 if closing caused the quit
QVERIFY2(spyTimeout.size() < 15, QByteArray::number(spyTimeout.size()).constData());
}
void tst_QGuiApplication::quitOnLastWindowClosedMulti()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
const QRect screenGeometry = QGuiApplication::primaryScreen()->availableVirtualGeometry();
QSignalSpy spyAboutToQuit(&app, &QCoreApplication::aboutToQuit);
QWindow mainWindow;
mainWindow.setTitle(QStringLiteral("quitOnLastWindowClosedMultiMainWindow"));
mainWindow.resize(windowSize, windowSize);
mainWindow.setFramePosition(QPoint(screenGeometry.left() + spacing, screenGeometry.top() + spacing));
QWindow dialog;
dialog.setTitle(QStringLiteral("quitOnLastWindowClosedMultiDialog"));
dialog.resize(windowSize, windowSize);
dialog.setFramePosition(QPoint(screenGeometry.left() + 2 * spacing + windowSize, screenGeometry.top() + spacing));
QVERIFY(!dialog.transientParent());
QVERIFY(app.quitOnLastWindowClosed());
mainWindow.show();
dialog.show();
QVERIFY(QTest::qWaitForWindowExposed(&dialog));
bool prematureQuit = true;
QTimer::singleShot(100, &mainWindow, [&]{
prematureQuit = true; // this should be reset by the other timer
mainWindow.close();
});
QTimer::singleShot(500, &mainWindow, [&]{
prematureQuit = false; // if we don't get here, then the app quit prematurely
dialog.close();
});
app.exec();
QVERIFY(!prematureQuit);
QCOMPARE(spyAboutToQuit.size(), 1); // fired only once
}
void tst_QGuiApplication::dontQuitOnLastWindowClosed()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
app.setQuitOnLastWindowClosed(false);
QTimer timer;
timer.setInterval(2000);
timer.setSingleShot(true);
QObject::connect(&timer, &QTimer::timeout, &app, &QCoreApplication::quit);
QSignalSpy spyLastWindowClosed(&app, &QGuiApplication::lastWindowClosed);
QSignalSpy spyTimeout(&timer, &QTimer::timeout);
QScopedPointer<QWindow> mainWindow(new QWindow);
mainWindow->show();
QTimer::singleShot(1000, mainWindow.data(), &QWindow::close); // This should not quit the application
timer.start();
app.exec();
app.setQuitOnLastWindowClosed(true); // restore underlying static to default value
QCOMPARE(spyTimeout.size(), 1); // quit timer fired
QCOMPARE(spyLastWindowClosed.size(), 1); // lastWindowClosed emitted
}
class QuitSpy : public QObject
{
Q_OBJECT
public:
QuitSpy()
{
qGuiApp->installEventFilter(this);
}
bool eventFilter(QObject *o, QEvent *e) override
{
Q_UNUSED(o);
if (e->type() == QEvent::Quit)
++quits;
return false;
}
int quits = 0;
};
void tst_QGuiApplication::quitOnLastWindowClosedWithEventLoopLocker()
{
int argc = 0;
QGuiApplication app(argc, nullptr);
QVERIFY(app.quitOnLastWindowClosed());
QVERIFY(app.isQuitLockEnabled());
auto defaultRestorer = qScopeGuard([&]{
app.setQuitLockEnabled(true);
app.setQuitOnLastWindowClosed(true);
});
{
// Disabling QEventLoopLocker support should not affect
// quitting when last window is closed.
app.setQuitLockEnabled(false);
QuitSpy quitSpy;
QWindow window;
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, &window, &QWindow::close);
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 1);
}
{
// Disabling quitOnLastWindowClosed support should not affect
// quitting when last QEventLoopLocker goes out of scope.
app.setQuitLockEnabled(true);
app.setQuitOnLastWindowClosed(false);
QuitSpy quitSpy;
QScopedPointer<QEventLoopLocker> locker(new QEventLoopLocker);
QWindow window;
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, [&]{ locker.reset(nullptr); });
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 1);
}
{
// With both properties enabled we need to get rid of both
// the window and locker to trigger a quit.
app.setQuitLockEnabled(true);
app.setQuitOnLastWindowClosed(true);
QuitSpy quitSpy;
QScopedPointer<QEventLoopLocker> locker(new QEventLoopLocker);
QWindow window;
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, &window, &QWindow::close);
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 0);
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, [&]{ locker.reset(nullptr); });
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 0);
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, [&]{ locker.reset(nullptr); });
QTimer::singleShot(0, &window, &QWindow::close);
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 1);
}
{
// With neither properties enabled we don't get automatic quit.
app.setQuitLockEnabled(false);
app.setQuitOnLastWindowClosed(false);
QuitSpy quitSpy;
QScopedPointer<QEventLoopLocker> locker(new QEventLoopLocker);
QWindow window;
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
QTimer::singleShot(0, [&]{ locker.reset(nullptr); });
QTimer::singleShot(0, &window, &QWindow::close);
QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); });
app.exec();
QCOMPARE(quitSpy.quits, 0);
}
}
static Qt::ScreenOrientation testOrientationToSend = Qt::PrimaryOrientation;
class TestPlugin : public QObject
{
Q_OBJECT
public:
TestPlugin()
{
QScreen* screen = QGuiApplication::primaryScreen();
QWindowSystemInterface::handleScreenOrientationChange(screen, testOrientationToSend);
}
};
class TestPluginFactory : public QGenericPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QGenericPluginFactoryInterface" FILE "testplugin.json")
public:
QObject* create(const QString &key, const QString &) override
{
if (key == "testplugin")
return new TestPlugin;
return nullptr;
}
};
class TestEventReceiver : public QObject
{
Q_OBJECT
public:
int customEvents;
TestEventReceiver()
: customEvents(0)
{}
virtual void customEvent(QEvent *) override
{
customEvents++;
}
};
#include "tst_qguiapplication.moc"
void tst_QGuiApplication::genericPluginsAndWindowSystemEvents()
{
testOrientationToSend = Qt::InvertedLandscapeOrientation;
TestEventReceiver testReceiver;
QCoreApplication::postEvent(&testReceiver, new QEvent(QEvent::User));
QCOMPARE(testReceiver.customEvents, 0);
QStaticPlugin testPluginInfo(qt_plugin_instance, qt_plugin_query_metadata_v2);
qRegisterStaticPluginFunction(testPluginInfo);
int argc = 3;
char *argv[] = { const_cast<char*>(QTest::currentAppName()), const_cast<char*>("-plugin"), const_cast<char*>("testplugin") };
QGuiApplication app(argc, argv);
QVERIFY(QGuiApplication::primaryScreen());
QCOMPARE(QGuiApplication::primaryScreen()->orientation(), testOrientationToSend);
QCOMPARE(testReceiver.customEvents, 0);
QCoreApplication::sendPostedEvents(&testReceiver);
QCOMPARE(testReceiver.customEvents, 1);
}
Q_DECLARE_METATYPE(Qt::LayoutDirection)
void tst_QGuiApplication::layoutDirection()
{
qRegisterMetaType<Qt::LayoutDirection>();
const Qt::LayoutDirection oldDirection = QGuiApplication::layoutDirection();
const Qt::LayoutDirection newDirection = oldDirection == Qt::LeftToRight ? Qt::RightToLeft : Qt::LeftToRight;
QGuiApplication::setLayoutDirection(newDirection);
QCOMPARE(QGuiApplication::layoutDirection(), newDirection);
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
QSignalSpy signalSpy(&app, SIGNAL(layoutDirectionChanged(Qt::LayoutDirection)));
QGuiApplication::setLayoutDirection(oldDirection);
QCOMPARE(QGuiApplication::layoutDirection(), oldDirection);
QCOMPARE(signalSpy.size(), 1);
QCOMPARE(signalSpy.at(0).at(0).toInt(), static_cast<int>(oldDirection));
QGuiApplication::setLayoutDirection(oldDirection);
QCOMPARE(QGuiApplication::layoutDirection(), oldDirection);
QCOMPARE(signalSpy.size(), 1);
// with QGuiApplication instantiated, install a translator that gives us control
class LayoutDirectionTranslator : public QTranslator
{
public:
LayoutDirectionTranslator(Qt::LayoutDirection direction)
: direction(direction)
{}
bool isEmpty() const override { return false; }
QString translate(const char *context, const char *sourceText, const char *disambiguation, int n) const override
{
if (QByteArrayView(sourceText) == "QT_LAYOUT_DIRECTION")
return direction == Qt::LeftToRight ? QLatin1String("LTR") : QLatin1String("RTL");
return QTranslator::translate(context, sourceText, disambiguation, n);
}
const Qt::LayoutDirection direction;
};
int layoutDirectionChangedCount = 0;
// reset to auto-detection, should be back to oldDirection now
QGuiApplication::setLayoutDirection(Qt::LayoutDirectionAuto);
QCOMPARE(QGuiApplication::layoutDirection(), oldDirection);
signalSpy.clear();
{
// this translator doesn't change the direction
LayoutDirectionTranslator translator(oldDirection);
QGuiApplication::installTranslator(&translator);
QCOMPARE(QGuiApplication::layoutDirection(), translator.direction);
QCOMPARE(signalSpy.size(), layoutDirectionChangedCount);
}
QCOMPARE(signalSpy.size(), layoutDirectionChangedCount); // ltrTranslator removed, no change
// install a new translator that changes the direction
{
LayoutDirectionTranslator translator(newDirection);
QGuiApplication::installTranslator(&translator);
QCOMPARE(QGuiApplication::layoutDirection(), translator.direction);
QCOMPARE(signalSpy.size(), ++layoutDirectionChangedCount);
}
// rtlTranslator removed
QCOMPARE(signalSpy.size(), ++layoutDirectionChangedCount);
// override translation
QGuiApplication::setLayoutDirection(newDirection);
QCOMPARE(signalSpy.size(), ++layoutDirectionChangedCount);
{
// this translator will be ignored
LayoutDirectionTranslator translator(oldDirection);
QGuiApplication::installTranslator(&translator);
QCOMPARE(QGuiApplication::layoutDirection(), newDirection);
QCOMPARE(signalSpy.size(), layoutDirectionChangedCount);
}
QCOMPARE(signalSpy.size(), layoutDirectionChangedCount);
}
void tst_QGuiApplication::globalShareContext()
{
#ifndef QT_NO_OPENGL
// Test that there is a global share context when requested.
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QScopedPointer<QGuiApplication> app(new QGuiApplication(argc, argv));
QOpenGLContext *ctx = qt_gl_global_share_context();
QVERIFY(ctx);
app.reset();
ctx = qt_gl_global_share_context();
QVERIFY(!ctx);
// Test that there is no global share context by default.
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, false);
app.reset(new QGuiApplication(argc, argv));
ctx = qt_gl_global_share_context();
QVERIFY(!ctx);
#else
QSKIP("No OpenGL support");
#endif
}
void tst_QGuiApplication::testSetPaletteAttribute()
{
QCoreApplication::setAttribute(Qt::AA_SetPalette, false);
int argc = 1;
char *argv[] = { const_cast<char*>("tst_qguiapplication") };
QGuiApplication app(argc, argv);
QVERIFY(!QCoreApplication::testAttribute(Qt::AA_SetPalette));
QPalette palette;
palette.setColor(QPalette::WindowText, Qt::red);
QGuiApplication::setPalette(palette);
QVERIFY(QCoreApplication::testAttribute(Qt::AA_SetPalette));
QGuiApplication::setPalette(QPalette());
QVERIFY(!QCoreApplication::testAttribute(Qt::AA_SetPalette));
}
// Test that static functions do not crash if there is no application instance.
void tst_QGuiApplication::staticFunctions()
{
QGuiApplication::setApplicationDisplayName(QString());
QGuiApplication::applicationDisplayName();
QGuiApplication::allWindows();
QGuiApplication::topLevelWindows();
QGuiApplication::topLevelAt(QPoint(0, 0));
QGuiApplication::setWindowIcon(QIcon());
QGuiApplication::windowIcon();
QGuiApplication::platformName();
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::modalWindow();
QGuiApplication::focusWindow();
QGuiApplication::focusObject();
QGuiApplication::primaryScreen();
QGuiApplication::screens();
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::overrideCursor();
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::setOverrideCursor(QCursor());
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::changeOverrideCursor(QCursor());
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::restoreOverrideCursor();
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::keyboardModifiers();
QTest::ignoreMessage(QtWarningMsg, "Must construct a QGuiApplication first.");
QGuiApplication::queryKeyboardModifiers();
QGuiApplication::mouseButtons();
QGuiApplication::setLayoutDirection(Qt::LeftToRight);
QGuiApplication::layoutDirection();
QGuiApplication::styleHints();
QGuiApplication::setDesktopSettingsAware(true);
QGuiApplication::desktopSettingsAware();
QGuiApplication::inputMethod();
QGuiApplication::platformNativeInterface();
QTest::ignoreMessage(QtWarningMsg, "QGuiApplication::platformFunction(): Must construct a QGuiApplication before accessing a platform function");
QGuiApplication::platformFunction(QByteArrayLiteral("bla"));
QGuiApplication::setQuitOnLastWindowClosed(true);
QGuiApplication::quitOnLastWindowClosed();
QGuiApplication::applicationState();
QTest::ignoreMessage(QtWarningMsg, "QPixmap: QGuiApplication must be created before calling defaultDepth().");
QPixmap::defaultDepth();
}
void tst_QGuiApplication::settableStyleHints_data()
{
QTest::addColumn<bool>("appInstance");
QTest::newRow("app") << true;
QTest::newRow("no-app") << false;
}
void tst_QGuiApplication::settableStyleHints()
{
QFETCH(bool, appInstance);
int argc = 0;
QScopedPointer<QGuiApplication> app;
if (appInstance)
app.reset(new QGuiApplication(argc, nullptr));
const int keyboardInputInterval = 555;
QGuiApplication::styleHints()->setKeyboardInputInterval(keyboardInputInterval);
QCOMPARE(QGuiApplication::styleHints()->keyboardInputInterval(), keyboardInputInterval);
}
QTEST_APPLESS_MAIN(tst_QGuiApplication)
Reference in New Issue View Git Blame Copy Permalink