yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/move_resize_window_test.cpp
Vlad Zahorodnii e97e520175 Move placement policy enum in KWin namespace 
Other policy enums are declared in options.h so let's do the same for
placement policy. Besides consistency, another advantage of moving the
enum in kwin namespace is that the enum could be forward declared.
2022-09-05 14:11:42 +00:00

1150 lines
50 KiB
C++
Raw Blame History

/*
KWin - the KDE window manager
This file is part of the KDE project.
SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "kwin_wayland_test.h"
#include "atoms.h"
#include "cursor.h"
#include "deleted.h"
#include "effects.h"
#include "output.h"
#include "placement.h"
#include "platform.h"
#include "wayland_server.h"
#include "window.h"
#include "workspace.h"
#include "x11window.h"
#include <KWayland/Client/compositor.h>
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/plasmashell.h>
#include <KWayland/Client/pointer.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/surface.h>
#include <linux/input.h>
#include <xcb/xcb_icccm.h>
Q_DECLARE_METATYPE(KWin::QuickTileMode)
Q_DECLARE_METATYPE(KWin::MaximizeMode)
namespace KWin
{
static const QString s_socketName = QStringLiteral("wayland_test_kwin_quick_tiling-0");
class MoveResizeWindowTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testMove();
void testResize();
void testPackTo_data();
void testPackTo();
void testPackAgainstClient_data();
void testPackAgainstClient();
void testGrowShrink_data();
void testGrowShrink();
void testPointerMoveEnd_data();
void testPointerMoveEnd();
void testClientSideMove();
void testPlasmaShellSurfaceMovable_data();
void testPlasmaShellSurfaceMovable();
void testNetMove();
void testAdjustClientGeometryOfAutohidingX11Panel_data();
void testAdjustClientGeometryOfAutohidingX11Panel();
void testAdjustClientGeometryOfAutohidingWaylandPanel_data();
void testAdjustClientGeometryOfAutohidingWaylandPanel();
void testResizeForVirtualKeyboard_data();
void testResizeForVirtualKeyboard();
void testResizeForVirtualKeyboardWithMaximize();
void testResizeForVirtualKeyboardWithFullScreen();
void testDestroyMoveClient();
void testDestroyResizeClient();
private:
KWayland::Client::ConnectionThread *m_connection = nullptr;
KWayland::Client::Compositor *m_compositor = nullptr;
};
void MoveResizeWindowTest::initTestCase()
{
qRegisterMetaType<KWin::Window *>();
qRegisterMetaType<KWin::Deleted *>();
qRegisterMetaType<KWin::MaximizeMode>("MaximizeMode");
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(applicationStartedSpy.isValid());
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QVERIFY(waylandServer()->init(s_socketName));
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
const auto outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 1);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
}
void MoveResizeWindowTest::init()
{
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::PlasmaShell | Test::AdditionalWaylandInterface::Seat));
QVERIFY(Test::waitForWaylandPointer());
m_connection = Test::waylandConnection();
m_compositor = Test::waylandCompositor();
workspace()->setActiveOutput(QPoint(640, 512));
}
void MoveResizeWindowTest::cleanup()
{
Test::destroyWaylandConnection();
}
void MoveResizeWindowTest::testMove()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
QSignalSpy startMoveResizedSpy(window, &Window::clientStartUserMovedResized);
QVERIFY(startMoveResizedSpy.isValid());
QSignalSpy moveResizedChangedSpy(window, &Window::moveResizedChanged);
QVERIFY(moveResizedChangedSpy.isValid());
QSignalSpy clientStepUserMovedResizedSpy(window, &Window::clientStepUserMovedResized);
QVERIFY(clientStepUserMovedResizedSpy.isValid());
QSignalSpy clientFinishUserMovedResizedSpy(window, &Window::clientFinishUserMovedResized);
QVERIFY(clientFinishUserMovedResizedSpy.isValid());
// effects signal handlers
QSignalSpy windowStartUserMovedResizedSpy(effects, &EffectsHandler::windowStartUserMovedResized);
QVERIFY(windowStartUserMovedResizedSpy.isValid());
QSignalSpy windowStepUserMovedResizedSpy(effects, &EffectsHandler::windowStepUserMovedResized);
QVERIFY(windowStepUserMovedResizedSpy.isValid());
QSignalSpy windowFinishUserMovedResizedSpy(effects, &EffectsHandler::windowFinishUserMovedResized);
QVERIFY(windowFinishUserMovedResizedSpy.isValid());
// begin move
QVERIFY(workspace()->moveResizeWindow() == nullptr);
QCOMPARE(window->isInteractiveMove(), false);
workspace()->slotWindowMove();
QCOMPARE(workspace()->moveResizeWindow(), window);
QCOMPARE(startMoveResizedSpy.count(), 1);
QCOMPARE(moveResizedChangedSpy.count(), 1);
QCOMPARE(windowStartUserMovedResizedSpy.count(), 1);
QCOMPARE(window->isInteractiveMove(), true);
QCOMPARE(window->geometryRestore(), QRect());
// send some key events, not going through input redirection
const QPoint cursorPos = Cursors::self()->mouse()->pos();
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(Cursors::self()->mouse()->pos());
QCOMPARE(Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
QEXPECT_FAIL("", "First event is ignored", Continue);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
clientStepUserMovedResizedSpy.clear();
windowStepUserMovedResizedSpy.clear();
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(Cursors::self()->mouse()->pos());
QCOMPARE(Cursors::self()->mouse()->pos(), cursorPos + QPoint(16, 0));
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
QCOMPARE(windowStepUserMovedResizedSpy.count(), 1);
window->keyPressEvent(Qt::Key_Down | Qt::ALT);
window->updateInteractiveMoveResize(Cursors::self()->mouse()->pos());
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
QCOMPARE(windowStepUserMovedResizedSpy.count(), 2);
QCOMPARE(window->frameGeometry(), QRect(16, 32, 100, 50));
QCOMPARE(Cursors::self()->mouse()->pos(), cursorPos + QPoint(16, 32));
// let's end
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
window->keyPressEvent(Qt::Key_Enter);
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
QCOMPARE(moveResizedChangedSpy.count(), 2);
QCOMPARE(windowFinishUserMovedResizedSpy.count(), 1);
QCOMPARE(window->frameGeometry(), QRect(16, 32, 100, 50));
QCOMPARE(window->isInteractiveMove(), false);
QVERIFY(workspace()->moveResizeWindow() == nullptr);
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
}
void MoveResizeWindowTest::testResize()
{
// a test case which manually resizes a window
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get(), Test::CreationSetup::CreateOnly));
QVERIFY(shellSurface != nullptr);
// Wait for the initial configure event.
Test::XdgToplevel::States states;
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QVERIFY(toplevelConfigureRequestedSpy.isValid());
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.isValid());
surface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 1);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 1);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Resizing));
// Let's render.
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
// We have to receive a configure event when the client becomes active.
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 2);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 2);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Resizing));
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QVERIFY(frameGeometryChangedSpy.isValid());
QSignalSpy startMoveResizedSpy(window, &Window::clientStartUserMovedResized);
QVERIFY(startMoveResizedSpy.isValid());
QSignalSpy moveResizedChangedSpy(window, &Window::moveResizedChanged);
QVERIFY(moveResizedChangedSpy.isValid());
QSignalSpy clientStepUserMovedResizedSpy(window, &Window::clientStepUserMovedResized);
QVERIFY(clientStepUserMovedResizedSpy.isValid());
QSignalSpy clientFinishUserMovedResizedSpy(window, &Window::clientFinishUserMovedResized);
QVERIFY(clientFinishUserMovedResizedSpy.isValid());
// begin resize
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
QCOMPARE(window->isInteractiveMove(), false);
QCOMPARE(window->isInteractiveResize(), false);
workspace()->slotWindowResize();
QCOMPARE(workspace()->moveResizeWindow(), window);
QCOMPARE(startMoveResizedSpy.count(), 1);
QCOMPARE(moveResizedChangedSpy.count(), 1);
QCOMPARE(window->isInteractiveResize(), true);
QCOMPARE(window->geometryRestore(), QRect());
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 3);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 3);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(states.testFlag(Test::XdgToplevel::State::Resizing));
// Trigger a change.
const QPoint cursorPos = Cursors::self()->mouse()->pos();
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(Cursors::self()->mouse()->pos());
QCOMPARE(Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
// The client should receive a configure event with the new size.
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 4);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 4);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(states.testFlag(Test::XdgToplevel::State::Resizing));
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(108, 50));
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// Now render new size.
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(108, 50), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(0, 0, 108, 50));
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// Go down.
window->keyPressEvent(Qt::Key_Down);
window->updateInteractiveMoveResize(Cursors::self()->mouse()->pos());
QCOMPARE(Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 8));
// The client should receive another configure event.
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 5);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 5);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(states.testFlag(Test::XdgToplevel::State::Resizing));
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(108, 58));
// Now render new size.
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(108, 58), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(0, 0, 108, 58));
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
// Let's finalize the resize operation.
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
window->keyPressEvent(Qt::Key_Enter);
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
QCOMPARE(moveResizedChangedSpy.count(), 2);
QCOMPARE(window->isInteractiveResize(), false);
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 6);
QCOMPARE(toplevelConfigureRequestedSpy.count(), 6);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Resizing));
// Destroy the client.
shellSurface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
}
void MoveResizeWindowTest::testPackTo_data()
{
QTest::addColumn<QString>("methodCall");
QTest::addColumn<QRectF>("expectedGeometry");
QTest::newRow("left") << QStringLiteral("slotWindowMoveLeft") << QRectF(0, 487, 100, 50);
QTest::newRow("up") << QStringLiteral("slotWindowMoveUp") << QRectF(590, 0, 100, 50);
QTest::newRow("right") << QStringLiteral("slotWindowMoveRight") << QRectF(1180, 487, 100, 50);
QTest::newRow("down") << QStringLiteral("slotWindowMoveDown") << QRectF(590, 974, 100, 50);
}
void MoveResizeWindowTest::testPackTo()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
// let's place it centered
workspace()->placement()->placeCentered(window, QRect(0, 0, 1280, 1024));
QCOMPARE(window->frameGeometry(), QRect(590, 487, 100, 50));
QFETCH(QString, methodCall);
QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
QTEST(window->frameGeometry(), "expectedGeometry");
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
}
void MoveResizeWindowTest::testPackAgainstClient_data()
{
QTest::addColumn<QString>("methodCall");
QTest::addColumn<QRectF>("expectedGeometry");
QTest::newRow("left") << QStringLiteral("slotWindowMoveLeft") << QRectF(10, 487, 100, 50);
QTest::newRow("up") << QStringLiteral("slotWindowMoveUp") << QRectF(590, 10, 100, 50);
QTest::newRow("right") << QStringLiteral("slotWindowMoveRight") << QRectF(1170, 487, 100, 50);
QTest::newRow("down") << QStringLiteral("slotWindowMoveDown") << QRectF(590, 964, 100, 50);
}
void MoveResizeWindowTest::testPackAgainstClient()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface1(Test::createSurface());
QVERIFY(surface1 != nullptr);
std::unique_ptr<KWayland::Client::Surface> surface2(Test::createSurface());
QVERIFY(surface2 != nullptr);
std::unique_ptr<KWayland::Client::Surface> surface3(Test::createSurface());
QVERIFY(surface3 != nullptr);
std::unique_ptr<KWayland::Client::Surface> surface4(Test::createSurface());
QVERIFY(surface4 != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface1(Test::createXdgToplevelSurface(surface1.get()));
QVERIFY(shellSurface1 != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface2(Test::createXdgToplevelSurface(surface2.get()));
QVERIFY(shellSurface2 != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface3(Test::createXdgToplevelSurface(surface3.get()));
QVERIFY(shellSurface3 != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface4(Test::createXdgToplevelSurface(surface4.get()));
QVERIFY(shellSurface4 != nullptr);
auto renderWindow = [](KWayland::Client::Surface *surface, const QString &methodCall, const QRect &expectedGeometry) {
// let's render
auto window = Test::renderAndWaitForShown(surface, QSize(10, 10), Qt::blue);
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(window->frameGeometry().size(), QSize(10, 10));
// let's place it centered
workspace()->placement()->placeCentered(window, QRect(0, 0, 1280, 1024));
QCOMPARE(window->frameGeometry(), QRect(635, 507, 10, 10));
QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
QCOMPARE(window->frameGeometry(), expectedGeometry);
};
renderWindow(surface1.get(), QStringLiteral("slotWindowMoveLeft"), QRect(0, 507, 10, 10));
renderWindow(surface2.get(), QStringLiteral("slotWindowMoveUp"), QRect(635, 0, 10, 10));
renderWindow(surface3.get(), QStringLiteral("slotWindowMoveRight"), QRect(1270, 507, 10, 10));
renderWindow(surface4.get(), QStringLiteral("slotWindowMoveDown"), QRect(635, 1014, 10, 10));
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
// let's place it centered
workspace()->placement()->placeCentered(window, QRect(0, 0, 1280, 1024));
QCOMPARE(window->frameGeometry(), QRect(590, 487, 100, 50));
QFETCH(QString, methodCall);
QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
QTEST(window->frameGeometry(), "expectedGeometry");
}
void MoveResizeWindowTest::testGrowShrink_data()
{
QTest::addColumn<QString>("methodCall");
QTest::addColumn<QRectF>("expectedGeometry");
QTest::newRow("grow vertical") << QStringLiteral("slotWindowExpandVertical") << QRectF(590, 487, 100, 537);
QTest::newRow("grow horizontal") << QStringLiteral("slotWindowExpandHorizontal") << QRectF(590, 487, 690, 50);
QTest::newRow("shrink vertical") << QStringLiteral("slotWindowShrinkVertical") << QRectF(590, 487, 100, 23);
QTest::newRow("shrink horizontal") << QStringLiteral("slotWindowShrinkHorizontal") << QRectF(590, 487, 40, 50);
}
void MoveResizeWindowTest::testGrowShrink()
{
using namespace KWayland::Client;
// block geometry helper
std::unique_ptr<KWayland::Client::Surface> surface1(Test::createSurface());
QVERIFY(surface1 != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface1(Test::createXdgToplevelSurface(surface1.get()));
QVERIFY(shellSurface1 != nullptr);
Test::render(surface1.get(), QSize(650, 514), Qt::blue);
QVERIFY(Test::waitForWaylandWindowShown());
workspace()->slotWindowMoveRight();
workspace()->slotWindowMoveDown();
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QVERIFY(toplevelConfigureRequestedSpy.isValid());
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.isValid());
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(toplevelConfigureRequestedSpy.wait());
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
// let's place it centered
workspace()->placement()->placeCentered(window, QRect(0, 0, 1280, 1024));
QCOMPARE(window->frameGeometry(), QRect(590, 487, 100, 50));
QFETCH(QString, methodCall);
QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
QVERIFY(surfaceConfigureRequestedSpy.wait());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::red);
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QVERIFY(frameGeometryChangedSpy.isValid());
m_connection->flush();
QVERIFY(frameGeometryChangedSpy.wait());
QTEST(window->frameGeometry(), "expectedGeometry");
}
void MoveResizeWindowTest::testPointerMoveEnd_data()
{
QTest::addColumn<int>("additionalButton");
QTest::newRow("BTN_RIGHT") << BTN_RIGHT;
QTest::newRow("BTN_MIDDLE") << BTN_MIDDLE;
QTest::newRow("BTN_SIDE") << BTN_SIDE;
QTest::newRow("BTN_EXTRA") << BTN_EXTRA;
QTest::newRow("BTN_FORWARD") << BTN_FORWARD;
QTest::newRow("BTN_BACK") << BTN_BACK;
QTest::newRow("BTN_TASK") << BTN_TASK;
for (int i = BTN_TASK + 1; i < BTN_JOYSTICK; i++) {
QTest::newRow(QByteArray::number(i, 16).constData()) << i;
}
}
void MoveResizeWindowTest::testPointerMoveEnd()
{
// this test verifies that moving a window through pointer only ends if all buttons are released
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(window, workspace()->activeWindow());
QVERIFY(!window->isInteractiveMove());
// let's trigger the left button
quint32 timestamp = 1;
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
QVERIFY(!window->isInteractiveMove());
workspace()->slotWindowMove();
QVERIFY(window->isInteractiveMove());
// let's press another button
QFETCH(int, additionalButton);
Test::pointerButtonPressed(additionalButton, timestamp++);
QVERIFY(window->isInteractiveMove());
// release the left button, should still have the window moving
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
QVERIFY(window->isInteractiveMove());
// but releasing the other button should now end moving
Test::pointerButtonReleased(additionalButton, timestamp++);
QVERIFY(!window->isInteractiveMove());
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
}
void MoveResizeWindowTest::testClientSideMove()
{
using namespace KWayland::Client;
Cursors::self()->mouse()->setPos(640, 512);
std::unique_ptr<Pointer> pointer(Test::waylandSeat()->createPointer());
QSignalSpy pointerEnteredSpy(pointer.get(), &Pointer::entered);
QVERIFY(pointerEnteredSpy.isValid());
QSignalSpy pointerLeftSpy(pointer.get(), &Pointer::left);
QVERIFY(pointerLeftSpy.isValid());
QSignalSpy buttonSpy(pointer.get(), &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// move pointer into center of geometry
const QRectF startGeometry = window->frameGeometry();
Cursors::self()->mouse()->setPos(startGeometry.center());
QVERIFY(pointerEnteredSpy.wait());
QCOMPARE(pointerEnteredSpy.first().last().toPoint(), QPoint(50, 25));
// simulate press
quint32 timestamp = 1;
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
QVERIFY(buttonSpy.wait());
QSignalSpy moveStartSpy(window, &Window::clientStartUserMovedResized);
QVERIFY(moveStartSpy.isValid());
shellSurface->move(*Test::waylandSeat(), buttonSpy.first().first().value<quint32>());
QVERIFY(moveStartSpy.wait());
QCOMPARE(window->isInteractiveMove(), true);
QVERIFY(pointerLeftSpy.wait());
// move a bit
QSignalSpy clientMoveStepSpy(window, &Window::clientStepUserMovedResized);
QVERIFY(clientMoveStepSpy.isValid());
const QPointF startPoint = startGeometry.center();
const int dragDistance = QApplication::startDragDistance();
// Why?
Test::pointerMotion(startPoint + QPoint(dragDistance, dragDistance) + QPoint(6, 6), timestamp++);
QCOMPARE(clientMoveStepSpy.count(), 1);
// and release again
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
QVERIFY(pointerEnteredSpy.wait());
QCOMPARE(window->isInteractiveMove(), false);
QCOMPARE(window->frameGeometry(), startGeometry.translated(QPoint(dragDistance, dragDistance) + QPoint(6, 6)));
QCOMPARE(pointerEnteredSpy.last().last().toPoint(), QPoint(50, 25));
}
void MoveResizeWindowTest::testPlasmaShellSurfaceMovable_data()
{
QTest::addColumn<KWayland::Client::PlasmaShellSurface::Role>("role");
QTest::addColumn<bool>("movable");
QTest::addColumn<bool>("movableAcrossScreens");
QTest::addColumn<bool>("resizable");
QTest::newRow("normal") << KWayland::Client::PlasmaShellSurface::Role::Normal << true << true << true;
QTest::newRow("desktop") << KWayland::Client::PlasmaShellSurface::Role::Desktop << false << false << false;
QTest::newRow("panel") << KWayland::Client::PlasmaShellSurface::Role::Panel << false << false << false;
QTest::newRow("osd") << KWayland::Client::PlasmaShellSurface::Role::OnScreenDisplay << false << false << false;
}
void MoveResizeWindowTest::testPlasmaShellSurfaceMovable()
{
// this test verifies that certain window types from PlasmaShellSurface are not moveable or resizable
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// and a PlasmaShellSurface
std::unique_ptr<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(surface.get()));
QVERIFY(plasmaSurface != nullptr);
QFETCH(KWayland::Client::PlasmaShellSurface::Role, role);
plasmaSurface->setRole(role);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QTEST(window->isMovable(), "movable");
QTEST(window->isMovableAcrossScreens(), "movableAcrossScreens");
QTEST(window->isResizable(), "resizable");
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
}
struct XcbConnectionDeleter
{
void operator()(xcb_connection_t *pointer)
{
xcb_disconnect(pointer);
}
};
void MoveResizeWindowTest::testNetMove()
{
// this test verifies that a move request for an X11 window through NET API works
// create an xcb window
std::unique_ptr<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
QVERIFY(!xcb_connection_has_error(c.get()));
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
0, 0, 100, 100,
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, 0, 0);
xcb_icccm_size_hints_set_size(&hints, 1, 100, 100);
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
// let's set a no-border
NETWinInfo winInfo(c.get(), windowId, rootWindow(), NET::WMWindowType, NET::Properties2());
winInfo.setWindowType(NET::Override);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
QVERIFY(windowCreatedSpy.isValid());
QVERIFY(windowCreatedSpy.wait());
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
const QRectF origGeo = window->frameGeometry();
// let's move the cursor outside the window
Cursors::self()->mouse()->setPos(workspace()->activeOutput()->geometry().center());
QVERIFY(!origGeo.contains(Cursors::self()->mouse()->pos()));
QSignalSpy moveStartSpy(window, &X11Window::clientStartUserMovedResized);
QVERIFY(moveStartSpy.isValid());
QSignalSpy moveEndSpy(window, &X11Window::clientFinishUserMovedResized);
QVERIFY(moveEndSpy.isValid());
QSignalSpy moveStepSpy(window, &X11Window::clientStepUserMovedResized);
QVERIFY(moveStepSpy.isValid());
QVERIFY(!workspace()->moveResizeWindow());
// use NETRootInfo to trigger a move request
NETRootInfo root(c.get(), NET::Properties());
root.moveResizeRequest(windowId, origGeo.center().x(), origGeo.center().y(), NET::Move);
xcb_flush(c.get());
QVERIFY(moveStartSpy.wait());
QCOMPARE(workspace()->moveResizeWindow(), window);
QVERIFY(window->isInteractiveMove());
QCOMPARE(window->geometryRestore(), origGeo);
QCOMPARE(Cursors::self()->mouse()->pos(), origGeo.center());
// let's move a step
Cursors::self()->mouse()->setPos(Cursors::self()->mouse()->pos() + QPoint(10, 10));
QCOMPARE(moveStepSpy.count(), 1);
QCOMPARE(moveStepSpy.first().last(), origGeo.translated(10, 10));
// let's cancel the move resize again through the net API
root.moveResizeRequest(windowId, window->frameGeometry().center().x(), window->frameGeometry().center().y(), NET::MoveResizeCancel);
xcb_flush(c.get());
QVERIFY(moveEndSpy.wait());
// and destroy the window again
xcb_unmap_window(c.get(), windowId);
xcb_destroy_window(c.get(), windowId);
xcb_flush(c.get());
c.reset();
QSignalSpy windowClosedSpy(window, &X11Window::windowClosed);
QVERIFY(windowClosedSpy.isValid());
QVERIFY(windowClosedSpy.wait());
}
void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingX11Panel_data()
{
QTest::addColumn<QRect>("panelGeometry");
QTest::addColumn<QPoint>("targetPoint");
QTest::addColumn<QPoint>("expectedAdjustedPoint");
QTest::addColumn<quint32>("hideLocation");
QTest::newRow("top") << QRect(0, 0, 100, 20) << QPoint(50, 25) << QPoint(50, 20) << 0u;
QTest::newRow("bottom") << QRect(0, 1024 - 20, 100, 20) << QPoint(50, 1024 - 25 - 50) << QPoint(50, 1024 - 20 - 50) << 2u;
QTest::newRow("left") << QRect(0, 0, 20, 100) << QPoint(25, 50) << QPoint(20, 50) << 3u;
QTest::newRow("right") << QRect(1280 - 20, 0, 20, 100) << QPoint(1280 - 25 - 100, 50) << QPoint(1280 - 20 - 100, 50) << 1u;
}
void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingX11Panel()
{
// this test verifies that auto hiding panels are ignored when adjusting client geometry
// see BUG 365892
// first create our panel
std::unique_ptr<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
QVERIFY(!xcb_connection_has_error(c.get()));
xcb_window_t windowId = xcb_generate_id(c.get());
QFETCH(QRect, panelGeometry);
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
panelGeometry.x(), panelGeometry.y(), panelGeometry.width(), panelGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, panelGeometry.x(), panelGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, panelGeometry.width(), panelGeometry.height());
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
NETWinInfo winInfo(c.get(), windowId, rootWindow(), NET::WMWindowType, NET::Properties2());
winInfo.setWindowType(NET::Dock);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
QVERIFY(windowCreatedSpy.isValid());
QVERIFY(windowCreatedSpy.wait());
X11Window *panel = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(panel);
QCOMPARE(panel->window(), windowId);
QCOMPARE(panel->frameGeometry(), panelGeometry);
QVERIFY(panel->isDock());
// let's create a window
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
auto testWindow = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(testWindow);
QVERIFY(testWindow->isMovable());
// panel is not yet hidden, we should snap against it
QFETCH(QPoint, targetPoint);
QTEST(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false).toPoint(), "expectedAdjustedPoint");
// now let's hide the panel
QSignalSpy panelHiddenSpy(panel, &Window::windowHidden);
QVERIFY(panelHiddenSpy.isValid());
QFETCH(quint32, hideLocation);
xcb_change_property(c.get(), XCB_PROP_MODE_REPLACE, windowId, atoms->kde_screen_edge_show, XCB_ATOM_CARDINAL, 32, 1, &hideLocation);
xcb_flush(c.get());
QVERIFY(panelHiddenSpy.wait());
// now try to snap again
QCOMPARE(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false), targetPoint);
// and destroy the panel again
xcb_unmap_window(c.get(), windowId);
xcb_destroy_window(c.get(), windowId);
xcb_flush(c.get());
c.reset();
QSignalSpy panelClosedSpy(panel, &X11Window::windowClosed);
QVERIFY(panelClosedSpy.isValid());
QVERIFY(panelClosedSpy.wait());
// snap once more
QCOMPARE(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false), targetPoint);
// and close
QSignalSpy windowClosedSpy(testWindow, &Window::windowClosed);
QVERIFY(windowClosedSpy.isValid());
shellSurface.reset();
surface.reset();
QVERIFY(windowClosedSpy.wait());
}
void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingWaylandPanel_data()
{
QTest::addColumn<QRect>("panelGeometry");
QTest::addColumn<QPoint>("targetPoint");
QTest::addColumn<QPoint>("expectedAdjustedPoint");
QTest::newRow("top") << QRect(0, 0, 100, 20) << QPoint(50, 25) << QPoint(50, 20);
QTest::newRow("bottom") << QRect(0, 1024 - 20, 100, 20) << QPoint(50, 1024 - 25 - 50) << QPoint(50, 1024 - 20 - 50);
QTest::newRow("left") << QRect(0, 0, 20, 100) << QPoint(25, 50) << QPoint(20, 50);
QTest::newRow("right") << QRect(1280 - 20, 0, 20, 100) << QPoint(1280 - 25 - 100, 50) << QPoint(1280 - 20 - 100, 50);
}
void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingWaylandPanel()
{
// this test verifies that auto hiding panels are ignored when adjusting client geometry
// see BUG 365892
// first create our panel
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> panelSurface(Test::createSurface());
QVERIFY(panelSurface != nullptr);
std::unique_ptr<Test::XdgToplevel> panelShellSurface(Test::createXdgToplevelSurface(panelSurface.get()));
QVERIFY(panelShellSurface != nullptr);
std::unique_ptr<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(panelSurface.get()));
QVERIFY(plasmaSurface != nullptr);
plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
plasmaSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AutoHide);
QFETCH(QRect, panelGeometry);
plasmaSurface->setPosition(panelGeometry.topLeft());
// let's render
auto panel = Test::renderAndWaitForShown(panelSurface.get(), panelGeometry.size(), Qt::blue);
QVERIFY(panel);
QCOMPARE(panel->frameGeometry(), panelGeometry);
QVERIFY(panel->isDock());
// let's create a window
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
auto testWindow = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(testWindow);
QVERIFY(testWindow->isMovable());
// panel is not yet hidden, we should snap against it
QFETCH(QPoint, targetPoint);
QTEST(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false).toPoint(), "expectedAdjustedPoint");
// now let's hide the panel
QSignalSpy panelHiddenSpy(panel, &Window::windowHidden);
QVERIFY(panelHiddenSpy.isValid());
plasmaSurface->requestHideAutoHidingPanel();
QVERIFY(panelHiddenSpy.wait());
// now try to snap again
QCOMPARE(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false), targetPoint);
// and destroy the panel again
QSignalSpy panelClosedSpy(panel, &Window::windowClosed);
QVERIFY(panelClosedSpy.isValid());
plasmaSurface.reset();
panelShellSurface.reset();
panelSurface.reset();
QVERIFY(panelClosedSpy.wait());
// snap once more
QCOMPARE(Workspace::self()->adjustWindowPosition(testWindow, targetPoint, false), targetPoint);
// and close
QSignalSpy windowClosedSpy(testWindow, &Window::windowClosed);
QVERIFY(windowClosedSpy.isValid());
shellSurface.reset();
surface.reset();
QVERIFY(windowClosedSpy.wait());
}
void MoveResizeWindowTest::testResizeForVirtualKeyboard_data()
{
QTest::addColumn<QRect>("windowRect");
QTest::addColumn<QRect>("keyboardRect");
QTest::addColumn<QRect>("resizedWindowRect");
QTest::newRow("standard") << QRect(100, 300, 500, 800) << QRect(0, 100, 1280, 500) << QRect(100, 0, 500, 100);
QTest::newRow("same size") << QRect(100, 300, 500, 500) << QRect(0, 600, 1280, 400) << QRect(100, 100, 500, 500);
QTest::newRow("smaller width") << QRect(100, 300, 500, 800) << QRect(300, 100, 100, 500) << QRect(100, 0, 500, 100);
QTest::newRow("no height change") << QRect(100, 300, 500, 500) << QRect(0, 900, 1280, 124) << QRect(100, 300, 500, 500);
QTest::newRow("no width change") << QRect(100, 300, 500, 500) << QRect(0, 400, 100, 500) << QRect(100, 300, 500, 500);
}
void MoveResizeWindowTest::testResizeForVirtualKeyboard()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
QFETCH(QRect, windowRect);
QFETCH(QRect, keyboardRect);
QFETCH(QRect, resizedWindowRect);
// There are three things that may happen when the virtual keyboard geometry
// is set: We move the window to the top and resize it, we move the window
// but don't change its size (if the window is already small enough) or we
// do not change anything because the virtual keyboard does not overlap the
// window. We should verify that, for the first, we get both a position and
// a size change, for the second we only get a position change and for the
// last we get no changes.
bool sizeChange = windowRect.size() != resizedWindowRect.size();
bool positionChange = windowRect.topLeft() != resizedWindowRect.topLeft();
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), windowRect.size(), Qt::blue);
QVERIFY(window);
// The client should receive a configure event upon becoming active.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QVERIFY(toplevelConfigureRequestedSpy.isValid());
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.isValid());
QVERIFY(surfaceConfigureRequestedSpy.wait());
surfaceConfigureRequestedSpy.clear();
window->move(windowRect.topLeft());
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QVERIFY(frameGeometryChangedSpy.isValid());
QCOMPARE(window->frameGeometry(), windowRect);
window->setVirtualKeyboardGeometry(keyboardRect);
if (sizeChange) {
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
} else {
QVERIFY(surfaceConfigureRequestedSpy.count() == 0);
}
// render at the new size
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
if (positionChange || sizeChange) {
QVERIFY(frameGeometryChangedSpy.count() > 0 || frameGeometryChangedSpy.wait());
frameGeometryChangedSpy.clear();
} else {
QVERIFY(frameGeometryChangedSpy.count() == 0);
}
QCOMPARE(window->frameGeometry(), resizedWindowRect);
window->setVirtualKeyboardGeometry(QRect());
if (sizeChange) {
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
}
// render at the new size
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
if (positionChange || sizeChange) {
QVERIFY(frameGeometryChangedSpy.count() > 0 || frameGeometryChangedSpy.wait());
} else {
QVERIFY(frameGeometryChangedSpy.count() == 0);
}
QCOMPARE(window->frameGeometry(), windowRect);
}
void MoveResizeWindowTest::testResizeForVirtualKeyboardWithMaximize()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(500, 800), Qt::blue);
QVERIFY(window);
// The client should receive a configure event upon becoming active.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QVERIFY(toplevelConfigureRequestedSpy.isValid());
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.isValid());
QVERIFY(surfaceConfigureRequestedSpy.wait());
window->move(QPoint(100, 300));
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QVERIFY(frameGeometryChangedSpy.isValid());
QCOMPARE(window->frameGeometry(), QRect(100, 300, 500, 800));
window->setVirtualKeyboardGeometry(QRect(0, 100, 1280, 500));
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
// render at the new size
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(100, 0, 500, 100));
window->setMaximize(true, true);
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
window->setVirtualKeyboardGeometry(QRect());
QVERIFY(!surfaceConfigureRequestedSpy.wait(10));
// render at the size of the configureRequested.. it won't have changed
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(!frameGeometryChangedSpy.wait(10));
// Size will NOT be restored
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
}
void MoveResizeWindowTest::testResizeForVirtualKeyboardWithFullScreen()
{
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(500, 800), Qt::blue);
QVERIFY(window);
// The client should receive a configure event upon becoming active.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QVERIFY(toplevelConfigureRequestedSpy.isValid());
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.isValid());
QVERIFY(surfaceConfigureRequestedSpy.wait());
window->move(QPoint(100, 300));
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QVERIFY(frameGeometryChangedSpy.isValid());
QCOMPARE(window->frameGeometry(), QRect(100, 300, 500, 800));
window->setVirtualKeyboardGeometry(QRect(0, 100, 1280, 500));
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
// render at the new size
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(100, 0, 500, 100));
window->setFullScreen(true, true);
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last()[0].toInt());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
window->setVirtualKeyboardGeometry(QRect());
QVERIFY(!surfaceConfigureRequestedSpy.wait(10));
// render at the size of the configureRequested.. it won't have changed
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(!frameGeometryChangedSpy.wait(10));
// Size will NOT be restored
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
}
void MoveResizeWindowTest::testDestroyMoveClient()
{
// This test verifies that active move operation gets finished when
// the associated client is destroyed.
// Create the test client.
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Start moving the client.
QSignalSpy clientStartMoveResizedSpy(window, &Window::clientStartUserMovedResized);
QVERIFY(clientStartMoveResizedSpy.isValid());
QSignalSpy clientFinishUserMovedResizedSpy(window, &Window::clientFinishUserMovedResized);
QVERIFY(clientFinishUserMovedResizedSpy.isValid());
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
QCOMPARE(window->isInteractiveMove(), false);
QCOMPARE(window->isInteractiveResize(), false);
workspace()->slotWindowMove();
QCOMPARE(clientStartMoveResizedSpy.count(), 1);
QCOMPARE(workspace()->moveResizeWindow(), window);
QCOMPARE(window->isInteractiveMove(), true);
QCOMPARE(window->isInteractiveResize(), false);
// Let's pretend that the client crashed.
shellSurface.reset();
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
}
void MoveResizeWindowTest::testDestroyResizeClient()
{
// This test verifies that active resize operation gets finished when
// the associated client is destroyed.
// Create the test client.
using namespace KWayland::Client;
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Start resizing the client.
QSignalSpy clientStartMoveResizedSpy(window, &Window::clientStartUserMovedResized);
QVERIFY(clientStartMoveResizedSpy.isValid());
QSignalSpy clientFinishUserMovedResizedSpy(window, &Window::clientFinishUserMovedResized);
QVERIFY(clientFinishUserMovedResizedSpy.isValid());
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
QCOMPARE(window->isInteractiveMove(), false);
QCOMPARE(window->isInteractiveResize(), false);
workspace()->slotWindowResize();
QCOMPARE(clientStartMoveResizedSpy.count(), 1);
QCOMPARE(workspace()->moveResizeWindow(), window);
QCOMPARE(window->isInteractiveMove(), false);
QCOMPARE(window->isInteractiveResize(), true);
// Let's pretend that the client crashed.
shellSurface.reset();
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(window));
QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
}
}
WAYLANDTEST_MAIN(KWin::MoveResizeWindowTest)
#include "move_resize_window_test.moc"
Reference in a new issue View git blame Copy permalink