yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/wayland/autotests/server/test_seat.cpp

209 lines
6.6 KiB
C++
Raw Normal View History

KWayland: Convert license headers to SPDX Summary: Convert license headers to SPDX expressions and add license files as required by REUSE specification. Reviewers: zzag Reviewed By: zzag Subscribers: kde-frameworks-devel Tags: #frameworks Maniphest Tasks: T11550 Differential Revision: https://phabricator.kde.org/D28058
2020-03-15 15:19:28 +00:00
/*
SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
KWayland: Convert license headers to SPDX Summary: Convert license headers to SPDX expressions and add license files as required by REUSE specification. Reviewers: zzag Reviewed By: zzag Subscribers: kde-frameworks-devel Tags: #frameworks Maniphest Tasks: T11550 Differential Revision: https://phabricator.kde.org/D28058
2020-03-15 15:19:28 +00:00
SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// Qt
Remove qt include prefixx
2018-11-06 06:22:36 +00:00
#include <QtTest>
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// WaylandServer
Add a build system Framework style build system which generates two libraries: * KF5WaylandClient * KF5WaylandServer autotests are adjusted to compile again. They need to be changed to use the libraries once the export header gets generated.
2014-09-17 12:35:33 +00:00
#include "../../src/server/display.h"
[server] Move PointerInterface into own .h and .cpp
2014-11-25 12:52:40 +00:00
#include "../../src/server/pointer_interface.h"
Add a build system Framework style build system which generates two libraries: * KF5WaylandClient * KF5WaylandServer autotests are adjusted to compile again. They need to be changed to use the libraries once the export header gets generated.
2014-09-17 12:35:33 +00:00
#include "../../src/server/seat_interface.h"
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
Port namespaces and includes
2020-04-29 14:56:38 +00:00
using namespace KWaylandServer;
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
class TestWaylandServerSeat : public QObject
{
Q_OBJECT
private Q_SLOTS:
void testCapabilities();
void testName();
void testPointerButton();
void testPointerPos();
Implement repeat info on wl_keyboard protocol * Raises wl_seat supported version to 4 in both server and client * Raises wl_keyboard supported version to 4 in wl_keyboard * wl_pointer and wl_touch are still on version 3 * Raises minimum Wayland version to 1.6
2015-09-02 14:00:11 +00:00
void testRepeatInfo();
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
void testMultiple();
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
};
static const QString s_socketName = QStringLiteral("kwin-wayland-server-seat-test-0");
void TestWaylandServerSeat::testCapabilities()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
display.start();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat = new SeatInterface(&display);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
QVERIFY(!seat->hasKeyboard());
QVERIFY(!seat->hasPointer());
QVERIFY(!seat->hasTouch());
QSignalSpy keyboardSpy(seat, SIGNAL(hasKeyboardChanged(bool)));
QVERIFY(keyboardSpy.isValid());
seat->setHasKeyboard(true);
QCOMPARE(keyboardSpy.count(), 1);
QVERIFY(keyboardSpy.last().first().toBool());
QVERIFY(seat->hasKeyboard());
seat->setHasKeyboard(false);
QCOMPARE(keyboardSpy.count(), 2);
QVERIFY(!keyboardSpy.last().first().toBool());
QVERIFY(!seat->hasKeyboard());
seat->setHasKeyboard(false);
QCOMPARE(keyboardSpy.count(), 2);
QSignalSpy pointerSpy(seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
seat->setHasPointer(true);
QCOMPARE(pointerSpy.count(), 1);
QVERIFY(pointerSpy.last().first().toBool());
QVERIFY(seat->hasPointer());
seat->setHasPointer(false);
QCOMPARE(pointerSpy.count(), 2);
QVERIFY(!pointerSpy.last().first().toBool());
QVERIFY(!seat->hasPointer());
seat->setHasPointer(false);
QCOMPARE(pointerSpy.count(), 2);
QSignalSpy touchSpy(seat, SIGNAL(hasTouchChanged(bool)));
QVERIFY(touchSpy.isValid());
seat->setHasTouch(true);
QCOMPARE(touchSpy.count(), 1);
QVERIFY(touchSpy.last().first().toBool());
QVERIFY(seat->hasTouch());
seat->setHasTouch(false);
QCOMPARE(touchSpy.count(), 2);
QVERIFY(!touchSpy.last().first().toBool());
QVERIFY(!seat->hasTouch());
seat->setHasTouch(false);
QCOMPARE(touchSpy.count(), 2);
}
void TestWaylandServerSeat::testName()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
display.start();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat = new SeatInterface(&display);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
QCOMPARE(seat->name(), QString());
QSignalSpy nameSpy(seat, SIGNAL(nameChanged(QString)));
QVERIFY(nameSpy.isValid());
const QString name = QStringLiteral("foobar");
seat->setName(name);
QCOMPARE(seat->name(), name);
QCOMPARE(nameSpy.count(), 1);
QCOMPARE(nameSpy.first().first().toString(), name);
seat->setName(name);
QCOMPARE(nameSpy.count(), 1);
}
void TestWaylandServerSeat::testPointerButton()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
display.start();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat = new SeatInterface(&display);
[server] Add a SeatInterface::focusedPointer This method is supposed to return the PointerInterface for the current focused surface. At the moment it just creates the one global PointerInterface. The existing SeatInterface::pointer method got removed as that is actually wrong usage.
2014-11-25 15:04:07 +00:00
PointerInterface *pointer = seat->focusedPointer();
Create one PointerInterface for each pointer wl_resource Makes PointerInterface more like other Interface classes wrapping wl_resource. The most important change is the handling of the focused surface. This is now kept in the SeatInterface and can also be set if there is no PointerInterface for the client yet. The unit tests had to be adjusted and some are also disabled as the button events are not yet moved into SeatInterface.
2014-11-26 09:34:23 +00:00
QVERIFY(!pointer);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// no button pressed yet, should be released and no serial
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
QVERIFY(!seat->isPointerButtonPressed(0));
QVERIFY(!seat->isPointerButtonPressed(1));
QCOMPARE(seat->pointerButtonSerial(0), quint32(0));
QCOMPARE(seat->pointerButtonSerial(1), quint32(0));
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// mark the button as pressed
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
seat->pointerButtonPressed(0);
QVERIFY(seat->isPointerButtonPressed(0));
QCOMPARE(seat->pointerButtonSerial(0), display.serial());
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// other button should still be unpressed
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
QVERIFY(!seat->isPointerButtonPressed(1));
QCOMPARE(seat->pointerButtonSerial(1), quint32(0));
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
// release it again
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
seat->pointerButtonReleased(0);
QVERIFY(!seat->isPointerButtonPressed(0));
QCOMPARE(seat->pointerButtonSerial(0), display.serial());
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
}
void TestWaylandServerSeat::testPointerPos()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
display.start();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat = new SeatInterface(&display);
[server] Move pointer position from PointerInterface to SeatInterface PointerInterface should only wrap a Resource. In order to do so all global state needs to move into the Global.
2014-11-25 13:24:52 +00:00
QSignalSpy seatPosSpy(seat, SIGNAL(pointerPosChanged(QPointF)));
QVERIFY(seatPosSpy.isValid());
[server] Add a SeatInterface::focusedPointer This method is supposed to return the PointerInterface for the current focused surface. At the moment it just creates the one global PointerInterface. The existing SeatInterface::pointer method got removed as that is actually wrong usage.
2014-11-25 15:04:07 +00:00
PointerInterface *pointer = seat->focusedPointer();
Create one PointerInterface for each pointer wl_resource Makes PointerInterface more like other Interface classes wrapping wl_resource. The most important change is the handling of the focused surface. This is now kept in the SeatInterface and can also be set if there is no PointerInterface for the client yet. The unit tests had to be adjusted and some are also disabled as the button events are not yet moved into SeatInterface.
2014-11-26 09:34:23 +00:00
QVERIFY(!pointer);
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
[server] Move pointer position from PointerInterface to SeatInterface PointerInterface should only wrap a Resource. In order to do so all global state needs to move into the Global.
2014-11-25 13:24:52 +00:00
QCOMPARE(seat->pointerPos(), QPointF());
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
seat->setPointerPos(QPointF(10, 15));
[server] Move pointer position from PointerInterface to SeatInterface PointerInterface should only wrap a Resource. In order to do so all global state needs to move into the Global.
2014-11-25 13:24:52 +00:00
QCOMPARE(seat->pointerPos(), QPointF(10, 15));
QCOMPARE(seatPosSpy.count(), 1);
QCOMPARE(seatPosSpy.first().first().toPointF(), QPointF(10, 15));
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
Move pointer button handling from PointerInterface to SeatInterface The button state is a seat-global state and not a per pointer state. All pressed/released and axis events are moved to the SeatInterface and just invoke the related method on the focused surface pointer.
2014-11-26 10:50:52 +00:00
seat->setPointerPos(QPointF(10, 15));
[server] Move pointer position from PointerInterface to SeatInterface PointerInterface should only wrap a Resource. In order to do so all global state needs to move into the Global.
2014-11-25 13:24:52 +00:00
QCOMPARE(seatPosSpy.count(), 1);
seat->setPointerPos(QPointF(5, 7));
QCOMPARE(seat->pointerPos(), QPointF(5, 7));
QCOMPARE(seatPosSpy.count(), 2);
QCOMPARE(seatPosSpy.first().first().toPointF(), QPointF(10, 15));
QCOMPARE(seatPosSpy.last().first().toPointF(), QPointF(5, 7));
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
}
Implement repeat info on wl_keyboard protocol * Raises wl_seat supported version to 4 in both server and client * Raises wl_keyboard supported version to 4 in wl_keyboard * wl_pointer and wl_touch are still on version 3 * Raises minimum Wayland version to 1.6
2015-09-02 14:00:11 +00:00
void TestWaylandServerSeat::testRepeatInfo()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
Implement repeat info on wl_keyboard protocol * Raises wl_seat supported version to 4 in both server and client * Raises wl_keyboard supported version to 4 in wl_keyboard * wl_pointer and wl_touch are still on version 3 * Raises minimum Wayland version to 1.6
2015-09-02 14:00:11 +00:00
display.start();
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat = new SeatInterface(&display);
move keyboard to the new approach and refactor the keyboard_interface - Get rid of the KF5 deprecated methods related to keymap, kwayland-server is not source compatible with kwayland, so we don't need to keep the deprecated methods - Move the key repeat, modifiers and keymap handling fully into the KeyboardInterface. - Get rid of some of the keyboard related code base from the seat_interface. Co-Author: Bhushan Shah <bshah@kde.org>
2020-10-02 14:22:59 +00:00
seat->setHasKeyboard(true);
QCOMPARE(seat->keyboard()->keyRepeatRate(), 0);
QCOMPARE(seat->keyboard()->keyRepeatDelay(), 0);
keyboard_interface: remove wrapper methods from the seat_interface And make them public in th keyboard_interface, there's no point in wrapping this in seat_interface with new approach See also: plasma/kwayland-server#13
2020-11-06 04:33:47 +00:00
seat->keyboard()->setRepeatInfo(25, 660);
move keyboard to the new approach and refactor the keyboard_interface - Get rid of the KF5 deprecated methods related to keymap, kwayland-server is not source compatible with kwayland, so we don't need to keep the deprecated methods - Move the key repeat, modifiers and keymap handling fully into the KeyboardInterface. - Get rid of some of the keyboard related code base from the seat_interface. Co-Author: Bhushan Shah <bshah@kde.org>
2020-10-02 14:22:59 +00:00
QCOMPARE(seat->keyboard()->keyRepeatRate(), 25);
QCOMPARE(seat->keyboard()->keyRepeatDelay(), 660);
Implement repeat info on wl_keyboard protocol * Raises wl_seat supported version to 4 in both server and client * Raises wl_keyboard supported version to 4 in wl_keyboard * wl_pointer and wl_touch are still on version 3 * Raises minimum Wayland version to 1.6
2015-09-02 14:00:11 +00:00
// setting negative values should result in 0
keyboard_interface: remove wrapper methods from the seat_interface And make them public in th keyboard_interface, there's no point in wrapping this in seat_interface with new approach See also: plasma/kwayland-server#13
2020-11-06 04:33:47 +00:00
seat->keyboard()->setRepeatInfo(-25, -660);
move keyboard to the new approach and refactor the keyboard_interface - Get rid of the KF5 deprecated methods related to keymap, kwayland-server is not source compatible with kwayland, so we don't need to keep the deprecated methods - Move the key repeat, modifiers and keymap handling fully into the KeyboardInterface. - Get rid of some of the keyboard related code base from the seat_interface. Co-Author: Bhushan Shah <bshah@kde.org>
2020-10-02 14:22:59 +00:00
QCOMPARE(seat->keyboard()->keyRepeatRate(), 0);
QCOMPARE(seat->keyboard()->keyRepeatDelay(), 0);
Implement repeat info on wl_keyboard protocol * Raises wl_seat supported version to 4 in both server and client * Raises wl_keyboard supported version to 4 in wl_keyboard * wl_pointer and wl_touch are still on version 3 * Raises minimum Wayland version to 1.6
2015-09-02 14:00:11 +00:00
}
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
void TestWaylandServerSeat::testMultiple()
{
Display display;
Allow accepting client connections on multiple sockets libwayland-server allows the wl_display accept client connections on more than one socket. We currently don't listen on multiple sockets, but it would be nice if Display supported such operation mode.
2020-10-19 15:52:56 +00:00
display.addSocketName(s_socketName);
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
display.start();
QVERIFY(display.seats().isEmpty());
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat1 = new SeatInterface(&display);
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
QCOMPARE(display.seats().count(), 1);
QCOMPARE(display.seats().at(0), seat1);
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat2 = new SeatInterface(&display);
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
QCOMPARE(display.seats().count(), 2);
QCOMPARE(display.seats().at(0), seat1);
QCOMPARE(display.seats().at(1), seat2);
Remove factory methods in Display The main reason why we have factory methods is that up to some point, kwayland had its own signal to indicate when globals have to be removed. Now that all globals add destroy listeners for the wl_display object, we don't have that signal. Most factory methods are equivalent to doing new T(display). Besides adding unnecessary boilerplate code, another reason to get rid of the factory methods is to reduce the amount of merge conflicts. If several persons work on implementing wayland protocols at the same time, sooner or later someone will have to resolve merge conflicts in Display.
2020-12-09 20:13:19 +00:00
SeatInterface *seat3 = new SeatInterface(&display);
[server] Add Display::seats() -> QVector<SeatInterface*> Similar to OutputInterfaces we can have multiple SeatInterfaces so expose a way to get to all SeatInterfaces. REVIEW: 126364
2015-12-15 14:47:19 +00:00
QCOMPARE(display.seats().count(), 3);
QCOMPARE(display.seats().at(0), seat1);
QCOMPARE(display.seats().at(1), seat2);
QCOMPARE(display.seats().at(2), seat3);
delete seat3;
QCOMPARE(display.seats().count(), 2);
QCOMPARE(display.seats().at(0), seat1);
QCOMPARE(display.seats().at(1), seat2);
delete seat2;
QCOMPARE(display.seats().count(), 1);
QCOMPARE(display.seats().at(0), seat1);
delete seat1;
QCOMPARE(display.seats().count(), 0);
}
Switch all auto tests to QTEST_GUILESS_MAIN We don't need a QGuiApplication in the tests.
2014-09-23 10:00:17 +00:00
QTEST_GUILESS_MAIN(TestWaylandServerSeat)
[kwin_wayland] Add SeatInterface to server module So far the Seat interface is provided together with pointer and keyboard. As always touch is not yet implemented. The pointer interface is still lacking the set cursor callback. Keyboard on the other hand is complete. Both Keyboard and Pointer have the concept of a focused surface and only to the bound interface belonging to the same client as the focused surface events are sent. The change comes with a set of new auto tests also verifying the client side which wasn't possible before as we couldn't fake events.
2014-09-02 07:34:31 +00:00
#include "test_seat.moc"
Reference in a new issue Copy permalink