2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2016-02-09 10:35:15 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
|
2016-02-09 10:35:15 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2016-02-09 10:35:15 +00:00
|
|
|
#include "kwin_wayland_test.h"
|
2020-03-04 07:55:26 +00:00
|
|
|
#include "abstract_client.h"
|
2021-08-31 07:03:05 +00:00
|
|
|
#include "abstract_output.h"
|
2016-04-07 07:24:17 +00:00
|
|
|
#include "platform.h"
|
2021-07-19 22:21:02 +00:00
|
|
|
#include "touch_input.h"
|
2016-02-09 10:35:15 +00:00
|
|
|
#include "cursor.h"
|
|
|
|
#include "screens.h"
|
|
|
|
#include "wayland_server.h"
|
|
|
|
#include "workspace.h"
|
|
|
|
|
|
|
|
#include <KWayland/Client/compositor.h>
|
|
|
|
#include <KWayland/Client/connection_thread.h>
|
|
|
|
#include <KWayland/Client/seat.h>
|
2017-01-10 18:27:42 +00:00
|
|
|
#include <KWayland/Client/server_decoration.h>
|
2016-02-09 10:35:15 +00:00
|
|
|
#include <KWayland/Client/surface.h>
|
|
|
|
#include <KWayland/Client/touch.h>
|
|
|
|
|
|
|
|
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();
|
2018-12-01 13:52:47 +00:00
|
|
|
void testTouchHidesCursor();
|
2017-01-10 18:27:42 +00:00
|
|
|
void testMultipleTouchPoints_data();
|
2016-02-09 10:35:15 +00:00
|
|
|
void testMultipleTouchPoints();
|
|
|
|
void testCancel();
|
2016-02-18 08:57:18 +00:00
|
|
|
void testTouchMouseAction();
|
2021-01-17 22:18:08 +00:00
|
|
|
void testTouchPointCount();
|
2021-07-19 22:21:02 +00:00
|
|
|
void testUpdateFocusOnDecorationDestroy();
|
2016-02-09 10:35:15 +00:00
|
|
|
|
|
|
|
private:
|
2017-01-10 18:27:42 +00:00
|
|
|
AbstractClient *showWindow(bool decorated = false);
|
2016-02-09 10:35:15 +00:00
|
|
|
KWayland::Client::Touch *m_touch = nullptr;
|
|
|
|
};
|
|
|
|
|
|
|
|
void TouchInputTest::initTestCase()
|
|
|
|
{
|
|
|
|
qRegisterMetaType<KWin::AbstractClient*>();
|
2020-07-07 09:32:29 +00:00
|
|
|
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
|
|
|
|
QVERIFY(applicationStartedSpy.isValid());
|
2016-04-07 06:28:35 +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-02-09 10:35:15 +00:00
|
|
|
|
|
|
|
kwinApp()->start();
|
2020-07-07 09:32:29 +00:00
|
|
|
QVERIFY(applicationStartedSpy.wait());
|
2021-08-31 07:03:05 +00:00
|
|
|
const auto outputs = kwinApp()->platform()->enabledOutputs();
|
|
|
|
QCOMPARE(outputs.count(), 2);
|
|
|
|
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
|
|
|
|
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
|
2021-05-08 00:08:22 +00:00
|
|
|
Test::initWaylandWorkspace();
|
2016-02-09 10:35:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TouchInputTest::init()
|
|
|
|
{
|
|
|
|
using namespace KWayland::Client;
|
2021-07-19 22:21:02 +00:00
|
|
|
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat |
|
|
|
|
Test::AdditionalWaylandInterface::Decoration |
|
|
|
|
Test::AdditionalWaylandInterface::XdgDecorationV1));
|
2016-06-30 11:32:54 +00:00
|
|
|
QVERIFY(Test::waitForWaylandTouch());
|
|
|
|
m_touch = Test::waylandSeat()->createTouch(Test::waylandSeat());
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(m_touch);
|
|
|
|
QVERIFY(m_touch->isValid());
|
|
|
|
|
2021-08-28 18:58:29 +00:00
|
|
|
workspace()->setActiveOutput(QPoint(640, 512));
|
2021-08-28 18:40:12 +00:00
|
|
|
Cursors::self()->mouse()->setPos(QPoint(640, 512));
|
2016-02-09 10:35:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TouchInputTest::cleanup()
|
|
|
|
{
|
|
|
|
delete m_touch;
|
|
|
|
m_touch = nullptr;
|
2016-06-30 11:32:54 +00:00
|
|
|
Test::destroyWaylandConnection();
|
2016-02-09 10:35:15 +00:00
|
|
|
}
|
|
|
|
|
2017-01-10 18:27:42 +00:00
|
|
|
AbstractClient *TouchInputTest::showWindow(bool decorated)
|
2016-02-09 10:35:15 +00:00
|
|
|
{
|
|
|
|
using namespace KWayland::Client;
|
|
|
|
#define VERIFY(statement) \
|
|
|
|
if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
|
|
|
|
return nullptr;
|
|
|
|
#define COMPARE(actual, expected) \
|
|
|
|
if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\
|
|
|
|
return nullptr;
|
|
|
|
|
2021-09-03 17:54:03 +00:00
|
|
|
KWayland::Client::Surface *surface = Test::createSurface(Test::waylandCompositor());
|
2016-02-09 10:35:15 +00:00
|
|
|
VERIFY(surface);
|
2021-05-11 05:26:51 +00:00
|
|
|
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
|
2016-02-09 10:35:15 +00:00
|
|
|
VERIFY(shellSurface);
|
2017-01-10 18:27:42 +00:00
|
|
|
if (decorated) {
|
|
|
|
auto deco = Test::waylandServerSideDecoration()->create(surface, surface);
|
|
|
|
QSignalSpy decoSpy(deco, &ServerSideDecoration::modeChanged);
|
|
|
|
VERIFY(decoSpy.isValid());
|
|
|
|
VERIFY(decoSpy.wait());
|
|
|
|
deco->requestMode(ServerSideDecoration::Mode::Server);
|
|
|
|
VERIFY(decoSpy.wait());
|
|
|
|
COMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
|
|
|
|
}
|
2016-02-09 10:35:15 +00:00
|
|
|
// let's render
|
2016-07-01 07:54:44 +00:00
|
|
|
auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
|
2016-02-09 10:35:15 +00:00
|
|
|
|
|
|
|
VERIFY(c);
|
2016-07-01 07:54:44 +00:00
|
|
|
COMPARE(workspace()->activeClient(), c);
|
2016-02-09 10:35:15 +00:00
|
|
|
|
|
|
|
#undef VERIFY
|
|
|
|
#undef COMPARE
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2018-12-01 13:52:47 +00:00
|
|
|
void TouchInputTest::testTouchHidesCursor()
|
|
|
|
{
|
|
|
|
QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
|
|
|
|
quint32 timestamp = 1;
|
|
|
|
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
|
|
|
|
QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
|
|
|
|
kwinApp()->platform()->touchDown(2, QPointF(130, 125), timestamp++);
|
|
|
|
kwinApp()->platform()->touchUp(2, timestamp++);
|
|
|
|
kwinApp()->platform()->touchUp(1, timestamp++);
|
|
|
|
|
|
|
|
// now a mouse event should show the cursor again
|
|
|
|
kwinApp()->platform()->pointerMotion(QPointF(0, 0), timestamp++);
|
|
|
|
QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
|
|
|
|
|
|
|
|
// touch should hide again
|
|
|
|
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
|
|
|
|
kwinApp()->platform()->touchUp(1, timestamp++);
|
|
|
|
QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
|
|
|
|
|
|
|
|
// wheel should also show
|
|
|
|
kwinApp()->platform()->pointerAxisVertical(1.0, timestamp++);
|
|
|
|
QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
|
|
|
|
}
|
|
|
|
|
2017-01-10 18:27:42 +00:00
|
|
|
void TouchInputTest::testMultipleTouchPoints_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<bool>("decorated");
|
|
|
|
|
|
|
|
QTest::newRow("undecorated") << false;
|
|
|
|
QTest::newRow("decorated") << true;
|
|
|
|
}
|
|
|
|
|
2016-02-09 10:35:15 +00:00
|
|
|
void TouchInputTest::testMultipleTouchPoints()
|
|
|
|
{
|
|
|
|
using namespace KWayland::Client;
|
2017-01-10 18:27:42 +00:00
|
|
|
QFETCH(bool, decorated);
|
|
|
|
AbstractClient *c = showWindow(decorated);
|
|
|
|
QCOMPARE(c->isDecorated(), decorated);
|
Rework async geometry updates
Window management features were written with synchronous geometry
updates in mind. Currently, this poses a big problem on Wayland because
geometry updates are done in asynchronous fashion there.
At the moment, geometry is updated in a so called pseudo-asynchronous
fashion, meaning that the frame geometry will be reset to the old value
once geometry updates are unblocked. The main drawback of this approach
is that it is too error prone, the data flow is hard to comprehend, etc.
It is worth noting that there is already a machinery to perform async
geometry which is used during interactive move/resize operations.
This change extends the move/resize geometry usage beyond interactive
move/resize to make asynchronous geometry updates less error prone and
easier to comprehend.
With the proposed solution, all geometry updates must be done on the
move/resize geometry first. After that, the new geometry is passed on to
the Client-specific implementation of moveResizeInternal().
To be more specific, the frameGeometry() returns the current frame
geometry, it is primarily useful only to the scene. If you want to move
or resize a window, you need to use moveResizeGeometry() because it
corresponds to the last requested frame geometry.
It is worth noting that the moveResizeGeometry() returns the desired
bounding geometry. The client may commit the xdg_toplevel surface with a
slightly smaller window geometry, for example to enforce a specific
aspect ratio. The client is not allowed to resize beyond the size as
indicated in moveResizeGeometry().
The data flow is very simple: moveResize() updates the move/resize
geometry and calls the client-specific implementation of the
moveResizeInternal() method. Based on whether a configure event is
needed, moveResizeInternal() will update the frameGeometry() either
immediately or after the client commits a new buffer.
Unfortunately, both the compositor and xdg-shell clients try to update
the window geometry. It means that it's possible to have conflicts
between the two. With this change, the compositor's move resize geometry
will be synced only if there are no pending configure events, meaning
that the user doesn't try to resize the window.
2021-04-30 18:26:09 +00:00
|
|
|
c->move(QPoint(100, 100));
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(c);
|
|
|
|
QSignalSpy sequenceStartedSpy(m_touch, &Touch::sequenceStarted);
|
|
|
|
QVERIFY(sequenceStartedSpy.isValid());
|
|
|
|
QSignalSpy pointAddedSpy(m_touch, &Touch::pointAdded);
|
|
|
|
QVERIFY(pointAddedSpy.isValid());
|
|
|
|
QSignalSpy pointMovedSpy(m_touch, &Touch::pointMoved);
|
|
|
|
QVERIFY(pointMovedSpy.isValid());
|
|
|
|
QSignalSpy pointRemovedSpy(m_touch, &Touch::pointRemoved);
|
|
|
|
QVERIFY(pointRemovedSpy.isValid());
|
|
|
|
QSignalSpy endedSpy(m_touch, &Touch::sequenceEnded);
|
|
|
|
QVERIFY(endedSpy.isValid());
|
|
|
|
|
|
|
|
quint32 timestamp = 1;
|
2017-01-10 18:27:42 +00:00
|
|
|
kwinApp()->platform()->touchDown(1, QPointF(125, 125) + c->clientPos(), timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
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
|
2017-01-10 18:27:42 +00:00
|
|
|
kwinApp()->platform()->touchDown(2, QPointF(0, 0) + c->clientPos(), timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
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
|
2017-01-10 18:27:42 +00:00
|
|
|
kwinApp()->platform()->touchMotion(2, QPointF(100, 100) + c->clientPos(), timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
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));
|
|
|
|
|
2016-04-07 06:28:35 +00:00
|
|
|
kwinApp()->platform()->touchUp(1, timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(pointRemovedSpy.wait());
|
|
|
|
QCOMPARE(pointRemovedSpy.count(), 1);
|
|
|
|
QCOMPARE(m_touch->sequence().count(), 2);
|
|
|
|
QCOMPARE(m_touch->sequence().first()->isDown(), false);
|
|
|
|
QCOMPARE(endedSpy.count(), 0);
|
|
|
|
|
2016-04-07 06:28:35 +00:00
|
|
|
kwinApp()->platform()->touchUp(2, timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
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()
|
|
|
|
{
|
|
|
|
using namespace KWayland::Client;
|
|
|
|
AbstractClient *c = showWindow();
|
Rework async geometry updates
Window management features were written with synchronous geometry
updates in mind. Currently, this poses a big problem on Wayland because
geometry updates are done in asynchronous fashion there.
At the moment, geometry is updated in a so called pseudo-asynchronous
fashion, meaning that the frame geometry will be reset to the old value
once geometry updates are unblocked. The main drawback of this approach
is that it is too error prone, the data flow is hard to comprehend, etc.
It is worth noting that there is already a machinery to perform async
geometry which is used during interactive move/resize operations.
This change extends the move/resize geometry usage beyond interactive
move/resize to make asynchronous geometry updates less error prone and
easier to comprehend.
With the proposed solution, all geometry updates must be done on the
move/resize geometry first. After that, the new geometry is passed on to
the Client-specific implementation of moveResizeInternal().
To be more specific, the frameGeometry() returns the current frame
geometry, it is primarily useful only to the scene. If you want to move
or resize a window, you need to use moveResizeGeometry() because it
corresponds to the last requested frame geometry.
It is worth noting that the moveResizeGeometry() returns the desired
bounding geometry. The client may commit the xdg_toplevel surface with a
slightly smaller window geometry, for example to enforce a specific
aspect ratio. The client is not allowed to resize beyond the size as
indicated in moveResizeGeometry().
The data flow is very simple: moveResize() updates the move/resize
geometry and calls the client-specific implementation of the
moveResizeInternal() method. Based on whether a configure event is
needed, moveResizeInternal() will update the frameGeometry() either
immediately or after the client commits a new buffer.
Unfortunately, both the compositor and xdg-shell clients try to update
the window geometry. It means that it's possible to have conflicts
between the two. With this change, the compositor's move resize geometry
will be synced only if there are no pending configure events, meaning
that the user doesn't try to resize the window.
2021-04-30 18:26:09 +00:00
|
|
|
c->move(QPoint(100, 100));
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(c);
|
|
|
|
QSignalSpy sequenceStartedSpy(m_touch, &Touch::sequenceStarted);
|
|
|
|
QVERIFY(sequenceStartedSpy.isValid());
|
|
|
|
QSignalSpy cancelSpy(m_touch, &Touch::sequenceCanceled);
|
|
|
|
QVERIFY(cancelSpy.isValid());
|
2016-02-09 13:50:30 +00:00
|
|
|
QSignalSpy pointRemovedSpy(m_touch, &Touch::pointRemoved);
|
|
|
|
QVERIFY(pointRemovedSpy.isValid());
|
2016-02-09 10:35:15 +00:00
|
|
|
|
|
|
|
quint32 timestamp = 1;
|
2016-04-07 06:28:35 +00:00
|
|
|
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(sequenceStartedSpy.wait());
|
|
|
|
QCOMPARE(sequenceStartedSpy.count(), 1);
|
|
|
|
|
|
|
|
// cancel
|
2016-04-07 06:28:35 +00:00
|
|
|
kwinApp()->platform()->touchCancel();
|
2016-02-09 10:35:15 +00:00
|
|
|
QVERIFY(cancelSpy.wait());
|
|
|
|
QCOMPARE(cancelSpy.count(), 1);
|
|
|
|
}
|
|
|
|
|
2016-02-18 08:57:18 +00:00
|
|
|
void TouchInputTest::testTouchMouseAction()
|
|
|
|
{
|
|
|
|
// this test verifies that a touch down on an inactive client will activate it
|
|
|
|
using namespace KWayland::Client;
|
|
|
|
// create two windows
|
|
|
|
AbstractClient *c1 = showWindow();
|
|
|
|
QVERIFY(c1);
|
|
|
|
AbstractClient *c2 = 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, &Touch::sequenceStarted);
|
|
|
|
QVERIFY(sequenceStartedSpy.isValid());
|
|
|
|
|
|
|
|
quint32 timestamp = 1;
|
2019-09-27 10:01:10 +00:00
|
|
|
kwinApp()->platform()->touchDown(1, c1->frameGeometry().center(), timestamp++);
|
2016-02-18 08:57:18 +00:00
|
|
|
QVERIFY(c1->isActive());
|
|
|
|
|
|
|
|
QVERIFY(sequenceStartedSpy.wait());
|
|
|
|
QCOMPARE(sequenceStartedSpy.count(), 1);
|
|
|
|
|
|
|
|
// cleanup
|
2021-01-17 22:18:08 +00:00
|
|
|
kwinApp()->platform()->cancelTouchSequence();
|
|
|
|
}
|
|
|
|
|
|
|
|
void TouchInputTest::testTouchPointCount()
|
|
|
|
{
|
2021-10-28 07:55:59 +00:00
|
|
|
QCOMPARE(input()->touch()->touchPointCount(), 0);
|
2021-01-17 22:18:08 +00:00
|
|
|
quint32 timestamp = 1;
|
|
|
|
kwinApp()->platform()->touchDown(0, QPointF(125, 125), timestamp++);
|
|
|
|
kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
|
|
|
|
kwinApp()->platform()->touchDown(2, QPointF(125, 125), timestamp++);
|
2021-10-28 07:55:59 +00:00
|
|
|
QCOMPARE(input()->touch()->touchPointCount(), 3);
|
2021-01-17 22:18:08 +00:00
|
|
|
|
|
|
|
kwinApp()->platform()->touchUp(1, timestamp++);
|
2021-10-28 07:55:59 +00:00
|
|
|
QCOMPARE(input()->touch()->touchPointCount(), 2);
|
2021-01-17 22:18:08 +00:00
|
|
|
|
|
|
|
kwinApp()->platform()->cancelTouchSequence();
|
2021-10-28 07:55:59 +00:00
|
|
|
QCOMPARE(input()->touch()->touchPointCount(), 0);
|
2016-02-18 08:57:18 +00:00
|
|
|
}
|
|
|
|
|
2021-07-19 22:21:02 +00:00
|
|
|
void TouchInputTest::testUpdateFocusOnDecorationDestroy()
|
|
|
|
{
|
|
|
|
// This test verifies that a maximized client 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);
|
|
|
|
QVERIFY(sequenceEndedSpy.isValid());
|
|
|
|
|
|
|
|
// Enable the borderless maximized windows option.
|
|
|
|
auto group = kwinApp()->config()->group("Windows");
|
|
|
|
group.writeEntry("BorderlessMaximizedWindows", true);
|
|
|
|
group.sync();
|
|
|
|
Workspace::self()->slotReconfigure();
|
|
|
|
QCOMPARE(options->borderlessMaximizedWindows(), true);
|
|
|
|
|
|
|
|
// Create the test client.
|
|
|
|
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
|
2021-12-09 07:47:55 +00:00
|
|
|
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data(), Test::CreationSetup::CreateOnly));
|
2021-07-19 22:21:02 +00:00
|
|
|
QScopedPointer<Test::XdgToplevelDecorationV1> decoration(Test::createXdgToplevelDecorationV1(shellSurface.data()));
|
|
|
|
|
|
|
|
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.data(), &Test::XdgToplevel::configureRequested);
|
|
|
|
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
|
|
|
|
QSignalSpy decorationConfigureRequestedSpy(decoration.data(), &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));
|
|
|
|
|
|
|
|
// Map the client.
|
|
|
|
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
|
|
|
|
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
|
|
|
|
QVERIFY(client);
|
|
|
|
QVERIFY(client->isActive());
|
|
|
|
QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
|
|
|
|
QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
|
|
|
|
QCOMPARE(client->isDecorated(), true);
|
|
|
|
|
|
|
|
// We should receive a configure event when the client 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;
|
|
|
|
kwinApp()->platform()->touchDown(1, client->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));
|
|
|
|
|
|
|
|
QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
|
|
|
|
QVERIFY(frameGeometryChangedSpy.isValid());
|
|
|
|
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
|
|
|
|
Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
|
|
|
|
QVERIFY(frameGeometryChangedSpy.wait());
|
|
|
|
QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
|
|
|
|
QCOMPARE(client->maximizeMode(), MaximizeFull);
|
|
|
|
QCOMPARE(client->requestedMaximizeMode(), MaximizeFull);
|
|
|
|
QCOMPARE(client->isDecorated(), false);
|
|
|
|
|
|
|
|
// Window should have focus
|
|
|
|
QVERIFY(!input()->touch()->decoration());
|
|
|
|
kwinApp()->platform()->touchUp(1, timestamp++);
|
|
|
|
QVERIFY(!sequenceEndedSpy.wait(100));
|
|
|
|
kwinApp()->platform()->touchDown(2, client->frameGeometry().center(), timestamp++);
|
|
|
|
kwinApp()->platform()->touchUp(2, timestamp++);
|
|
|
|
QVERIFY(sequenceEndedSpy.wait());
|
|
|
|
|
|
|
|
// Destroy the client.
|
|
|
|
shellSurface.reset();
|
|
|
|
QVERIFY(Test::waitForWindowDestroyed(client));
|
|
|
|
}
|
|
|
|
|
2016-02-09 10:35:15 +00:00
|
|
|
}
|
|
|
|
|
2016-02-11 08:34:19 +00:00
|
|
|
WAYLANDTEST_MAIN(KWin::TouchInputTest)
|
2016-02-09 10:35:15 +00:00
|
|
|
#include "touch_input_test.moc"
|