2020-08-02 22:22:19 +00:00
|
|
|
|
/*
|
|
|
|
|
KWin - the KDE window manager
|
|
|
|
|
This file is part of the KDE project.
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
|
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
|
SPDX-FileCopyrightText: 2019 David Edmundson <davidedmundson@kde.org>
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
|
*/
|
2016-06-07 09:43:56 +00:00
|
|
|
|
#include "kwin_wayland_test.h"
|
2020-03-04 07:55:26 +00:00
|
|
|
|
#include "abstract_client.h"
|
2020-11-23 18:24:37 +00:00
|
|
|
|
#include "abstract_wayland_output.h"
|
2016-06-07 09:43:56 +00:00
|
|
|
|
#include "cursor.h"
|
2019-06-11 13:24:24 +00:00
|
|
|
|
#include "decorations/decorationbridge.h"
|
|
|
|
|
#include "decorations/settings.h"
|
2016-07-01 14:03:13 +00:00
|
|
|
|
#include "effects.h"
|
2018-11-18 19:13:55 +00:00
|
|
|
|
#include "deleted.h"
|
2016-06-07 09:43:56 +00:00
|
|
|
|
#include "platform.h"
|
|
|
|
|
#include "screens.h"
|
|
|
|
|
#include "wayland_server.h"
|
2016-06-14 11:46:28 +00:00
|
|
|
|
#include "workspace.h"
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2019-06-11 13:24:24 +00:00
|
|
|
|
#include <KDecoration2/DecoratedClient>
|
|
|
|
|
#include <KDecoration2/Decoration>
|
|
|
|
|
#include <KDecoration2/DecorationSettings>
|
2017-12-22 17:23:44 +00:00
|
|
|
|
|
2016-06-07 09:43:56 +00:00
|
|
|
|
#include <KWayland/Client/connection_thread.h>
|
|
|
|
|
#include <KWayland/Client/compositor.h>
|
2017-08-24 16:57:30 +00:00
|
|
|
|
#include <KWayland/Client/output.h>
|
2020-07-14 11:34:25 +00:00
|
|
|
|
#include <KWayland/Client/pointer.h>
|
|
|
|
|
#include <KWayland/Client/seat.h>
|
2016-09-12 12:14:20 +00:00
|
|
|
|
#include <KWayland/Client/server_decoration.h>
|
2019-10-03 19:43:28 +00:00
|
|
|
|
#include <KWayland/Client/subsurface.h>
|
2016-06-07 09:43:56 +00:00
|
|
|
|
#include <KWayland/Client/surface.h>
|
2016-09-12 10:03:18 +00:00
|
|
|
|
#include <KWayland/Client/xdgshell.h>
|
2019-01-01 17:37:18 +00:00
|
|
|
|
#include <KWayland/Client/xdgdecoration.h>
|
2017-12-22 14:22:24 +00:00
|
|
|
|
#include <KWayland/Client/appmenu.h>
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-04-29 15:18:41 +00:00
|
|
|
|
#include <KWaylandServer/clientconnection.h>
|
|
|
|
|
#include <KWaylandServer/display.h>
|
2017-12-22 14:22:24 +00:00
|
|
|
|
|
2019-06-11 13:24:24 +00:00
|
|
|
|
#include <QDBusConnection>
|
|
|
|
|
|
2016-11-15 15:48:20 +00:00
|
|
|
|
// system
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/socket.h>
|
|
|
|
|
#include <unistd.h>
|
2019-07-09 19:19:26 +00:00
|
|
|
|
|
|
|
|
|
#include <csignal>
|
2016-11-15 15:48:20 +00:00
|
|
|
|
|
2016-06-07 09:43:56 +00:00
|
|
|
|
using namespace KWin;
|
|
|
|
|
using namespace KWayland::Client;
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
static const QString s_socketName = QStringLiteral("wayland_test_kwin_xdgshellclient-0");
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
class TestXdgShellClient : public QObject
|
2016-06-07 09:43:56 +00:00
|
|
|
|
{
|
|
|
|
|
Q_OBJECT
|
|
|
|
|
private Q_SLOTS:
|
|
|
|
|
void initTestCase();
|
|
|
|
|
void init();
|
|
|
|
|
void cleanup();
|
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
void testMapUnmap();
|
2016-07-01 14:03:13 +00:00
|
|
|
|
void testDesktopPresenceChanged();
|
2017-08-24 16:57:30 +00:00
|
|
|
|
void testWindowOutputs();
|
2016-08-11 15:08:08 +00:00
|
|
|
|
void testMinimizeActiveWindow();
|
2016-09-12 10:03:18 +00:00
|
|
|
|
void testFullscreen_data();
|
|
|
|
|
void testFullscreen();
|
2019-06-11 13:24:24 +00:00
|
|
|
|
|
2019-02-22 18:54:52 +00:00
|
|
|
|
void testFullscreenRestore();
|
2017-10-07 09:41:17 +00:00
|
|
|
|
void testUserCanSetFullscreen();
|
2019-08-27 15:01:14 +00:00
|
|
|
|
void testUserSetFullscreen();
|
|
|
|
|
|
|
|
|
|
void testMaximizedToFullscreen_data();
|
|
|
|
|
void testMaximizedToFullscreen();
|
2020-11-23 18:24:37 +00:00
|
|
|
|
void testFullscreenMultipleOutputs();
|
2016-09-14 12:08:47 +00:00
|
|
|
|
void testWindowOpensLargerThanScreen();
|
2016-10-11 14:24:10 +00:00
|
|
|
|
void testHidden();
|
2016-10-27 13:59:08 +00:00
|
|
|
|
void testDesktopFileName();
|
2016-10-31 14:50:14 +00:00
|
|
|
|
void testCaptionSimplified();
|
2017-08-20 06:56:13 +00:00
|
|
|
|
void testCaptionMultipleWindows();
|
XdgV6 - Kwin side
Summary:
Adds XDGV6 support for the kwin side.
Popup placement support is limited to the stuff v5 had,
a simple offset, rather than the awesome new positioner.
But Qt doesn't make use of it yet either.
Also ideally we should do all the positioning before sending the first
configure, but again Qt doesn't actually do anything with that anyway.
Also integrate pinging clients
Test Plan: gtk3-demo works nicely.
Reviewers: #plasma, graesslin, mart
Reviewed By: #plasma, graesslin
Subscribers: mart, graesslin, kwin, plasma-devel, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6591
2017-09-25 15:37:59 +00:00
|
|
|
|
void testUnresponsiveWindow_data();
|
|
|
|
|
void testUnresponsiveWindow();
|
2017-12-22 14:22:24 +00:00
|
|
|
|
void testAppMenu();
|
2018-02-19 21:10:17 +00:00
|
|
|
|
void testNoDecorationModeRequested();
|
2018-12-12 17:25:51 +00:00
|
|
|
|
void testSendClientWithTransientToDesktop();
|
2018-12-13 16:47:10 +00:00
|
|
|
|
void testMinimizeWindowWithTransients();
|
2019-01-01 17:37:18 +00:00
|
|
|
|
void testXdgDecoration_data();
|
|
|
|
|
void testXdgDecoration();
|
2019-02-26 13:41:07 +00:00
|
|
|
|
void testXdgNeverCommitted();
|
|
|
|
|
void testXdgInitialState();
|
|
|
|
|
void testXdgInitiallyMaximised();
|
2019-10-11 08:46:08 +00:00
|
|
|
|
void testXdgInitiallyFullscreen();
|
2019-02-26 13:41:07 +00:00
|
|
|
|
void testXdgInitiallyMinimized();
|
2019-10-03 19:43:28 +00:00
|
|
|
|
void testXdgWindowGeometryIsntSet();
|
|
|
|
|
void testXdgWindowGeometryAttachBuffer();
|
|
|
|
|
void testXdgWindowGeometryAttachSubSurface();
|
|
|
|
|
void testXdgWindowGeometryInteractiveResize();
|
|
|
|
|
void testXdgWindowGeometryFullScreen();
|
|
|
|
|
void testXdgWindowGeometryMaximize();
|
2021-01-06 01:08:25 +00:00
|
|
|
|
void testXdgWindowReactive();
|
|
|
|
|
void testXdgWindowRepositioning();
|
2020-07-14 11:34:25 +00:00
|
|
|
|
void testPointerInputTransform();
|
2020-07-20 19:33:19 +00:00
|
|
|
|
void testReentrantSetFrameGeometry();
|
2020-10-14 18:53:07 +00:00
|
|
|
|
void testDoubleMaximize();
|
2016-06-07 09:43:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2021-01-06 01:08:25 +00:00
|
|
|
|
void TestXdgShellClient::testXdgWindowReactive()
|
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Test::XdgPositioner> positioner(Test::createXdgPositioner());
|
|
|
|
|
positioner->set_size(10, 10);
|
|
|
|
|
positioner->set_anchor_rect(10, 10, 10, 10);
|
|
|
|
|
positioner->set_reactive();
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> rootSurface(Test::createSurface());
|
|
|
|
|
QScopedPointer<Surface> childSurface(Test::createSurface());
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Test::XdgToplevel> root(Test::createXdgToplevelSurface(rootSurface.data()));
|
|
|
|
|
QScopedPointer<Test::XdgPopup> popup(Test::createXdgPopupSurface(childSurface.data(), root->xdgSurface(), positioner.data()));
|
|
|
|
|
|
|
|
|
|
auto rootClient = Test::renderAndWaitForShown(rootSurface.data(), QSize(100, 100), Qt::cyan);
|
|
|
|
|
auto childClient = Test::renderAndWaitForShown(childSurface.data(), QSize(10, 10), Qt::cyan);
|
|
|
|
|
|
|
|
|
|
QVERIFY(rootClient);
|
|
|
|
|
QVERIFY(childClient);
|
|
|
|
|
|
|
|
|
|
QSignalSpy frameGeometryChangedSpy(childClient, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
|
|
|
|
|
|
|
|
|
rootClient->move(rootClient->x()+20, rootClient->y()+20);
|
|
|
|
|
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgWindowRepositioning()
|
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Test::XdgPositioner> positioner(Test::createXdgPositioner());
|
|
|
|
|
positioner->set_size(10, 10);
|
|
|
|
|
positioner->set_anchor_rect(10, 10, 10, 10);
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Test::XdgPositioner> otherPositioner(Test::createXdgPositioner());
|
|
|
|
|
otherPositioner->set_size(50, 50);
|
|
|
|
|
otherPositioner->set_anchor_rect(10, 10, 10, 10);
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> rootSurface(Test::createSurface());
|
|
|
|
|
QScopedPointer<Surface> childSurface(Test::createSurface());
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Test::XdgToplevel> root(Test::createXdgToplevelSurface(rootSurface.data()));
|
|
|
|
|
QScopedPointer<Test::XdgPopup> popup(Test::createXdgPopupSurface(childSurface.data(), root->xdgSurface(), positioner.data()));
|
|
|
|
|
|
|
|
|
|
auto rootClient = Test::renderAndWaitForShown(rootSurface.data(), QSize(100, 100), Qt::cyan);
|
|
|
|
|
auto childClient = Test::renderAndWaitForShown(childSurface.data(), QSize(10, 10), Qt::cyan);
|
|
|
|
|
|
|
|
|
|
QVERIFY(rootClient);
|
|
|
|
|
QVERIFY(childClient);
|
|
|
|
|
|
|
|
|
|
QSignalSpy reconfigureSpy(popup.data(), &Test::XdgPopup::configureRequested);
|
|
|
|
|
QVERIFY(reconfigureSpy.isValid());
|
|
|
|
|
|
|
|
|
|
popup->reposition(otherPositioner->object(), 500000);
|
|
|
|
|
|
|
|
|
|
QVERIFY(reconfigureSpy.wait());
|
|
|
|
|
QCOMPARE(reconfigureSpy.count(), 1);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::initTestCase()
|
2016-06-07 09:43:56 +00:00
|
|
|
|
{
|
2018-11-18 19:13:55 +00:00
|
|
|
|
qRegisterMetaType<KWin::Deleted*>();
|
2016-06-07 09:43:56 +00:00
|
|
|
|
qRegisterMetaType<KWin::AbstractClient*>();
|
2017-08-24 16:57:30 +00:00
|
|
|
|
qRegisterMetaType<KWayland::Client::Output*>();
|
|
|
|
|
|
2020-07-07 09:32:29 +00:00
|
|
|
|
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
|
|
|
|
|
QVERIFY(applicationStartedSpy.isValid());
|
2016-06-07 09:43:56 +00:00
|
|
|
|
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
|
2020-12-09 13:06:15 +00:00
|
|
|
|
QVERIFY(waylandServer()->init(s_socketName));
|
2019-08-26 21:16:53 +00:00
|
|
|
|
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
|
|
|
|
kwinApp()->start();
|
2020-07-07 09:32:29 +00:00
|
|
|
|
QVERIFY(applicationStartedSpy.wait());
|
2016-06-07 09:43:56 +00:00
|
|
|
|
QCOMPARE(screens()->count(), 2);
|
|
|
|
|
QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
|
|
|
|
|
QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
|
|
|
|
|
waylandServer()->initWorkspace();
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::init()
|
2016-06-07 09:43:56 +00:00
|
|
|
|
{
|
2017-12-22 14:22:24 +00:00
|
|
|
|
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration |
|
2020-07-14 11:34:25 +00:00
|
|
|
|
Test::AdditionalWaylandInterface::Seat |
|
2019-01-01 17:37:18 +00:00
|
|
|
|
Test::AdditionalWaylandInterface::XdgDecoration |
|
2017-12-22 14:22:24 +00:00
|
|
|
|
Test::AdditionalWaylandInterface::AppMenu));
|
2020-07-14 11:34:25 +00:00
|
|
|
|
QVERIFY(Test::waitForWaylandPointer());
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
|
|
|
|
screens()->setCurrent(0);
|
2020-11-30 22:14:23 +00:00
|
|
|
|
//put mouse in the middle of screen one
|
|
|
|
|
KWin::Cursors::self()->mouse()->setPos(QPoint(512, 512));
|
2016-06-07 09:43:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::cleanup()
|
2016-06-07 09:43:56 +00:00
|
|
|
|
{
|
2016-06-30 11:32:54 +00:00
|
|
|
|
Test::destroyWaylandConnection();
|
2016-06-07 09:43:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
void TestXdgShellClient::testMapUnmap()
|
2016-04-22 12:13:37 +00:00
|
|
|
|
{
|
2020-05-07 14:29:41 +00:00
|
|
|
|
// This test verifies that the compositor destroys XdgToplevelClient when the
|
|
|
|
|
// associated xdg_toplevel surface is unmapped.
|
2016-04-22 12:13:37 +00:00
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
// Create a wl_surface and an xdg_toplevel, but don't commit them yet!
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(
|
|
|
|
|
Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
2016-04-22 12:13:37 +00:00
|
|
|
|
|
2020-07-22 18:35:41 +00:00
|
|
|
|
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
|
2016-06-07 09:43:56 +00:00
|
|
|
|
QVERIFY(clientAddedSpy.isValid());
|
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
// Tell the compositor that we want to map the surface.
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
// The compositor will respond with a configure event.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
// Now we can attach a buffer with actual data to the surface.
|
|
|
|
|
Test::render(surface.data(), QSize(100, 50), Qt::blue);
|
2016-06-07 09:43:56 +00:00
|
|
|
|
QVERIFY(clientAddedSpy.wait());
|
2020-05-07 14:29:41 +00:00
|
|
|
|
QCOMPARE(clientAddedSpy.count(), 1);
|
|
|
|
|
AbstractClient *client = clientAddedSpy.last().first().value<AbstractClient *>();
|
2016-06-07 09:43:56 +00:00
|
|
|
|
QVERIFY(client);
|
2016-07-04 13:06:20 +00:00
|
|
|
|
QCOMPARE(client->readyForPainting(), true);
|
2020-05-07 14:29:41 +00:00
|
|
|
|
|
|
|
|
|
// When the client becomes active, the compositor will send another configure event.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
|
|
|
|
|
// Unmap the xdg_toplevel surface by committing a null buffer.
|
2016-06-07 09:43:56 +00:00
|
|
|
|
surface->attachBuffer(Buffer::Ptr());
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-05-07 14:29:41 +00:00
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
|
|
|
|
|
// Tell the compositor that we want to re-map the xdg_toplevel surface.
|
2016-06-07 09:43:56 +00:00
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-05-07 14:29:41 +00:00
|
|
|
|
|
|
|
|
|
// The compositor will respond with a configure event.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
|
|
|
|
|
// Now we can attach a buffer with actual data to the surface.
|
|
|
|
|
Test::render(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(clientAddedSpy.wait());
|
|
|
|
|
QCOMPARE(clientAddedSpy.count(), 2);
|
|
|
|
|
client = clientAddedSpy.last().first().value<AbstractClient *>();
|
|
|
|
|
QVERIFY(client);
|
2016-07-04 13:37:30 +00:00
|
|
|
|
QCOMPARE(client->readyForPainting(), true);
|
2016-06-07 09:43:56 +00:00
|
|
|
|
|
2020-05-07 14:29:41 +00:00
|
|
|
|
// The compositor will respond with a configure event.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 4);
|
|
|
|
|
|
|
|
|
|
// Destroy the test client.
|
2016-06-07 09:43:56 +00:00
|
|
|
|
shellSurface.reset();
|
2020-05-07 14:29:41 +00:00
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
2016-06-07 09:43:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testDesktopPresenceChanged()
|
2016-07-01 14:03:13 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that the desktop presence changed signals are properly emitted
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2016-07-01 14:03:13 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QCOMPARE(c->desktop(), 1);
|
|
|
|
|
effects->setNumberOfDesktops(4);
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy desktopPresenceChangedClientSpy(c, &AbstractClient::desktopPresenceChanged);
|
2016-07-01 14:03:13 +00:00
|
|
|
|
QVERIFY(desktopPresenceChangedClientSpy.isValid());
|
|
|
|
|
QSignalSpy desktopPresenceChangedWorkspaceSpy(workspace(), &Workspace::desktopPresenceChanged);
|
|
|
|
|
QVERIFY(desktopPresenceChangedWorkspaceSpy.isValid());
|
|
|
|
|
QSignalSpy desktopPresenceChangedEffectsSpy(effects, &EffectsHandler::desktopPresenceChanged);
|
|
|
|
|
QVERIFY(desktopPresenceChangedEffectsSpy.isValid());
|
|
|
|
|
|
|
|
|
|
// let's change the desktop
|
|
|
|
|
workspace()->sendClientToDesktop(c, 2, false);
|
|
|
|
|
QCOMPARE(c->desktop(), 2);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedClientSpy.count(), 1);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedWorkspaceSpy.count(), 1);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedEffectsSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
// verify the arguments
|
|
|
|
|
QCOMPARE(desktopPresenceChangedClientSpy.first().at(0).value<AbstractClient*>(), c);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedClientSpy.first().at(1).toInt(), 1);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(0).value<AbstractClient*>(), c);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(1).toInt(), 1);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(0).value<EffectWindow*>(), c->effectWindow());
|
|
|
|
|
QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(1).toInt(), 1);
|
|
|
|
|
QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(2).toInt(), 2);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testWindowOutputs()
|
2017-08-24 16:57:30 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2017-08-24 16:57:30 +00:00
|
|
|
|
auto size = QSize(200,200);
|
|
|
|
|
|
|
|
|
|
QSignalSpy outputEnteredSpy(surface.data(), &Surface::outputEntered);
|
|
|
|
|
QSignalSpy outputLeftSpy(surface.data(), &Surface::outputLeft);
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
|
|
|
|
|
//move to be in the first screen
|
2019-09-27 10:01:10 +00:00
|
|
|
|
c->setFrameGeometry(QRect(QPoint(100,100), size));
|
2017-08-24 16:57:30 +00:00
|
|
|
|
//we don't don't know where the compositor first placed this window,
|
|
|
|
|
//this might fire, it might not
|
|
|
|
|
outputEnteredSpy.wait(5);
|
|
|
|
|
outputEnteredSpy.clear();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(surface->outputs().count(), 1);
|
|
|
|
|
QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(0,0));
|
|
|
|
|
|
|
|
|
|
//move to overlapping both first and second screen
|
2019-09-27 10:01:10 +00:00
|
|
|
|
c->setFrameGeometry(QRect(QPoint(1250,100), size));
|
2017-08-24 16:57:30 +00:00
|
|
|
|
QVERIFY(outputEnteredSpy.wait());
|
|
|
|
|
QCOMPARE(outputEnteredSpy.count(), 1);
|
|
|
|
|
QCOMPARE(outputLeftSpy.count(), 0);
|
|
|
|
|
QCOMPARE(surface->outputs().count(), 2);
|
|
|
|
|
QVERIFY(surface->outputs()[0] != surface->outputs()[1]);
|
|
|
|
|
|
|
|
|
|
//move entirely into second screen
|
2019-09-27 10:01:10 +00:00
|
|
|
|
c->setFrameGeometry(QRect(QPoint(1400,100), size));
|
2017-08-24 16:57:30 +00:00
|
|
|
|
QVERIFY(outputLeftSpy.wait());
|
|
|
|
|
QCOMPARE(outputEnteredSpy.count(), 1);
|
|
|
|
|
QCOMPARE(outputLeftSpy.count(), 1);
|
|
|
|
|
QCOMPARE(surface->outputs().count(), 1);
|
|
|
|
|
QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(1280,0));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testMinimizeActiveWindow()
|
2016-08-11 15:08:08 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that when minimizing the active window it gets deactivated
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<QObject> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2016-08-11 15:08:08 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
QCOMPARE(workspace()->activeClient(), c);
|
2016-09-12 08:01:02 +00:00
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
|
|
|
|
QVERIFY(c->isShown(true));
|
2016-08-11 15:08:08 +00:00
|
|
|
|
|
|
|
|
|
workspace()->slotWindowMinimize();
|
2016-09-12 08:01:02 +00:00
|
|
|
|
QVERIFY(!c->isShown(true));
|
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
2016-08-11 15:08:08 +00:00
|
|
|
|
QVERIFY(!c->isActive());
|
|
|
|
|
QVERIFY(!workspace()->activeClient());
|
2016-08-18 08:30:27 +00:00
|
|
|
|
QVERIFY(c->isMinimized());
|
|
|
|
|
|
|
|
|
|
// unminimize again
|
|
|
|
|
c->unminimize();
|
|
|
|
|
QVERIFY(!c->isMinimized());
|
|
|
|
|
QVERIFY(c->isActive());
|
2016-09-12 08:01:02 +00:00
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
|
|
|
|
QVERIFY(c->isShown(true));
|
2016-08-18 08:30:27 +00:00
|
|
|
|
QCOMPARE(workspace()->activeClient(), c);
|
2016-08-11 15:08:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testFullscreen_data()
|
2016-09-12 10:03:18 +00:00
|
|
|
|
{
|
2016-09-12 12:14:20 +00:00
|
|
|
|
QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
|
2016-09-12 10:03:18 +00:00
|
|
|
|
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QTest::newRow("client-side deco") << ServerSideDecoration::Mode::Client;
|
|
|
|
|
QTest::newRow("server-side deco") << ServerSideDecoration::Mode::Server;
|
2016-09-12 10:03:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testFullscreen()
|
2016-09-12 10:03:18 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that a window can be properly fullscreened
|
2020-02-17 18:39:17 +00:00
|
|
|
|
|
|
|
|
|
XdgShellSurface::States states;
|
|
|
|
|
|
2016-09-12 10:03:18 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2019-07-29 19:45:19 +00:00
|
|
|
|
QVERIFY(shellSurface);
|
2018-10-05 14:27:05 +00:00
|
|
|
|
|
2016-09-12 12:14:20 +00:00
|
|
|
|
// create deco
|
|
|
|
|
QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
|
|
|
|
|
QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
|
|
|
|
|
QVERIFY(decoSpy.isValid());
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
QFETCH(ServerSideDecoration::Mode, decoMode);
|
|
|
|
|
deco->requestMode(decoMode);
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
QCOMPARE(deco->mode(), decoMode);
|
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QCOMPARE(client->layer(), NormalLayer);
|
|
|
|
|
QVERIFY(!client->isFullScreen());
|
|
|
|
|
QCOMPARE(client->clientSize(), QSize(100, 50));
|
|
|
|
|
QCOMPARE(client->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
|
|
|
|
|
QCOMPARE(client->clientSizeToFrameSize(client->clientSize()), client->size());
|
|
|
|
|
|
|
|
|
|
QSignalSpy fullScreenChangedSpy(client, &AbstractClient::fullScreenChanged);
|
|
|
|
|
QVERIFY(fullScreenChangedSpy.isValid());
|
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-07-29 19:45:19 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
2018-10-05 14:27:05 +00:00
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
// Wait for the compositor to send a configure event with the Activated state.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Activated);
|
|
|
|
|
|
|
|
|
|
// Ask the compositor to show the window in full screen mode.
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->setFullscreen(true);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Fullscreen);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), screens()->size(0));
|
2016-09-12 10:03:18 +00:00
|
|
|
|
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::red);
|
|
|
|
|
|
|
|
|
|
#if 0 // TODO: Uncomment when full screen state updates are truly asynchronous.
|
|
|
|
|
QVERIFY(fullScreenChangedSpy.wait());
|
|
|
|
|
QCOMPARE(fullScreenChangedSpy.count(), 1);
|
|
|
|
|
#else
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QCOMPARE(fullScreenChangedSpy.count(), 1);
|
|
|
|
|
#endif
|
|
|
|
|
QVERIFY(client->isFullScreen());
|
|
|
|
|
QVERIFY(!client->isDecorated());
|
|
|
|
|
QCOMPARE(client->layer(), ActiveLayer);
|
|
|
|
|
QCOMPARE(client->frameGeometry(), QRect(QPoint(0, 0), screens()->size(0)));
|
2016-09-12 10:03:18 +00:00
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
// Ask the compositor to show the window in normal mode.
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->setFullscreen(false);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(!(states & XdgShellSurface::State::Fullscreen));
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), QSize(100, 50));
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::blue);
|
|
|
|
|
|
|
|
|
|
#if 0 // TODO: Uncomment when full screen state updates are truly asynchronous.
|
|
|
|
|
QVERIFY(fullScreenChangedSpy.wait());
|
|
|
|
|
QCOMPARE(fullScreenChangedSpy.count(), 2);
|
|
|
|
|
#else
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(fullScreenChangedSpy.count(), 2);
|
|
|
|
|
#endif
|
|
|
|
|
QCOMPARE(client->clientSize(), QSize(100, 50));
|
|
|
|
|
QVERIFY(!client->isFullScreen());
|
|
|
|
|
QCOMPARE(client->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
|
|
|
|
|
QCOMPARE(client->layer(), NormalLayer);
|
|
|
|
|
|
|
|
|
|
// Destroy the client.
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
2016-09-12 12:41:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testFullscreenRestore()
|
2019-02-22 18:54:52 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that windows created fullscreen can be later properly restored
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
XdgShellSurface *xdgShellSurface = Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly);
|
2019-07-29 19:45:19 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(xdgShellSurface, &XdgShellSurface::configureRequested);
|
2019-02-22 18:54:52 +00:00
|
|
|
|
|
|
|
|
|
// fullscreen the window
|
|
|
|
|
xdgShellSurface->setFullscreen(true);
|
2019-02-26 13:41:07 +00:00
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2019-02-22 18:54:52 +00:00
|
|
|
|
|
2019-02-26 13:41:07 +00:00
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
const auto size = configureRequestedSpy.first()[0].value<QSize>();
|
|
|
|
|
const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(size, screens()->size(0));
|
|
|
|
|
QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
|
|
|
|
|
xdgShellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
|
2019-02-22 18:54:52 +00:00
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isFullScreen());
|
|
|
|
|
|
2019-02-26 13:41:07 +00:00
|
|
|
|
configureRequestedSpy.wait(100);
|
|
|
|
|
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
|
2019-02-22 18:54:52 +00:00
|
|
|
|
QVERIFY(fullscreenChangedSpy.isValid());
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-02-22 18:54:52 +00:00
|
|
|
|
|
|
|
|
|
// swap back to normal
|
2019-02-26 13:41:07 +00:00
|
|
|
|
configureRequestedSpy.clear();
|
2019-02-22 18:54:52 +00:00
|
|
|
|
xdgShellSurface->setFullscreen(false);
|
|
|
|
|
|
|
|
|
|
QVERIFY(fullscreenChangedSpy.wait());
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().first().toSize(), QSize(0, 0));
|
|
|
|
|
QVERIFY(!c->isFullScreen());
|
|
|
|
|
|
|
|
|
|
for (const auto &it: configureRequestedSpy) {
|
2019-02-26 13:41:07 +00:00
|
|
|
|
xdgShellSurface->ackConfigure(it[2].toUInt());
|
2019-02-22 18:54:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Test::render(surface.data(), QSize(100, 50), Qt::red);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 1);
|
2019-02-22 18:54:52 +00:00
|
|
|
|
QVERIFY(!c->isFullScreen());
|
2019-09-27 10:01:10 +00:00
|
|
|
|
QCOMPARE(c->frameGeometry().size(), QSize(100, 50));
|
2019-02-22 18:54:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testUserCanSetFullscreen()
|
2017-10-07 09:41:17 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2017-10-07 09:41:17 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
QVERIFY(!c->isFullScreen());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QVERIFY(c->userCanSetFullScreen());
|
2017-10-07 09:41:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testUserSetFullscreen()
|
2017-10-07 09:41:17 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(
|
|
|
|
|
surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
|
2017-10-07 09:41:17 +00:00
|
|
|
|
QVERIFY(!shellSurface.isNull());
|
2019-02-26 13:41:07 +00:00
|
|
|
|
|
|
|
|
|
// wait for the initial configure event
|
2017-10-07 09:41:17 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
2019-02-26 13:41:07 +00:00
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
2017-10-07 09:41:17 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
QVERIFY(!c->isFullScreen());
|
|
|
|
|
|
2019-02-26 13:41:07 +00:00
|
|
|
|
// The client gets activated, which gets another configure event. Though that's not relevant to the test
|
|
|
|
|
configureRequestedSpy.wait(10);
|
2017-10-07 09:41:17 +00:00
|
|
|
|
|
|
|
|
|
QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
|
|
|
|
|
QVERIFY(fullscreenChangedSpy.isValid());
|
|
|
|
|
c->setFullScreen(true);
|
|
|
|
|
QCOMPARE(c->isFullScreen(), true);
|
|
|
|
|
configureRequestedSpy.clear();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.first().at(0).toSize(), screens()->size(0));
|
|
|
|
|
const auto states = configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
|
|
|
|
|
QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Activated));
|
|
|
|
|
QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Maximized));
|
|
|
|
|
QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Resizing));
|
|
|
|
|
QCOMPARE(fullscreenChangedSpy.count(), 1);
|
|
|
|
|
QVERIFY(c->isFullScreen());
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.first().at(2).value<quint32>());
|
|
|
|
|
|
|
|
|
|
// unset fullscreen again
|
|
|
|
|
c->setFullScreen(false);
|
|
|
|
|
QCOMPARE(c->isFullScreen(), false);
|
|
|
|
|
configureRequestedSpy.clear();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.first().at(0).toSize(), QSize(100, 50));
|
|
|
|
|
QVERIFY(!configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>().testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
|
|
|
|
|
QCOMPARE(fullscreenChangedSpy.count(), 2);
|
|
|
|
|
QVERIFY(!c->isFullScreen());
|
|
|
|
|
}
|
2016-09-12 12:41:03 +00:00
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testMaximizedToFullscreen_data()
|
2019-01-29 12:28:52 +00:00
|
|
|
|
{
|
|
|
|
|
QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
|
|
|
|
|
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QTest::newRow("client-side deco") << ServerSideDecoration::Mode::Client;
|
|
|
|
|
QTest::newRow("server-side deco") << ServerSideDecoration::Mode::Server;
|
2016-09-12 12:41:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testMaximizedToFullscreen()
|
2016-09-12 12:41:03 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that a window can be properly fullscreened after maximizing
|
2020-02-17 18:39:17 +00:00
|
|
|
|
|
|
|
|
|
XdgShellSurface::States states;
|
|
|
|
|
|
2016-09-12 12:41:03 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2019-07-29 19:45:19 +00:00
|
|
|
|
QVERIFY(shellSurface);
|
2018-10-05 14:27:05 +00:00
|
|
|
|
|
2016-09-12 12:41:03 +00:00
|
|
|
|
// create deco
|
|
|
|
|
QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
|
|
|
|
|
QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
|
|
|
|
|
QVERIFY(decoSpy.isValid());
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
QFETCH(ServerSideDecoration::Mode, decoMode);
|
|
|
|
|
deco->requestMode(decoMode);
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
QCOMPARE(deco->mode(), decoMode);
|
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QVERIFY(!client->isFullScreen());
|
|
|
|
|
QCOMPARE(client->clientSize(), QSize(100, 50));
|
|
|
|
|
QCOMPARE(client->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
|
|
|
|
|
|
|
|
|
|
QSignalSpy fullscreenChangedSpy(client, &AbstractClient::fullScreenChanged);
|
2016-09-12 12:41:03 +00:00
|
|
|
|
QVERIFY(fullscreenChangedSpy.isValid());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-07-29 19:45:19 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
2019-01-29 12:28:52 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
|
|
|
|
|
// Wait for the compositor to send a configure event with the Activated state.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Activated);
|
|
|
|
|
|
|
|
|
|
// Ask the compositor to maximize the window.
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->setMaximized(true);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Maximized);
|
[wayland] Asyncronously update maximise flags
Summary:
A window maximising is an async operation. We work out what size we want
the client to be, then request the client to update. The window isn't
really maximised until we get that new buffer with the new size.
This patch splits the requested, pending and current state, updating as
appropriate.
Things are a bit complex with things like borders. Technically we
shouldn't update them till we get a response, but we also need to have
the correct geometry of the full size window in our request. For now
they behave as before, updating when we request the change.
X code is untouched.
This hopefully fixes maximise animations on wayland as now we update the
geometry before emitting maximisedChanged.
Test Plan:
Maximised a window with the button and double clicking title bar.
I get only the following events on maximise/restore:
19:51:39.156 KWin::EffectsHandlerImpl::slotGeometryShapeChanged geometry
shape changed QRect(47,24 640x509) QRect(0,0 716x573)
19:51:39.157 KWin::EffectsHandlerImpl::slotClientMaximized slot client
maximised true true
19:51:40.522 KWin::EffectsHandlerImpl::slotGeometryShapeChanged geometry
shape changed QRect(0,0 716x573) QRect(47,24 640x509)
19:51:40.522 KWin::EffectsHandlerImpl::slotClientMaximized slot client
maximised false false
BUG: 382698
Reviewers: #kwin, romangg
Reviewed By: #kwin, romangg
Subscribers: romangg, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D15150
2018-10-05 14:36:02 +00:00
|
|
|
|
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::red);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QCOMPARE(client->maximizeMode(), MaximizeFull);
|
[wayland] Asyncronously update maximise flags
Summary:
A window maximising is an async operation. We work out what size we want
the client to be, then request the client to update. The window isn't
really maximised until we get that new buffer with the new size.
This patch splits the requested, pending and current state, updating as
appropriate.
Things are a bit complex with things like borders. Technically we
shouldn't update them till we get a response, but we also need to have
the correct geometry of the full size window in our request. For now
they behave as before, updating when we request the change.
X code is untouched.
This hopefully fixes maximise animations on wayland as now we update the
geometry before emitting maximisedChanged.
Test Plan:
Maximised a window with the button and double clicking title bar.
I get only the following events on maximise/restore:
19:51:39.156 KWin::EffectsHandlerImpl::slotGeometryShapeChanged geometry
shape changed QRect(47,24 640x509) QRect(0,0 716x573)
19:51:39.157 KWin::EffectsHandlerImpl::slotClientMaximized slot client
maximised true true
19:51:40.522 KWin::EffectsHandlerImpl::slotGeometryShapeChanged geometry
shape changed QRect(0,0 716x573) QRect(47,24 640x509)
19:51:40.522 KWin::EffectsHandlerImpl::slotClientMaximized slot client
maximised false false
BUG: 382698
Reviewers: #kwin, romangg
Reviewed By: #kwin, romangg
Subscribers: romangg, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D15150
2018-10-05 14:36:02 +00:00
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
// Ask the compositor to show the window in full screen mode.
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->setFullscreen(true);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), screens()->size(0));
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Maximized);
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Fullscreen);
|
2016-09-12 12:41:03 +00:00
|
|
|
|
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
2020-02-17 18:39:17 +00:00
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::red);
|
2018-11-16 11:59:39 +00:00
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
#if 0 // TODO: Uncomment when full screen changes are truly asynchronous.
|
|
|
|
|
QVERIFY(fullScreenChangedSpy.wait());
|
|
|
|
|
QCOMPARE(fullScreenChangedSpy.count(), 1);
|
|
|
|
|
#else
|
|
|
|
|
QTRY_COMPARE(fullscreenChangedSpy.count(), 1);
|
|
|
|
|
#endif
|
|
|
|
|
QCOMPARE(client->maximizeMode(), MaximizeFull);
|
|
|
|
|
QVERIFY(client->isFullScreen());
|
|
|
|
|
QVERIFY(!client->isDecorated());
|
2016-09-12 12:41:03 +00:00
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
// Switch back to normal mode.
|
2019-07-29 19:45:19 +00:00
|
|
|
|
shellSurface->setFullscreen(false);
|
|
|
|
|
shellSurface->setMaximized(false);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 4);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), QSize(100, 50));
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(!(states & XdgShellSurface::State::Maximized));
|
|
|
|
|
QVERIFY(!(states & XdgShellSurface::State::Fullscreen));
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::red);
|
|
|
|
|
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QVERIFY(!client->isFullScreen());
|
|
|
|
|
QCOMPARE(client->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
|
|
|
|
|
QCOMPARE(client->maximizeMode(), MaximizeRestore);
|
|
|
|
|
|
|
|
|
|
// Destroy the client.
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
2016-09-12 10:03:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-11-23 18:24:37 +00:00
|
|
|
|
void TestXdgShellClient::testFullscreenMultipleOutputs()
|
|
|
|
|
{
|
|
|
|
|
// this test verifies that kwin will place fullscreen windows in the outputs its instructed to
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < screens()->count(); ++i) {
|
|
|
|
|
XdgShellSurface::States states;
|
|
|
|
|
|
|
|
|
|
QSharedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QSharedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
|
|
|
|
|
|
|
|
|
QVERIFY(surface);
|
|
|
|
|
QVERIFY(shellSurface);
|
|
|
|
|
|
|
|
|
|
auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QVERIFY(!client->isFullScreen());
|
|
|
|
|
QCOMPARE(client->clientSize(), QSize(100, 50));
|
|
|
|
|
QVERIFY(!client->isDecorated());
|
|
|
|
|
|
|
|
|
|
QSignalSpy fullscreenChangedSpy(client, &AbstractClient::fullScreenChanged);
|
|
|
|
|
QVERIFY(fullscreenChangedSpy.isValid());
|
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
|
|
|
|
|
|
|
|
|
// Wait for the compositor to send a configure event with the Activated state.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states & XdgShellSurface::State::Activated);
|
|
|
|
|
|
|
|
|
|
// Ask the compositor to show the window in full screen mode.
|
|
|
|
|
shellSurface->setFullscreen(true, Test::waylandOutputs()[i]);
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), screens()->size(i));
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), configureRequestedSpy.last().at(0).value<QSize>(), Qt::red);
|
|
|
|
|
|
|
|
|
|
QVERIFY(!fullscreenChangedSpy.isEmpty() || fullscreenChangedSpy.wait());
|
|
|
|
|
QCOMPARE(fullscreenChangedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
QVERIFY(!frameGeometryChangedSpy.isEmpty() || frameGeometryChangedSpy.wait());
|
|
|
|
|
|
|
|
|
|
QVERIFY(client->isFullScreen());
|
|
|
|
|
|
|
|
|
|
QCOMPARE(client->frameGeometry(), screens()->geometry(i));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testWindowOpensLargerThanScreen()
|
2016-09-14 12:08:47 +00:00
|
|
|
|
{
|
|
|
|
|
// this test creates a window which is as large as the screen, but is decorated
|
|
|
|
|
// the window should get resized to fit into the screen, BUG: 366632
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-09-23 18:39:59 +00:00
|
|
|
|
QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
|
2016-09-14 12:08:47 +00:00
|
|
|
|
QVERIFY(sizeChangeRequestedSpy.isValid());
|
|
|
|
|
|
|
|
|
|
// create deco
|
|
|
|
|
QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
|
|
|
|
|
QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
|
|
|
|
|
QVERIFY(decoSpy.isValid());
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
deco->requestMode(ServerSideDecoration::Mode::Server);
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), screens()->size(0), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
QVERIFY(c->isDecorated());
|
|
|
|
|
QEXPECT_FAIL("", "BUG 366632", Continue);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QCOMPARE(c->frameGeometry(), QRect(QPoint(0, 0), screens()->size(0)));
|
2016-09-14 12:08:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testHidden()
|
2016-10-11 14:24:10 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that when hiding window it doesn't get shown
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<QObject> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2016-10-11 14:24:10 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
QCOMPARE(workspace()->activeClient(), c);
|
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
|
|
|
|
QVERIFY(c->isShown(true));
|
|
|
|
|
|
|
|
|
|
c->hideClient(true);
|
|
|
|
|
QVERIFY(!c->isShown(true));
|
|
|
|
|
QVERIFY(!c->isActive());
|
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
|
|
|
|
|
|
|
|
|
// unhide again
|
|
|
|
|
c->hideClient(false);
|
|
|
|
|
QVERIFY(c->isShown(true));
|
|
|
|
|
QVERIFY(c->wantsInput());
|
|
|
|
|
QVERIFY(c->wantsTabFocus());
|
|
|
|
|
|
|
|
|
|
//QCOMPARE(workspace()->activeClient(), c);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testDesktopFileName()
|
2016-10-27 13:59:08 +00:00
|
|
|
|
{
|
2016-10-31 13:16:23 +00:00
|
|
|
|
QIcon::setThemeName(QStringLiteral("breeze"));
|
2016-10-27 13:59:08 +00:00
|
|
|
|
// this test verifies that desktop file name is passed correctly to the window
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
// only xdg-shell as ShellSurface misses the setter
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2016-10-27 13:59:08 +00:00
|
|
|
|
shellSurface->setAppId(QByteArrayLiteral("org.kde.foo"));
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.foo"));
|
2018-03-04 16:05:46 +00:00
|
|
|
|
QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.foo"));
|
2019-08-30 21:36:58 +00:00
|
|
|
|
QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
|
2016-10-27 13:59:08 +00:00
|
|
|
|
// the desktop file does not exist, so icon should be generic Wayland
|
|
|
|
|
QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
|
|
|
|
|
|
|
|
|
|
QSignalSpy desktopFileNameChangedSpy(c, &AbstractClient::desktopFileNameChanged);
|
|
|
|
|
QVERIFY(desktopFileNameChangedSpy.isValid());
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy iconChangedSpy(c, &AbstractClient::iconChanged);
|
2016-10-27 13:59:08 +00:00
|
|
|
|
QVERIFY(iconChangedSpy.isValid());
|
|
|
|
|
shellSurface->setAppId(QByteArrayLiteral("org.kde.bar"));
|
|
|
|
|
QVERIFY(desktopFileNameChangedSpy.wait());
|
|
|
|
|
QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.bar"));
|
2018-03-04 16:05:46 +00:00
|
|
|
|
QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.bar"));
|
2019-08-30 21:36:58 +00:00
|
|
|
|
QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
|
2016-10-27 13:59:08 +00:00
|
|
|
|
// icon should still be wayland
|
|
|
|
|
QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
|
|
|
|
|
QVERIFY(iconChangedSpy.isEmpty());
|
|
|
|
|
|
|
|
|
|
const QString dfPath = QFINDTESTDATA("data/example.desktop");
|
|
|
|
|
shellSurface->setAppId(dfPath.toUtf8());
|
|
|
|
|
QVERIFY(desktopFileNameChangedSpy.wait());
|
|
|
|
|
QCOMPARE(iconChangedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(QString::fromUtf8(c->desktopFileName()), dfPath);
|
|
|
|
|
QCOMPARE(c->icon().name(), QStringLiteral("kwin"));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testCaptionSimplified()
|
2016-10-31 14:50:14 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that caption is properly trimmed
|
|
|
|
|
// see BUG 323798 comment #12
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
// only done for xdg-shell as ShellSurface misses the setter
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2016-10-31 14:50:14 +00:00
|
|
|
|
const QString origTitle = QString::fromUtf8(QByteArrayLiteral("Was tun, wenn Schüler Autismus haben?\342\200\250\342\200\250\342\200\250 – Marlies Hübner - Mozilla Firefox"));
|
|
|
|
|
shellSurface->setTitle(origTitle);
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->caption() != origTitle);
|
|
|
|
|
QCOMPARE(c->caption(), origTitle.simplified());
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testCaptionMultipleWindows()
|
2017-08-20 06:56:13 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2017-08-20 06:56:13 +00:00
|
|
|
|
shellSurface->setTitle(QStringLiteral("foo"));
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QCOMPARE(c->caption(), QStringLiteral("foo"));
|
|
|
|
|
QCOMPARE(c->captionNormal(), QStringLiteral("foo"));
|
|
|
|
|
QCOMPARE(c->captionSuffix(), QString());
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface2(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
|
2017-08-20 06:56:13 +00:00
|
|
|
|
shellSurface2->setTitle(QStringLiteral("foo"));
|
|
|
|
|
auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c2);
|
|
|
|
|
QCOMPARE(c2->caption(), QStringLiteral("foo <2>"));
|
|
|
|
|
QCOMPARE(c2->captionNormal(), QStringLiteral("foo"));
|
|
|
|
|
QCOMPARE(c2->captionSuffix(), QStringLiteral(" <2>"));
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface3(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
|
2017-08-20 06:56:13 +00:00
|
|
|
|
shellSurface3->setTitle(QStringLiteral("foo"));
|
|
|
|
|
auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c3);
|
|
|
|
|
QCOMPARE(c3->caption(), QStringLiteral("foo <3>"));
|
|
|
|
|
QCOMPARE(c3->captionNormal(), QStringLiteral("foo"));
|
|
|
|
|
QCOMPARE(c3->captionSuffix(), QStringLiteral(" <3>"));
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface4(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
|
2017-08-20 06:56:13 +00:00
|
|
|
|
shellSurface4->setTitle(QStringLiteral("bar"));
|
|
|
|
|
auto c4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c4);
|
|
|
|
|
QCOMPARE(c4->caption(), QStringLiteral("bar"));
|
|
|
|
|
QCOMPARE(c4->captionNormal(), QStringLiteral("bar"));
|
|
|
|
|
QCOMPARE(c4->captionSuffix(), QString());
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy captionChangedSpy(c4, &AbstractClient::captionChanged);
|
2017-08-20 06:56:13 +00:00
|
|
|
|
QVERIFY(captionChangedSpy.isValid());
|
|
|
|
|
shellSurface4->setTitle(QStringLiteral("foo"));
|
|
|
|
|
QVERIFY(captionChangedSpy.wait());
|
|
|
|
|
QCOMPARE(captionChangedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(c4->caption(), QStringLiteral("foo <4>"));
|
|
|
|
|
QCOMPARE(c4->captionNormal(), QStringLiteral("foo"));
|
|
|
|
|
QCOMPARE(c4->captionSuffix(), QStringLiteral(" <4>"));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testUnresponsiveWindow_data()
|
2016-11-15 15:48:20 +00:00
|
|
|
|
{
|
XdgV6 - Kwin side
Summary:
Adds XDGV6 support for the kwin side.
Popup placement support is limited to the stuff v5 had,
a simple offset, rather than the awesome new positioner.
But Qt doesn't make use of it yet either.
Also ideally we should do all the positioning before sending the first
configure, but again Qt doesn't actually do anything with that anyway.
Also integrate pinging clients
Test Plan: gtk3-demo works nicely.
Reviewers: #plasma, graesslin, mart
Reviewed By: #plasma, graesslin
Subscribers: mart, graesslin, kwin, plasma-devel, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6591
2017-09-25 15:37:59 +00:00
|
|
|
|
QTest::addColumn<QString>("shellInterface");//see env selection in qwaylandintegration.cpp
|
2016-11-15 15:48:20 +00:00
|
|
|
|
QTest::addColumn<bool>("socketMode");
|
|
|
|
|
|
2020-03-18 09:14:37 +00:00
|
|
|
|
QTest::newRow("xdg display") << "xdg-shell" << false;
|
|
|
|
|
QTest::newRow("xdg socket") << "xdg-shell" << true;
|
2016-11-15 15:48:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testUnresponsiveWindow()
|
2016-11-15 15:48:20 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that killWindow properly terminates a process
|
|
|
|
|
// for this an external binary is launched
|
2017-08-25 16:18:20 +00:00
|
|
|
|
const QString kill = QFINDTESTDATA(QStringLiteral("kill"));
|
2016-11-15 15:48:20 +00:00
|
|
|
|
QVERIFY(!kill.isEmpty());
|
2020-07-22 18:35:41 +00:00
|
|
|
|
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
|
|
|
|
|
QVERIFY(clientAddedSpy.isValid());
|
2016-11-15 15:48:20 +00:00
|
|
|
|
|
|
|
|
|
QScopedPointer<QProcess> process(new QProcess);
|
|
|
|
|
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
|
XdgV6 - Kwin side
Summary:
Adds XDGV6 support for the kwin side.
Popup placement support is limited to the stuff v5 had,
a simple offset, rather than the awesome new positioner.
But Qt doesn't make use of it yet either.
Also ideally we should do all the positioning before sending the first
configure, but again Qt doesn't actually do anything with that anyway.
Also integrate pinging clients
Test Plan: gtk3-demo works nicely.
Reviewers: #plasma, graesslin, mart
Reviewed By: #plasma, graesslin
Subscribers: mart, graesslin, kwin, plasma-devel, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6591
2017-09-25 15:37:59 +00:00
|
|
|
|
|
|
|
|
|
QFETCH(QString, shellInterface);
|
2016-11-15 15:48:20 +00:00
|
|
|
|
QFETCH(bool, socketMode);
|
XdgV6 - Kwin side
Summary:
Adds XDGV6 support for the kwin side.
Popup placement support is limited to the stuff v5 had,
a simple offset, rather than the awesome new positioner.
But Qt doesn't make use of it yet either.
Also ideally we should do all the positioning before sending the first
configure, but again Qt doesn't actually do anything with that anyway.
Also integrate pinging clients
Test Plan: gtk3-demo works nicely.
Reviewers: #plasma, graesslin, mart
Reviewed By: #plasma, graesslin
Subscribers: mart, graesslin, kwin, plasma-devel, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6591
2017-09-25 15:37:59 +00:00
|
|
|
|
env.insert("QT_WAYLAND_SHELL_INTEGRATION", shellInterface);
|
2016-11-15 15:48:20 +00:00
|
|
|
|
if (socketMode) {
|
|
|
|
|
int sx[2];
|
|
|
|
|
QVERIFY(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) >= 0);
|
|
|
|
|
waylandServer()->display()->createClient(sx[0]);
|
|
|
|
|
int socket = dup(sx[1]);
|
|
|
|
|
QVERIFY(socket != -1);
|
|
|
|
|
env.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
|
|
|
|
|
env.remove("WAYLAND_DISPLAY");
|
|
|
|
|
} else {
|
|
|
|
|
env.insert("WAYLAND_DISPLAY", s_socketName);
|
|
|
|
|
}
|
|
|
|
|
process->setProcessEnvironment(env);
|
|
|
|
|
process->setProcessChannelMode(QProcess::ForwardedChannels);
|
|
|
|
|
process->setProgram(kill);
|
2018-12-23 06:58:29 +00:00
|
|
|
|
QSignalSpy processStartedSpy{process.data(), &QProcess::started};
|
|
|
|
|
QVERIFY(processStartedSpy.isValid());
|
2016-11-15 15:48:20 +00:00
|
|
|
|
process->start();
|
2018-12-23 06:58:29 +00:00
|
|
|
|
QVERIFY(processStartedSpy.wait());
|
2016-11-15 15:48:20 +00:00
|
|
|
|
|
|
|
|
|
AbstractClient *killClient = nullptr;
|
2020-07-22 18:35:41 +00:00
|
|
|
|
if (clientAddedSpy.isEmpty()) {
|
|
|
|
|
QVERIFY(clientAddedSpy.wait());
|
2018-12-23 06:58:29 +00:00
|
|
|
|
}
|
2019-02-28 02:09:16 +00:00
|
|
|
|
::kill(process->processId(), SIGUSR1); // send a signal to freeze the process
|
|
|
|
|
|
2020-07-22 18:35:41 +00:00
|
|
|
|
killClient = clientAddedSpy.first().first().value<AbstractClient*>();
|
2019-02-28 02:09:16 +00:00
|
|
|
|
QVERIFY(killClient);
|
XdgV6 - Kwin side
Summary:
Adds XDGV6 support for the kwin side.
Popup placement support is limited to the stuff v5 had,
a simple offset, rather than the awesome new positioner.
But Qt doesn't make use of it yet either.
Also ideally we should do all the positioning before sending the first
configure, but again Qt doesn't actually do anything with that anyway.
Also integrate pinging clients
Test Plan: gtk3-demo works nicely.
Reviewers: #plasma, graesslin, mart
Reviewed By: #plasma, graesslin
Subscribers: mart, graesslin, kwin, plasma-devel, #kwin
Tags: #plasma
Differential Revision: https://phabricator.kde.org/D6591
2017-09-25 15:37:59 +00:00
|
|
|
|
QSignalSpy unresponsiveSpy(killClient, &AbstractClient::unresponsiveChanged);
|
|
|
|
|
QSignalSpy killedSpy(process.data(), static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished));
|
|
|
|
|
QSignalSpy deletedSpy(killClient, &QObject::destroyed);
|
|
|
|
|
|
|
|
|
|
qint64 startTime = QDateTime::currentMSecsSinceEpoch();
|
|
|
|
|
|
|
|
|
|
//wait for the process to be frozen
|
|
|
|
|
QTest::qWait(10);
|
|
|
|
|
|
|
|
|
|
//pretend the user clicked the close button
|
|
|
|
|
killClient->closeWindow();
|
|
|
|
|
|
|
|
|
|
//client should not yet be marked unresponsive nor killed
|
|
|
|
|
QVERIFY(!killClient->unresponsive());
|
|
|
|
|
QVERIFY(killedSpy.isEmpty());
|
|
|
|
|
|
|
|
|
|
QVERIFY(unresponsiveSpy.wait());
|
|
|
|
|
//client should be marked unresponsive but not killed
|
|
|
|
|
auto elapsed1 = QDateTime::currentMSecsSinceEpoch() - startTime;
|
|
|
|
|
QVERIFY(elapsed1 > 900 && elapsed1 < 1200); //ping timer is 1s, but coarse timers on a test across two processes means we need a fuzzy compare
|
|
|
|
|
QVERIFY(killClient->unresponsive());
|
|
|
|
|
QVERIFY(killedSpy.isEmpty());
|
|
|
|
|
|
|
|
|
|
QVERIFY(deletedSpy.wait());
|
|
|
|
|
if (!socketMode) {
|
|
|
|
|
//process was killed - because we're across process this could happen in either order
|
|
|
|
|
QVERIFY(killedSpy.count() || killedSpy.wait());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto elapsed2 = QDateTime::currentMSecsSinceEpoch() - startTime;
|
|
|
|
|
QVERIFY(elapsed2 > 1800); //second ping comes in a second later
|
2016-11-15 15:48:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testAppMenu()
|
2017-12-22 14:22:24 +00:00
|
|
|
|
{
|
2017-12-22 17:23:44 +00:00
|
|
|
|
//register a faux appmenu client
|
|
|
|
|
QVERIFY (QDBusConnection::sessionBus().registerService("org.kde.kappmenu"));
|
|
|
|
|
|
2017-12-22 14:22:24 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2019-08-27 15:01:14 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2017-12-22 14:22:24 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QScopedPointer<AppMenu> menu(Test::waylandAppMenuManager()->create(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy spy(c, &AbstractClient::hasApplicationMenuChanged);
|
2017-12-22 14:22:24 +00:00
|
|
|
|
menu->setAddress("service.name", "object/path");
|
|
|
|
|
spy.wait();
|
|
|
|
|
QCOMPARE(c->hasApplicationMenu(), true);
|
2017-12-22 15:47:43 +00:00
|
|
|
|
QCOMPARE(c->applicationMenuServiceName(), QString("service.name"));
|
|
|
|
|
QCOMPARE(c->applicationMenuObjectPath(), QString("object/path"));
|
2017-12-22 17:23:44 +00:00
|
|
|
|
|
|
|
|
|
QVERIFY (QDBusConnection::sessionBus().unregisterService("org.kde.kappmenu"));
|
2017-12-22 14:22:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testNoDecorationModeRequested()
|
2018-02-19 21:10:17 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that the decoration follows the default mode if no mode is explicitly requested
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2018-02-19 21:10:17 +00:00
|
|
|
|
QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
|
|
|
|
|
QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
|
|
|
|
|
QVERIFY(decoSpy.isValid());
|
|
|
|
|
if (deco->mode() != ServerSideDecoration::Mode::Server) {
|
|
|
|
|
QVERIFY(decoSpy.wait());
|
|
|
|
|
}
|
|
|
|
|
QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QCOMPARE(c->noBorder(), false);
|
|
|
|
|
QCOMPARE(c->isDecorated(), true);
|
|
|
|
|
}
|
2017-12-22 14:22:24 +00:00
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testSendClientWithTransientToDesktop()
|
2018-12-12 17:25:51 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that when sending a client to a desktop all transients are also send to that desktop
|
|
|
|
|
|
|
|
|
|
VirtualDesktopManager::self()->setCount(2);
|
|
|
|
|
QScopedPointer<Surface> surface{Test::createSurface()};
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2018-12-12 17:25:51 +00:00
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
|
|
|
|
|
// let's create a transient window
|
|
|
|
|
QScopedPointer<Surface> transientSurface{Test::createSurface()};
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellStableSurface(transientSurface.data()));
|
2018-12-12 17:25:51 +00:00
|
|
|
|
transientShellSurface->setTransientFor(shellSurface.data());
|
|
|
|
|
|
|
|
|
|
auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(transient);
|
|
|
|
|
QCOMPARE(workspace()->activeClient(), transient);
|
|
|
|
|
QCOMPARE(transient->transientFor(), c);
|
|
|
|
|
QVERIFY(c->transients().contains(transient));
|
|
|
|
|
|
|
|
|
|
QCOMPARE(c->desktop(), 1);
|
|
|
|
|
QVERIFY(!c->isOnAllDesktops());
|
|
|
|
|
QCOMPARE(transient->desktop(), 1);
|
|
|
|
|
QVERIFY(!transient->isOnAllDesktops());
|
|
|
|
|
workspace()->slotWindowToDesktop(2);
|
|
|
|
|
|
|
|
|
|
QCOMPARE(c->desktop(), 1);
|
|
|
|
|
QCOMPARE(transient->desktop(), 2);
|
|
|
|
|
|
|
|
|
|
// activate c
|
|
|
|
|
workspace()->activateClient(c);
|
|
|
|
|
QCOMPARE(workspace()->activeClient(), c);
|
|
|
|
|
QVERIFY(c->isActive());
|
|
|
|
|
|
|
|
|
|
// and send it to the desktop it's already on
|
|
|
|
|
QCOMPARE(c->desktop(), 1);
|
|
|
|
|
QCOMPARE(transient->desktop(), 2);
|
|
|
|
|
workspace()->slotWindowToDesktop(1);
|
|
|
|
|
|
|
|
|
|
// which should move the transient back to the desktop
|
|
|
|
|
QCOMPARE(c->desktop(), 1);
|
|
|
|
|
QCOMPARE(transient->desktop(), 1);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testMinimizeWindowWithTransients()
|
2018-12-13 16:47:10 +00:00
|
|
|
|
{
|
|
|
|
|
// this test verifies that when minimizing/unminimizing a window all its
|
|
|
|
|
// transients will be minimized/unminimized as well
|
|
|
|
|
|
|
|
|
|
// create the main window
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2018-12-13 16:47:10 +00:00
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(!c->isMinimized());
|
|
|
|
|
|
|
|
|
|
// create a transient window
|
|
|
|
|
QScopedPointer<Surface> transientSurface(Test::createSurface());
|
2020-09-09 09:54:44 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellStableSurface(transientSurface.data()));
|
2018-12-13 16:47:10 +00:00
|
|
|
|
transientShellSurface->setTransientFor(shellSurface.data());
|
|
|
|
|
auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::red);
|
|
|
|
|
QVERIFY(transient);
|
|
|
|
|
QVERIFY(!transient->isMinimized());
|
|
|
|
|
QCOMPARE(transient->transientFor(), c);
|
|
|
|
|
QVERIFY(c->hasTransient(transient, false));
|
|
|
|
|
|
|
|
|
|
// minimize the main window, the transient should be minimized as well
|
|
|
|
|
c->minimize();
|
|
|
|
|
QVERIFY(c->isMinimized());
|
|
|
|
|
QVERIFY(transient->isMinimized());
|
|
|
|
|
|
|
|
|
|
// unminimize the main window, the transient should be unminimized as well
|
|
|
|
|
c->unminimize();
|
|
|
|
|
QVERIFY(!c->isMinimized());
|
|
|
|
|
QVERIFY(!transient->isMinimized());
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgDecoration_data()
|
2019-01-01 17:37:18 +00:00
|
|
|
|
{
|
|
|
|
|
QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("requestedMode");
|
|
|
|
|
QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("expectedMode");
|
|
|
|
|
|
|
|
|
|
QTest::newRow("client side requested") << XdgDecoration::Mode::ClientSide << XdgDecoration::Mode::ClientSide;
|
|
|
|
|
QTest::newRow("server side requested") << XdgDecoration::Mode::ServerSide << XdgDecoration::Mode::ServerSide;
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgDecoration()
|
2019-01-01 17:37:18 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
|
|
|
|
QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
|
|
|
|
|
|
|
|
|
|
QSignalSpy decorationConfiguredSpy(deco.data(), &XdgDecoration::modeChanged);
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
|
|
|
|
|
QFETCH(KWayland::Client::XdgDecoration::Mode, requestedMode);
|
|
|
|
|
QFETCH(KWayland::Client::XdgDecoration::Mode, expectedMode);
|
|
|
|
|
|
|
|
|
|
//request a mode
|
|
|
|
|
deco->setMode(requestedMode);
|
|
|
|
|
|
|
|
|
|
//kwin will send a configure
|
|
|
|
|
decorationConfiguredSpy.wait();
|
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(decorationConfiguredSpy.count(), 1);
|
|
|
|
|
QCOMPARE(decorationConfiguredSpy.first()[0].value<KWayland::Client::XdgDecoration::Mode>(), expectedMode);
|
|
|
|
|
QVERIFY(configureRequestedSpy.count() > 0);
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
QCOMPARE(c->userCanSetNoBorder(), expectedMode == XdgDecoration::Mode::ServerSide);
|
|
|
|
|
QCOMPARE(c->isDecorated(), expectedMode == XdgDecoration::Mode::ServerSide);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgNeverCommitted()
|
2019-02-26 13:41:07 +00:00
|
|
|
|
{
|
2019-08-30 21:36:58 +00:00
|
|
|
|
//check we don't crash if we create a shell object but delete the XdgShellClient before committing it
|
2019-02-26 13:41:07 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgInitialState()
|
2019-02-26 13:41:07 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
const auto size = configureRequestedSpy.first()[0].value<QSize>();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(size, QSize(0, 0)); //client should chose it's preferred size
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), QSize(200,100), Qt::blue);
|
|
|
|
|
QCOMPARE(c->size(), QSize(200, 100));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgInitiallyMaximised()
|
2019-02-26 13:41:07 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
|
|
|
|
|
shellSurface->setMaximized(true);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
const auto size = configureRequestedSpy.first()[0].value<QSize>();
|
|
|
|
|
const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(size, QSize(1280, 1024));
|
|
|
|
|
QVERIFY(state & KWayland::Client::XdgShellSurface::State::Maximized);
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
|
|
|
|
|
QCOMPARE(c->maximizeMode(), MaximizeFull);
|
|
|
|
|
QCOMPARE(c->size(), QSize(1280, 1024));
|
2019-10-11 08:46:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgInitiallyFullscreen()
|
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
|
|
|
|
|
shellSurface->setFullscreen(true);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
const auto size = configureRequestedSpy.first()[0].value<QSize>();
|
|
|
|
|
const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(size, QSize(1280, 1024));
|
|
|
|
|
QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
|
|
|
|
|
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
|
|
|
|
|
QCOMPARE(c->isFullScreen(), true);
|
|
|
|
|
QCOMPARE(c->size(), QSize(1280, 1024));
|
2019-02-26 13:41:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
void TestXdgShellClient::testXdgInitiallyMinimized()
|
2019-02-26 13:41:07 +00:00
|
|
|
|
{
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
|
|
|
|
|
shellSurface->requestMinimize();
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
configureRequestedSpy.wait();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
|
|
|
|
const auto size = configureRequestedSpy.first()[0].value<QSize>();
|
|
|
|
|
const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
|
|
|
|
|
|
|
|
|
|
QCOMPARE(size, QSize(0, 0));
|
|
|
|
|
QCOMPARE(state, 0);
|
|
|
|
|
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
|
|
|
|
|
|
|
|
|
|
QEXPECT_FAIL("", "Client created in a minimised state is not exposed to kwin bug 404838", Abort);
|
|
|
|
|
auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue, QImage::Format_ARGB32, 10);
|
|
|
|
|
QVERIFY(c);
|
|
|
|
|
QVERIFY(c->isMinimized());
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-03 19:43:28 +00:00
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryIsntSet()
|
2019-05-17 14:13:54 +00:00
|
|
|
|
{
|
2019-10-03 19:43:28 +00:00
|
|
|
|
// This test verifies that the effective window geometry corresponds to the
|
|
|
|
|
// bounding rectangle of the main surface and its sub-surfaces if no window
|
|
|
|
|
// geometry is set by the client.
|
|
|
|
|
|
2019-05-17 14:13:54 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
const QPoint oldPosition = client->pos();
|
|
|
|
|
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
Test::render(surface.data(), QSize(100, 50), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> childSurface(Test::createSurface());
|
|
|
|
|
QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
|
|
|
|
|
QVERIFY(subSurface);
|
|
|
|
|
subSurface->setPosition(QPoint(-20, -10));
|
|
|
|
|
Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(120, 60));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition + QPoint(20, 10));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryAttachBuffer()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that the effective window geometry remains the same when
|
|
|
|
|
// a new buffer is attached and xdg_surface.set_window_geometry is not called
|
|
|
|
|
// again. Notice that the window geometry must remain the same even if the new
|
|
|
|
|
// buffer is smaller.
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
const QPoint oldPosition = client->pos();
|
|
|
|
|
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 1);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
Test::render(surface.data(), QSize(100, 50), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 2);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(90, 40));
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
|
|
|
|
|
|
2020-02-17 18:39:17 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(0, 0, 100, 50));
|
2019-10-03 19:43:28 +00:00
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 3);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
2020-02-17 18:39:17 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
|
|
|
|
|
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryAttachSubSurface()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that the effective window geometry remains the same
|
|
|
|
|
// when a new sub-surface is added and xdg_surface.set_window_geometry is
|
|
|
|
|
// not called again.
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
const QPoint oldPosition = client->pos();
|
|
|
|
|
|
2020-03-04 07:55:26 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> childSurface(Test::createSurface());
|
|
|
|
|
QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
|
|
|
|
|
QVERIFY(subSurface);
|
|
|
|
|
subSurface->setPosition(QPoint(-20, -20));
|
|
|
|
|
Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(-15, -15, 50, 40));
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(50, 40));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(-15, -15));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryInteractiveResize()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that correct window geometry is provided along each
|
|
|
|
|
// configure event when an xdg-shell is being interactively resized.
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
2019-05-17 14:13:54 +00:00
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
2019-05-17 14:13:54 +00:00
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
|
|
|
|
|
QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
|
|
|
|
|
QVERIFY(clientStartMoveResizedSpy.isValid());
|
|
|
|
|
QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
|
|
|
|
|
QVERIFY(clientStepUserMovedResizedSpy.isValid());
|
|
|
|
|
QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
|
|
|
|
|
QVERIFY(clientFinishUserMovedResizedSpy.isValid());
|
|
|
|
|
|
|
|
|
|
// Start interactively resizing the client.
|
|
|
|
|
QCOMPARE(workspace()->moveResizeClient(), nullptr);
|
|
|
|
|
workspace()->slotWindowResize();
|
|
|
|
|
QCOMPARE(workspace()->moveResizeClient(), client);
|
|
|
|
|
QCOMPARE(clientStartMoveResizedSpy.count(), 1);
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
|
|
|
|
|
|
|
|
|
|
// Go right.
|
2020-04-02 16:18:01 +00:00
|
|
|
|
QPoint cursorPos = KWin::Cursors::self()->mouse()->pos();
|
2019-10-03 19:43:28 +00:00
|
|
|
|
client->keyPressEvent(Qt::Key_Right);
|
2020-04-02 16:18:01 +00:00
|
|
|
|
client->updateMoveResize(KWin::Cursors::self()->mouse()->pos());
|
|
|
|
|
QCOMPARE(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 80));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 188, 80));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(208, 100), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(208, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(188, 80));
|
|
|
|
|
|
|
|
|
|
// Go down.
|
2020-04-02 16:18:01 +00:00
|
|
|
|
cursorPos = KWin::Cursors::self()->mouse()->pos();
|
2019-10-03 19:43:28 +00:00
|
|
|
|
client->keyPressEvent(Qt::Key_Down);
|
2020-04-02 16:18:01 +00:00
|
|
|
|
client->updateMoveResize(KWin::Cursors::self()->mouse()->pos());
|
|
|
|
|
QCOMPARE(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(0, 8));
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 4);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 88));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 188, 88));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(208, 108), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(208, 108));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(188, 88));
|
|
|
|
|
|
|
|
|
|
// Finish resizing the client.
|
|
|
|
|
client->keyPressEvent(Qt::Key_Enter);
|
|
|
|
|
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
|
|
|
|
|
QCOMPARE(workspace()->moveResizeClient(), nullptr);
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 5);
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
|
2019-05-17 14:13:54 +00:00
|
|
|
|
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
}
|
2019-05-17 14:13:54 +00:00
|
|
|
|
|
2019-10-03 19:43:28 +00:00
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryFullScreen()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that an xdg-shell receives correct window geometry when
|
|
|
|
|
// its fullscreen state gets changed.
|
2019-05-17 14:13:54 +00:00
|
|
|
|
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
2019-05-17 14:13:54 +00:00
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
2019-05-17 14:13:54 +00:00
|
|
|
|
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
2019-05-17 14:13:54 +00:00
|
|
|
|
|
2019-10-03 19:43:28 +00:00
|
|
|
|
workspace()->slotWindowFullScreen();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
|
|
|
|
|
XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Fullscreen));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
|
|
|
|
|
|
|
|
|
|
workspace()->slotWindowFullScreen();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(!states.testFlag(XdgShellSurface::State::Fullscreen));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(200, 100), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TestXdgShellClient::testXdgWindowGeometryMaximize()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that an xdg-shell receives correct window geometry when
|
|
|
|
|
// its maximized state gets changed.
|
|
|
|
|
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
2020-03-04 07:55:26 +00:00
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.isValid());
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
|
|
|
|
|
workspace()->slotWindowMaximize();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
|
|
|
|
|
XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
|
|
|
|
|
|
|
|
|
|
workspace()->slotWindowMaximize();
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 3);
|
|
|
|
|
QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
|
|
|
|
|
shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
|
|
|
|
|
Test::render(surface.data(), QSize(200, 100), Qt::blue);
|
2020-02-05 09:28:50 +00:00
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
2019-10-03 19:43:28 +00:00
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
|
|
|
|
|
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
2019-05-17 14:13:54 +00:00
|
|
|
|
}
|
2019-02-26 13:41:07 +00:00
|
|
|
|
|
2020-07-14 11:34:25 +00:00
|
|
|
|
void TestXdgShellClient::testPointerInputTransform()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that XdgToplevelClient provides correct input transform matrix.
|
|
|
|
|
// The input transform matrix is used by seat to map pointer events from the global
|
|
|
|
|
// screen coordinates to the surface-local coordinates.
|
|
|
|
|
|
|
|
|
|
// Get a wl_pointer object on the client side.
|
|
|
|
|
QScopedPointer<KWayland::Client::Pointer> pointer(Test::waylandSeat()->createPointer());
|
|
|
|
|
QVERIFY(pointer);
|
|
|
|
|
QVERIFY(pointer->isValid());
|
|
|
|
|
QSignalSpy pointerEnteredSpy(pointer.data(), &KWayland::Client::Pointer::entered);
|
|
|
|
|
QVERIFY(pointerEnteredSpy.isValid());
|
|
|
|
|
QSignalSpy pointerMotionSpy(pointer.data(), &KWayland::Client::Pointer::motion);
|
|
|
|
|
QVERIFY(pointerMotionSpy.isValid());
|
|
|
|
|
|
|
|
|
|
// Create an xdg_toplevel surface and wait for the compositor to catch up.
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
|
|
|
|
|
// Enter the surface.
|
|
|
|
|
quint32 timestamp = 0;
|
|
|
|
|
kwinApp()->platform()->pointerMotion(client->pos(), timestamp++);
|
|
|
|
|
QVERIFY(pointerEnteredSpy.wait());
|
|
|
|
|
|
|
|
|
|
// Move the pointer to (10, 5) relative to the upper left frame corner, which is located
|
|
|
|
|
// at (0, 0) in the surface-local coordinates.
|
|
|
|
|
kwinApp()->platform()->pointerMotion(client->pos() + QPoint(10, 5), timestamp++);
|
|
|
|
|
QVERIFY(pointerMotionSpy.wait());
|
|
|
|
|
QCOMPARE(pointerMotionSpy.last().first(), QPoint(10, 5));
|
|
|
|
|
|
|
|
|
|
// Let's pretend that the client has changed the extents of the client-side drop-shadow
|
|
|
|
|
// but the frame geometry didn't change.
|
|
|
|
|
QSignalSpy bufferGeometryChangedSpy(client, &AbstractClient::bufferGeometryChanged);
|
|
|
|
|
QVERIFY(bufferGeometryChangedSpy.isValid());
|
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
|
|
|
|
shellSurface->setWindowGeometry(QRect(10, 20, 200, 100));
|
|
|
|
|
Test::render(surface.data(), QSize(220, 140), Qt::blue);
|
|
|
|
|
QVERIFY(bufferGeometryChangedSpy.wait());
|
|
|
|
|
QCOMPARE(frameGeometryChangedSpy.count(), 0);
|
|
|
|
|
QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
|
|
|
|
|
QCOMPARE(client->bufferGeometry().size(), QSize(220, 140));
|
|
|
|
|
|
|
|
|
|
// Move the pointer to (20, 50) relative to the upper left frame corner, which is located
|
|
|
|
|
// at (10, 20) in the surface-local coordinates.
|
|
|
|
|
kwinApp()->platform()->pointerMotion(client->pos() + QPoint(20, 50), timestamp++);
|
|
|
|
|
QVERIFY(pointerMotionSpy.wait());
|
|
|
|
|
QCOMPARE(pointerMotionSpy.last().first(), QPoint(10, 20) + QPoint(20, 50));
|
|
|
|
|
|
|
|
|
|
// Destroy the xdg-toplevel surface.
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-20 19:33:19 +00:00
|
|
|
|
void TestXdgShellClient::testReentrantSetFrameGeometry()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that calling setFrameGeometry() from a slot connected directly
|
|
|
|
|
// to the frameGeometryChanged() signal won't cause an infinite recursion.
|
|
|
|
|
|
|
|
|
|
// Create an xdg-toplevel surface and wait for the compositor to catch up.
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
|
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
|
|
|
|
|
QVERIFY(client);
|
|
|
|
|
QCOMPARE(client->pos(), QPoint(0, 0));
|
|
|
|
|
|
|
|
|
|
// Let's pretend that there is a script that really wants the client to be at (100, 100).
|
|
|
|
|
connect(client, &AbstractClient::frameGeometryChanged, this, [client]() {
|
|
|
|
|
client->setFrameGeometry(QRect(QPoint(100, 100), client->size()));
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// Trigger the lambda above.
|
|
|
|
|
client->move(QPoint(40, 50));
|
|
|
|
|
|
|
|
|
|
// Eventually, the client will end up at (100, 100).
|
|
|
|
|
QCOMPARE(client->pos(), QPoint(100, 100));
|
|
|
|
|
|
|
|
|
|
// Destroy the xdg-toplevel surface.
|
|
|
|
|
shellSurface.reset();
|
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 18:53:07 +00:00
|
|
|
|
void TestXdgShellClient::testDoubleMaximize()
|
|
|
|
|
{
|
|
|
|
|
// This test verifies that the case where a client issues two set_maximized() requests
|
|
|
|
|
// separated by the initial commit is handled properly.
|
|
|
|
|
|
|
|
|
|
// Create the test surface.
|
|
|
|
|
QScopedPointer<Surface> surface(Test::createSurface());
|
|
|
|
|
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
|
|
|
|
|
shellSurface->setMaximized(true);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
// Wait for the compositor to respond with a configure event.
|
|
|
|
|
QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 1);
|
|
|
|
|
QSize size = configureRequestedSpy.last().at(0).value<QSize>();
|
|
|
|
|
QCOMPARE(size, QSize(1280, 1024));
|
|
|
|
|
XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
|
|
|
|
|
|
|
|
|
|
// Send another set_maximized() request, but do not attach any buffer yet.
|
|
|
|
|
shellSurface->setMaximized(true);
|
|
|
|
|
surface->commit(Surface::CommitFlag::None);
|
|
|
|
|
|
|
|
|
|
// The compositor must respond with another configure event even if the state hasn't changed.
|
|
|
|
|
QVERIFY(configureRequestedSpy.wait());
|
|
|
|
|
QCOMPARE(configureRequestedSpy.count(), 2);
|
|
|
|
|
size = configureRequestedSpy.last().at(0).value<QSize>();
|
|
|
|
|
QCOMPARE(size, QSize(1280, 1024));
|
|
|
|
|
states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
|
|
|
|
|
QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-30 21:36:58 +00:00
|
|
|
|
WAYLANDTEST_MAIN(TestXdgShellClient)
|
|
|
|
|
#include "xdgshellclient_test.moc"
|