kwin/autotests/integration/touch_input_test.cpp

434 lines
16 KiB
C++
Raw Normal View History

2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "kwin_wayland_test.h"
#include "core/output.h"
#include "pointer_input.h"
#include "touch_input.h"
#include "wayland_server.h"
2022-04-22 17:39:12 +00:00
#include "window.h"
#include "workspace.h"
#include <KWayland/Client/compositor.h>
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/surface.h>
#include <KWayland/Client/touch.h>
2022-10-24 14:41:35 +00:00
#include <QAction>
#include <QSignalSpy>
2022-10-24 14:41:35 +00:00
namespace KWin
{
static const QString s_socketName = QStringLiteral("wayland_test_kwin_touch_input-0");
class TouchInputTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testTouchHidesCursor();
void testMultipleTouchPoints_data();
void testMultipleTouchPoints();
void testCancel();
void testTouchMouseAction();
void testTouchPointCount();
void testUpdateFocusOnDecorationDestroy();
2022-05-27 15:26:24 +00:00
void testGestureDetection();
private:
std::pair<Window *, std::unique_ptr<KWayland::Client::Surface>> showWindow(bool decorated = false);
KWayland::Client::Touch *m_touch = nullptr;
};
void TouchInputTest::initTestCase()
{
2022-04-22 17:39:12 +00:00
qRegisterMetaType<KWin::Window *>();
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(waylandServer()->init(s_socketName));
Test::setOutputConfig({
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
});
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
const auto outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
}
void TouchInputTest::init()
{
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::XdgDecorationV1));
QVERIFY(Test::waitForWaylandTouch());
m_touch = Test::waylandSeat()->createTouch(Test::waylandSeat());
QVERIFY(m_touch);
QVERIFY(m_touch->isValid());
workspace()->setActiveOutput(QPoint(640, 512));
input()->pointer()->warp(QPoint(640, 512));
}
void TouchInputTest::cleanup()
{
delete m_touch;
m_touch = nullptr;
Test::destroyWaylandConnection();
}
std::pair<Window *, std::unique_ptr<KWayland::Client::Surface>> TouchInputTest::showWindow(bool decorated)
{
#define VERIFY(statement) \
if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__)) \
return {nullptr, nullptr};
#define COMPARE(actual, expected) \
if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__)) \
return {nullptr, nullptr};
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
VERIFY(surface.get());
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface.get(), Test::CreationSetup::CreateOnly, surface.get());
VERIFY(shellSurface);
if (decorated) {
wayland: Properly handle async xdg-decoration updates Currently, if a window switches between SSD and CSD, it is possible to encounter a "corrupted" state where the server-side decoration is wrapped around the window while it still has the client-side decoration. The xdg-decoration protocol fixes this problem by saying that decoration updates are bound to xdg_surface configure events. At the moment, kwin sort of applies decoration updates immediately. With this change, decoration updates will be done according to the spec. If the compositor wants to create a decoration, it will send a configure event and apply the decoration when the configure event is acked by the client. In order to send the configure event with a good window geometry size, kwin will create the decoration to query the border size but not assign it to the client yet. As is, KDecoration api doesn't make querying the border size ahead of time easy. The decoration plugin can assign arbitrary border sizes to windows as it pleases it. We could change that, but it effectively means starting KDecoration3 and setting existing window deco ecosystem around kwin on fire the second time, that's off the table. If the compositor wants to remove the decoration, it will send a configure event. When the configure event is acked and the surface is committed, the window decoration will be destroyed. Sync'ing decoration updates to configure events ensures that we cannot end up with having both client-side and server-side decoration. It also helps us to fix a bunch of geometry related issues caused by creating and destroying the decoration without any surface buffer attached yet. BUG: 445259
2021-01-27 15:35:13 +00:00
auto decoration = Test::createXdgToplevelDecorationV1(shellSurface, shellSurface);
decoration->set_mode(Test::XdgToplevelDecorationV1::mode_server_side);
}
wayland: Properly handle async xdg-decoration updates Currently, if a window switches between SSD and CSD, it is possible to encounter a "corrupted" state where the server-side decoration is wrapped around the window while it still has the client-side decoration. The xdg-decoration protocol fixes this problem by saying that decoration updates are bound to xdg_surface configure events. At the moment, kwin sort of applies decoration updates immediately. With this change, decoration updates will be done according to the spec. If the compositor wants to create a decoration, it will send a configure event and apply the decoration when the configure event is acked by the client. In order to send the configure event with a good window geometry size, kwin will create the decoration to query the border size but not assign it to the client yet. As is, KDecoration api doesn't make querying the border size ahead of time easy. The decoration plugin can assign arbitrary border sizes to windows as it pleases it. We could change that, but it effectively means starting KDecoration3 and setting existing window deco ecosystem around kwin on fire the second time, that's off the table. If the compositor wants to remove the decoration, it will send a configure event. When the configure event is acked and the surface is committed, the window decoration will be destroyed. Sync'ing decoration updates to configure events ensures that we cannot end up with having both client-side and server-side decoration. It also helps us to fix a bunch of geometry related issues caused by creating and destroying the decoration without any surface buffer attached yet. BUG: 445259
2021-01-27 15:35:13 +00:00
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
surface->commit(KWayland::Client::Surface::CommitFlag::None);
VERIFY(surfaceConfigureRequestedSpy.wait());
// let's render
wayland: Properly handle async xdg-decoration updates Currently, if a window switches between SSD and CSD, it is possible to encounter a "corrupted" state where the server-side decoration is wrapped around the window while it still has the client-side decoration. The xdg-decoration protocol fixes this problem by saying that decoration updates are bound to xdg_surface configure events. At the moment, kwin sort of applies decoration updates immediately. With this change, decoration updates will be done according to the spec. If the compositor wants to create a decoration, it will send a configure event and apply the decoration when the configure event is acked by the client. In order to send the configure event with a good window geometry size, kwin will create the decoration to query the border size but not assign it to the client yet. As is, KDecoration api doesn't make querying the border size ahead of time easy. The decoration plugin can assign arbitrary border sizes to windows as it pleases it. We could change that, but it effectively means starting KDecoration3 and setting existing window deco ecosystem around kwin on fire the second time, that's off the table. If the compositor wants to remove the decoration, it will send a configure event. When the configure event is acked and the surface is committed, the window decoration will be destroyed. Sync'ing decoration updates to configure events ensures that we cannot end up with having both client-side and server-side decoration. It also helps us to fix a bunch of geometry related issues caused by creating and destroying the decoration without any surface buffer attached yet. BUG: 445259
2021-01-27 15:35:13 +00:00
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
2022-04-23 19:51:16 +00:00
VERIFY(window);
COMPARE(workspace()->activeWindow(), window);
#undef VERIFY
#undef COMPARE
return {window, std::move(surface)};
}
void TouchInputTest::testTouchHidesCursor()
{
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), false);
quint32 timestamp = 1;
Test::touchDown(1, QPointF(125, 125), timestamp++);
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Test::touchDown(2, QPointF(130, 125), timestamp++);
Test::touchUp(2, timestamp++);
Test::touchUp(1, timestamp++);
// now a mouse event should show the cursor again
Test::pointerMotion(QPointF(0, 0), timestamp++);
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), false);
// touch should hide again
Test::touchDown(1, QPointF(125, 125), timestamp++);
Test::touchUp(1, timestamp++);
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), true);
// wheel should also show
Test::pointerAxisVertical(1.0, timestamp++);
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), false);
}
void TouchInputTest::testMultipleTouchPoints_data()
{
QTest::addColumn<bool>("decorated");
QTest::newRow("undecorated") << false;
QTest::newRow("decorated") << true;
}
void TouchInputTest::testMultipleTouchPoints()
{
QFETCH(bool, decorated);
auto [window, surface] = showWindow(decorated);
2022-04-23 19:51:16 +00:00
QCOMPARE(window->isDecorated(), decorated);
window->move(QPoint(100, 100));
QVERIFY(window);
QSignalSpy sequenceStartedSpy(m_touch, &KWayland::Client::Touch::sequenceStarted);
QSignalSpy pointAddedSpy(m_touch, &KWayland::Client::Touch::pointAdded);
QSignalSpy pointMovedSpy(m_touch, &KWayland::Client::Touch::pointMoved);
QSignalSpy pointRemovedSpy(m_touch, &KWayland::Client::Touch::pointRemoved);
QSignalSpy endedSpy(m_touch, &KWayland::Client::Touch::sequenceEnded);
quint32 timestamp = 1;
Test::touchDown(1, window->mapFromLocal(QPointF(25, 25)), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 1);
QCOMPARE(m_touch->sequence().first()->isDown(), true);
QCOMPARE(m_touch->sequence().first()->position(), QPointF(25, 25));
QCOMPARE(pointAddedSpy.count(), 0);
QCOMPARE(pointMovedSpy.count(), 0);
// a point outside the window
Test::touchDown(2, window->mapFromLocal(QPointF(-100, -100)), timestamp++);
QVERIFY(pointAddedSpy.wait());
QCOMPARE(pointAddedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().at(1)->isDown(), true);
QCOMPARE(m_touch->sequence().at(1)->position(), QPointF(-100, -100));
QCOMPARE(pointMovedSpy.count(), 0);
// let's move that one
Test::touchMotion(2, window->mapFromLocal(QPointF(0, 0)), timestamp++);
QVERIFY(pointMovedSpy.wait());
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().at(1)->isDown(), true);
QCOMPARE(m_touch->sequence().at(1)->position(), QPointF(0, 0));
Test::touchUp(1, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 1);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().first()->isDown(), false);
QCOMPARE(endedSpy.count(), 0);
Test::touchUp(2, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 2);
QCOMPARE(m_touch->sequence().count(), 2);
QCOMPARE(m_touch->sequence().first()->isDown(), false);
QCOMPARE(m_touch->sequence().at(1)->isDown(), false);
QCOMPARE(endedSpy.count(), 1);
}
void TouchInputTest::testCancel()
{
auto [window, surface] = showWindow();
2022-04-23 19:51:16 +00:00
window->move(QPoint(100, 100));
QVERIFY(window);
QSignalSpy sequenceStartedSpy(m_touch, &KWayland::Client::Touch::sequenceStarted);
QSignalSpy cancelSpy(m_touch, &KWayland::Client::Touch::sequenceCanceled);
QSignalSpy pointRemovedSpy(m_touch, &KWayland::Client::Touch::pointRemoved);
quint32 timestamp = 1;
Test::touchDown(1, QPointF(125, 125), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
// cancel
Test::touchCancel();
QVERIFY(cancelSpy.wait());
QCOMPARE(cancelSpy.count(), 1);
}
void TouchInputTest::testTouchMouseAction()
{
2022-04-23 19:51:16 +00:00
// this test verifies that a touch down on an inactive window will activate it
// create two windows
auto [c1, surface] = showWindow();
QVERIFY(c1);
auto [c2, surface2] = showWindow();
QVERIFY(c2);
QVERIFY(!c1->isActive());
QVERIFY(c2->isActive());
// also create a sequence started spy as the touch event should be passed through
QSignalSpy sequenceStartedSpy(m_touch, &KWayland::Client::Touch::sequenceStarted);
quint32 timestamp = 1;
Test::touchDown(1, c1->frameGeometry().center(), timestamp++);
QVERIFY(c1->isActive());
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
// cleanup
input()->touch()->cancel();
}
void TouchInputTest::testTouchPointCount()
{
QCOMPARE(input()->touch()->touchPointCount(), 0);
quint32 timestamp = 1;
Test::touchDown(0, QPointF(125, 125), timestamp++);
Test::touchDown(1, QPointF(125, 125), timestamp++);
Test::touchDown(2, QPointF(125, 125), timestamp++);
QCOMPARE(input()->touch()->touchPointCount(), 3);
Test::touchUp(1, timestamp++);
QCOMPARE(input()->touch()->touchPointCount(), 2);
input()->touch()->cancel();
QCOMPARE(input()->touch()->touchPointCount(), 0);
}
void TouchInputTest::testUpdateFocusOnDecorationDestroy()
{
2022-04-23 19:51:16 +00:00
// This test verifies that a maximized window gets it's touch focus
// if decoration was focused and then destroyed on maximize with BorderlessMaximizedWindows option.
QSignalSpy sequenceEndedSpy(m_touch, &KWayland::Client::Touch::sequenceEnded);
// Enable the borderless maximized windows option.
auto group = kwinApp()->config()->group(QStringLiteral("Windows"));
group.writeEntry("BorderlessMaximizedWindows", true);
group.sync();
Workspace::self()->slotReconfigure();
QCOMPARE(options->borderlessMaximizedWindows(), true);
2022-04-23 19:51:16 +00:00
// Create the test window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get(), Test::CreationSetup::CreateOnly));
std::unique_ptr<Test::XdgToplevelDecorationV1> decoration(Test::createXdgToplevelDecorationV1(shellSurface.get()));
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QSignalSpy decorationConfigureRequestedSpy(decoration.get(), &Test::XdgToplevelDecorationV1::configureRequested);
decoration->set_mode(Test::XdgToplevelDecorationV1::mode_server_side);
surface->commit(KWayland::Client::Surface::CommitFlag::None);
// Wait for the initial configure event.
Test::XdgToplevel::States states;
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 1);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(0, 0));
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Maximized));
2022-04-23 19:51:16 +00:00
// Map the window.
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->maximizeMode(), MaximizeMode::MaximizeRestore);
QCOMPARE(window->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
QCOMPARE(window->isDecorated(), true);
// We should receive a configure event when the window becomes active.
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 2);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Maximized));
// Simulate decoration hover
quint32 timestamp = 0;
2022-04-23 19:51:16 +00:00
Test::touchDown(1, window->frameGeometry().topLeft(), timestamp++);
QVERIFY(input()->touch()->decoration());
// Maximize when on decoration
workspace()->slotWindowMaximize();
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 3);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(states.testFlag(Test::XdgToplevel::State::Maximized));
2022-04-23 19:51:16 +00:00
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(1280, 1024), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
2022-04-23 19:51:16 +00:00
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->isDecorated(), false);
// Window should have focus
QVERIFY(!input()->touch()->decoration());
Test::touchUp(1, timestamp++);
QVERIFY(!sequenceEndedSpy.wait(100));
2022-04-23 19:51:16 +00:00
Test::touchDown(2, window->frameGeometry().center(), timestamp++);
Test::touchUp(2, timestamp++);
QVERIFY(sequenceEndedSpy.wait());
2022-04-23 19:51:16 +00:00
// Destroy the window.
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
}
2022-05-27 15:26:24 +00:00
void TouchInputTest::testGestureDetection()
{
#if !KWIN_BUILD_GLOBALSHORTCUTS
QSKIP("Can't test shortcuts without shortcuts");
return;
#endif
2022-05-27 15:26:24 +00:00
bool callbackTriggered = false;
const auto callback = [&callbackTriggered](float progress) {
callbackTriggered = true;
qWarning() << "progress callback!" << progress;
};
QAction action;
input()->forceRegisterTouchscreenSwipeShortcut(SwipeDirection::Right, 3, &action, callback);
2022-05-27 15:26:24 +00:00
// verify that gestures are detected
quint32 timestamp = 1;
Test::touchDown(0, QPointF(500, 125), timestamp++);
Test::touchDown(1, QPointF(500, 125), timestamp++);
Test::touchDown(2, QPointF(500, 125), timestamp++);
Test::touchMotion(0, QPointF(100, 125), timestamp++);
QVERIFY(callbackTriggered);
// verify that gestures are canceled properly
QSignalSpy gestureCancelled(&action, &QAction::triggered);
Test::touchUp(0, timestamp++);
QVERIFY(gestureCancelled.wait());
Test::touchUp(1, timestamp++);
Test::touchUp(2, timestamp++);
callbackTriggered = false;
// verify that touch points too far apart don't trigger a gesture
Test::touchDown(0, QPointF(125, 125), timestamp++);
Test::touchDown(1, QPointF(10000, 125), timestamp++);
Test::touchDown(2, QPointF(125, 125), timestamp++);
QVERIFY(!callbackTriggered);
Test::touchUp(0, timestamp++);
Test::touchUp(1, timestamp++);
Test::touchUp(2, timestamp++);
// verify that touch points triggered too slow don't trigger a gesture
Test::touchDown(0, QPointF(125, 125), timestamp++);
timestamp += 1000;
Test::touchDown(1, QPointF(125, 125), timestamp++);
Test::touchDown(2, QPointF(125, 125), timestamp++);
QVERIFY(!callbackTriggered);
Test::touchUp(0, timestamp++);
Test::touchUp(1, timestamp++);
Test::touchUp(2, timestamp++);
// verify that after a gesture has been canceled but never initiated, gestures still work
Test::touchDown(0, QPointF(500, 125), timestamp++);
Test::touchDown(1, QPointF(500, 125), timestamp++);
Test::touchDown(2, QPointF(500, 125), timestamp++);
Test::touchMotion(0, QPointF(100, 125), timestamp++);
Test::touchMotion(1, QPointF(100, 125), timestamp++);
Test::touchMotion(2, QPointF(100, 125), timestamp++);
QVERIFY(callbackTriggered);
Test::touchUp(0, timestamp++);
Test::touchUp(1, timestamp++);
Test::touchUp(2, timestamp++);
}
}
2016-02-11 08:34:19 +00:00
WAYLANDTEST_MAIN(KWin::TouchInputTest)
#include "touch_input_test.moc"