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

2489 lines
102 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
// KWin
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/client/compositor.h"
#include "../../src/client/connection_thread.h"
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
#include "../../src/client/datadevice.h"
#include "../../src/client/datadevicemanager.h"
#include "../../src/client/datasource.h"
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
#include "../../src/client/event_queue.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/client/keyboard.h"
#include "../../src/client/pointer.h"
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
#include "../../src/client/pointergestures.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/client/surface.h"
#include "../../src/client/registry.h"
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
#include "../../src/client/relativepointer.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/client/seat.h"
#include "../../src/client/shm_pool.h"
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
#include "../../src/client/subcompositor.h"
#include "../../src/client/subsurface.h"
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
#include "../../src/client/touch.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/buffer_interface.h"
#include "../../src/server/compositor_interface.h"
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
#include "../../src/server/datadevicemanager_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/display.h"
[server] Move KeyboardInterface into dedicated .h and .cpp
2014-11-25 12:39:24 +00:00
#include "../../src/server/keyboard_interface.h"
[server] Move PointerInterface into own .h and .cpp
2014-11-25 12:52:40 +00:00
#include "../../src/server/pointer_interface.h"
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
#include "../../src/server/pointergestures_interface.h"
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
#include "../../src/server/relativepointer_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"
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
#include "../../src/server/subcompositor_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/surface_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
// Wayland
#include <wayland-client-protocol.h>
#include <linux/input.h>
Properly handle destroying a Keyboard resource Summary: On client side the newer wl_keyboard_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the KeyboardInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound KeyboardInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2036
2016-06-28 15:02:22 +00:00
// System
#include <fcntl.h>
#include <unistd.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
class TestWaylandSeat : public QObject
{
Q_OBJECT
public:
explicit TestWaylandSeat(QObject *parent = nullptr);
private Q_SLOTS:
void init();
void cleanup();
void testName();
void testCapabilities_data();
void testCapabilities();
void testPointer();
[server] Add support for pointer input transformation So far we only supported mapping global to surface-local coordinates using a 2D-offset. With this change it's possible to register a QMatrix4x4 to describe the transformation for going from global to surface-local coordinates in a full 3D space. The existing 2D-offset is transformed to use the new matrix based variant describing a translation. REVIEW: 126271
2015-12-07 10:45:34 +00:00
void testPointerTransformation_data();
void testPointerTransformation();
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
void testPointerButton_data();
void testPointerButton();
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
void testPointerSubSurfaceTree();
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
void testPointerSwipeGesture_data();
void testPointerSwipeGesture();
void testPointerPinchGesture_data();
void testPointerPinchGesture();
Allow compositors to send discrete axis values Summary: So far not all v5 features were implemented because most of them are optional. But given that XWayland needs axis_discrete event maybe it's time to implement them. CCBUG: 404152 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, mthw, kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D18933
2019-02-11 16:35:23 +00:00
void testPointerAxis();
[server] Pass keyboard focus to child surface on pointer click If the focused pointer and keyboard surface is the same we use pointer clicks as a hint to which child surface should have keyboard focus. Keyboard focus handling for sub surfaces is rather limited overall. We just don't have a good model on how to determine which child surface should get the keyboard focus. When passing focus to a surface there is no way to know which of the sub-surfaces should get the focus. Ideally the client should handle this, but that's just not the case. The best we have is a reference through the pointer. But that's of course also limited. Keyboard focus passed to the surface for another reason (Alt+Tab) cannot select the proper sub-surface without interaction from another input device. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1330
2016-04-06 11:50:19 +00:00
void testKeyboardSubSurfaceTreeFromPointer();
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
void testCursor();
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
void testCursorDamage();
[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 testKeyboard();
Add test case for operator cast in Client::Seat
2014-09-22 09:56:48 +00:00
void testCast();
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
void testDestroy();
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
void testSelection();
[server] Ensure we have a DataSource on the DataDevice in setSelection Summary: SeatInterface provides a way to set the current selection. This method did not verify whether the new DataDeviceInterface actually has a DataSourceInterface. If there is no DataSourceInterface on that DataDeviceInterface the selection should not be sent to the current selection owner. This results in a crash as DataOfferInterface (correctly) doesn't expect the passed in DataSourceInterface to be null. To ensure we don't hit this again the DataOfferInterface ctor gained an Q_ASSERT to validate the DataSourceInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3148
2016-10-24 08:04:33 +00:00
void testSelectionNoDataSource();
[server] Fix possible crash on creation of DataDevice Summary: This is a similar condition as D3148. If a DataDeviceInterface is created for the currently focused keyboard Surface the current selection is sent to the new DataDeviceInterface. If the current selection does not have a DataSourceInterface a DataOfferInterface for a null DataSourceInterface would be created and result in a crash. This change verifies that there is a DataSourcInterface on the current selection prior to sending out the selection. Test Plan: A test case is added which simulates the condition by using two clients. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3149
2016-10-24 09:05:04 +00:00
void testDataDeviceForKeyboardSurface();
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
void testTouch();
[server] Improve the handling when clients disconnect Summary: So far the server component performed manual cleanup in some cases when a client disconnects. But this is not needed: the Wayland library calls the static unbind methods which do cleanup. If we cleanup ourselves this can result in double deletes in the worst case, so let's only use the Wayland functionality. Adjusted: * RegionInterface * SurfaceInterface * ShellSurfaceInterface (doesn't take a parent anymore) * DpmsInterface * QtSurfaceExtensionInterface * KeyboardInterface * PointerInterface * TouchInterface * DataOfferInterface * PlasmaShellSurfaceInterface For each adjusted case a test case is added to verify that the cleanup works. Exceptions are DpmsInterface as the actual Resource is not exposed at all in the Server component and DataOfferInterface as that is server side created. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma Differential Revision: https://phabricator.kde.org/D1640
2016-05-19 13:17:07 +00:00
void testDisconnect();
[src/server] Verify that surface has a resource before sending pointer enter Summary: If we try to send a pointer enter on a null resource of a Surface (e.g. after unbound) we hit a marshalling error: error marshalling arguments for enter (signature uoff): null value passed for arg 1 The added test case hits this error without the change and passes cleanly with the change. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2159
2016-07-14 09:45:38 +00:00
void testPointerEnterOnUnboundSurface();
Pass a dedicated fd to each keyboard for the xkb keymap Summary: To better isolate the clients from each other eachh KeyboardInterface creates it's own dedicated temporary file and sends the fd for this temporary file to the client. This means the memory for the keymap is no longer shared between all clients, every client has an own copy. To support this the existing API to set the keymap is deprecated and replaced by a new method setKeymapData which takes the content of the keymap as a byte array. The now deprecated method which takes a file descriptor is changed to use the new setKeymapData method. For that it reads the content of the file. The implementation in KeyboardInterface to create the file descriptor is based on the implementation of KWin. As I implemented the change in KWin (see 3b4c508ee36ac74c37e77fcaa14d106397ad2994) it is not a problem from GPL vs LGPL perspective. The change includes test cases to verify that the content of the keymap is properly passed to the client and that the memory is no longer shared. BUG: 381674 Reviewers: #kwin, #frameworks, davidedmundson, zzag Reviewed By: #kwin, zzag Subscribers: plasma-devel, kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14910
2020-03-19 13:58:52 +00:00
void testKeymap();
void testKeymapThroughFd();
[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
private:
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
KWayland::Server::Display *m_display;
KWayland::Server::CompositorInterface *m_compositorInterface;
KWayland::Server::SeatInterface *m_seatInterface;
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
KWayland::Server::SubCompositorInterface *m_subCompositorInterface;
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
KWayland::Server::RelativePointerManagerInterface *m_relativePointerManagerInterface;
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
KWayland::Server::PointerGesturesInterface *m_pointerGesturesInterface;
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
KWayland::Client::ConnectionThread *m_connection;
KWayland::Client::Compositor *m_compositor;
KWayland::Client::Seat *m_seat;
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
KWayland::Client::ShmPool *m_shm;
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
KWayland::Client::SubCompositor * m_subCompositor;
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
KWayland::Client::RelativePointerManager *m_relativePointerManager;
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
KWayland::Client::PointerGestures *m_pointerGestures;
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
KWayland::Client::EventQueue *m_queue;
[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
QThread *m_thread;
};
static const QString s_socketName = QStringLiteral("kwin-test-wayland-seat-0");
TestWaylandSeat::TestWaylandSeat(QObject *parent)
: QObject(parent)
, m_display(nullptr)
, m_compositorInterface(nullptr)
, m_seatInterface(nullptr)
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
, m_subCompositorInterface(nullptr)
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
, m_relativePointerManagerInterface(nullptr)
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
, m_pointerGesturesInterface(nullptr)
[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
, m_connection(nullptr)
, m_compositor(nullptr)
, m_seat(nullptr)
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
, m_shm(nullptr)
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
, m_subCompositor(nullptr)
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
, m_relativePointerManager(nullptr)
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
, m_pointerGestures(nullptr)
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
, m_queue(nullptr)
[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
, m_thread(nullptr)
{
}
void TestWaylandSeat::init()
{
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
using namespace KWayland::Server;
[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
delete m_display;
m_display = new Display(this);
m_display->setSocketName(s_socketName);
m_display->start();
QVERIFY(m_display->isRunning());
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
m_display->createShm();
[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
m_compositorInterface = m_display->createCompositor(m_display);
QVERIFY(m_compositorInterface);
m_compositorInterface->create();
QVERIFY(m_compositorInterface->isValid());
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
m_subCompositorInterface = m_display->createSubCompositor(m_display);
QVERIFY(m_subCompositorInterface);
m_subCompositorInterface->create();
QVERIFY(m_subCompositorInterface->isValid());
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
m_relativePointerManagerInterface = m_display->createRelativePointerManager(RelativePointerInterfaceVersion::UnstableV1, m_display);
QVERIFY(m_relativePointerManagerInterface);
m_relativePointerManagerInterface->create();
QVERIFY(m_relativePointerManagerInterface->isValid());
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
m_pointerGesturesInterface = m_display->createPointerGestures(PointerGesturesInterfaceVersion::UnstableV1, m_display);
QVERIFY(m_pointerGesturesInterface);
m_pointerGesturesInterface->create();
QVERIFY(m_pointerGesturesInterface->isValid());
[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
// setup connection
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
m_connection = new KWayland::Client::ConnectionThread;
[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
QSignalSpy connectedSpy(m_connection, SIGNAL(connected()));
m_connection->setSocketName(s_socketName);
m_thread = new QThread(this);
m_connection->moveToThread(m_thread);
m_thread->start();
m_connection->initConnection();
QVERIFY(connectedSpy.wait());
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
m_queue = new KWayland::Client::EventQueue(this);
m_queue->setup(m_connection);
[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
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
KWayland::Client::Registry registry;
[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
QSignalSpy compositorSpy(&registry, SIGNAL(compositorAnnounced(quint32,quint32)));
QSignalSpy seatSpy(&registry, SIGNAL(seatAnnounced(quint32,quint32)));
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
QSignalSpy shmSpy(&registry, SIGNAL(shmAnnounced(quint32,quint32)));
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
registry.setEventQueue(m_queue);
[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
registry.create(m_connection->display());
QVERIFY(registry.isValid());
registry.setup();
QVERIFY(compositorSpy.wait());
m_seatInterface = m_display->createSeat();
QVERIFY(m_seatInterface);
m_seatInterface->setName(QStringLiteral("seat0"));
m_seatInterface->create();
QVERIFY(m_seatInterface->isValid());
QVERIFY(seatSpy.wait());
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
m_compositor = new KWayland::Client::Compositor(this);
[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
m_compositor->setup(registry.bindCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>()));
QVERIFY(m_compositor->isValid());
Add convenient create methods to Registry These methods allow to create the Interface objects and set them up directly.
2014-09-19 08:42:44 +00:00
m_seat = registry.createSeat(seatSpy.first().first().value<quint32>(), seatSpy.first().last().value<quint32>(), this);
[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
QSignalSpy nameSpy(m_seat, SIGNAL(nameChanged(QString)));
QVERIFY(nameSpy.wait());
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
m_shm = new KWayland::Client::ShmPool(this);
m_shm->setup(registry.bindShm(shmSpy.first().first().value<quint32>(), shmSpy.first().last().value<quint32>()));
QVERIFY(m_shm->isValid());
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
m_subCompositor = registry.createSubCompositor(registry.interface(KWayland::Client::Registry::Interface::SubCompositor).name,
registry.interface(KWayland::Client::Registry::Interface::SubCompositor).version,
this);
QVERIFY(m_subCompositor->isValid());
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
m_relativePointerManager = registry.createRelativePointerManager(registry.interface(KWayland::Client::Registry::Interface::RelativePointerManagerUnstableV1).name,
registry.interface(KWayland::Client::Registry::Interface::RelativePointerManagerUnstableV1).version,
this);
QVERIFY(m_relativePointerManager->isValid());
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
m_pointerGestures = registry.createPointerGestures(registry.interface(KWayland::Client::Registry::Interface::PointerGesturesUnstableV1).name,
registry.interface(KWayland::Client::Registry::Interface::PointerGesturesUnstableV1).version,
this);
QVERIFY(m_pointerGestures->isValid());
[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 TestWaylandSeat::cleanup()
{
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
if (m_pointerGestures) {
delete m_pointerGestures;
m_pointerGestures = nullptr;
}
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
if (m_relativePointerManager) {
delete m_relativePointerManager;
m_relativePointerManager = nullptr;
}
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
if (m_subCompositor) {
delete m_subCompositor;
m_subCompositor = nullptr;
}
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
if (m_shm) {
delete m_shm;
m_shm = nullptr;
}
[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
if (m_seat) {
delete m_seat;
m_seat = nullptr;
}
if (m_compositor) {
delete m_compositor;
m_compositor = nullptr;
}
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
if (m_queue) {
delete m_queue;
m_queue = nullptr;
}
if (m_connection) {
m_connection->deleteLater();
m_connection = nullptr;
}
[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
if (m_thread) {
m_thread->quit();
m_thread->wait();
delete m_thread;
m_thread = nullptr;
}
delete m_compositorInterface;
m_compositorInterface = nullptr;
delete m_seatInterface;
m_seatInterface = nullptr;
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
delete m_subCompositorInterface;
m_subCompositorInterface = nullptr;
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
delete m_relativePointerManagerInterface;
m_relativePointerManagerInterface = nullptr;
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
delete m_pointerGesturesInterface;
m_pointerGesturesInterface = nullptr;
[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
delete m_display;
m_display = nullptr;
}
void TestWaylandSeat::testName()
{
// no name set yet
QCOMPARE(m_seat->name(), QStringLiteral("seat0"));
QSignalSpy spy(m_seat, SIGNAL(nameChanged(QString)));
QVERIFY(spy.isValid());
const QString name = QStringLiteral("foobar");
m_seatInterface->setName(name);
QVERIFY(spy.wait());
QCOMPARE(m_seat->name(), name);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.first().first().toString(), name);
}
void TestWaylandSeat::testCapabilities_data()
{
QTest::addColumn<bool>("pointer");
QTest::addColumn<bool>("keyboard");
QTest::addColumn<bool>("touch");
QTest::newRow("none") << false << false << false;
QTest::newRow("pointer") << true << false << false;
QTest::newRow("keyboard") << false << true << false;
QTest::newRow("touch") << false << false << true;
QTest::newRow("pointer/keyboard") << true << true << false;
QTest::newRow("pointer/touch") << true << false << true;
QTest::newRow("keyboard/touch") << false << true << true;
QTest::newRow("all") << true << true << true;
}
void TestWaylandSeat::testCapabilities()
{
QVERIFY(!m_seat->hasPointer());
QVERIFY(!m_seat->hasKeyboard());
QVERIFY(!m_seat->hasTouch());
QFETCH(bool, pointer);
QFETCH(bool, keyboard);
QFETCH(bool, touch);
QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
QSignalSpy keyboardSpy(m_seat, SIGNAL(hasKeyboardChanged(bool)));
QVERIFY(keyboardSpy.isValid());
QSignalSpy touchSpy(m_seat, SIGNAL(hasTouchChanged(bool)));
QVERIFY(touchSpy.isValid());
m_seatInterface->setHasPointer(pointer);
m_seatInterface->setHasKeyboard(keyboard);
m_seatInterface->setHasTouch(touch);
// do processing
QCOMPARE(pointerSpy.wait(1000), pointer);
QCOMPARE(pointerSpy.isEmpty(), !pointer);
if (!pointerSpy.isEmpty()) {
QCOMPARE(pointerSpy.first().first().toBool(), pointer);
}
if (keyboardSpy.isEmpty()) {
QCOMPARE(keyboardSpy.wait(1000), keyboard);
}
QCOMPARE(keyboardSpy.isEmpty(), !keyboard);
if (!keyboardSpy.isEmpty()) {
QCOMPARE(keyboardSpy.first().first().toBool(), keyboard);
}
if (touchSpy.isEmpty()) {
QCOMPARE(touchSpy.wait(1000), touch);
}
QCOMPARE(touchSpy.isEmpty(), !touch);
if (!touchSpy.isEmpty()) {
QCOMPARE(touchSpy.first().first().toBool(), touch);
}
QCOMPARE(m_seat->hasPointer(), pointer);
QCOMPARE(m_seat->hasKeyboard(), keyboard);
QCOMPARE(m_seat->hasTouch(), touch);
}
void TestWaylandSeat::testPointer()
{
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
using namespace KWayland::Client;
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
using namespace KWayland::Server;
[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
QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
[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(surfaceCreatedSpy.isValid());
Surface *s = m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
[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(serverSurface);
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QSignalSpy focusedPointerChangedSpy(m_seatInterface, &SeatInterface::focusedPointerChanged);
QVERIFY(focusedPointerChangedSpy.isValid());
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
m_seatInterface->setPointerPos(QPoint(20, 18));
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(10, 15));
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 1);
QVERIFY(!focusedPointerChangedSpy.first().first().value<PointerInterface*>());
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
// no pointer yet
QVERIFY(m_seatInterface->focusedPointerSurface());
QVERIFY(!m_seatInterface->focusedPointer());
[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
Pointer *p = m_seat->createPointer(m_seat);
[server] Add support for the frame semantics of Pointer version 5 Summary: This change implements the required changes for wl_seat version 5. There seem to be applications which require version 5 and refuse to start if the server doesn't provide it. Thus we need to provide it. The main difference with version 5 is that pointer need to send a frame event after each logical group of events. As we don't support the new events from version 5 yet, we just emit the frame after each event and implement the suggested semantics for the enter/leave behavior. To really make use of this, we will have to implement additions in the API and then in KWin to expose the new API elements. But to just support the semantics we don't need it. BUG: 389189 FIXED-IN: 5.45 Test Plan: Extended autotest Reviewers: #kwin, #plasma, #frameworks Subscribers: plasma-devel Tags: #frameworks, #plasma Differential Revision: https://phabricator.kde.org/D10235
2018-02-01 16:46:53 +00:00
QSignalSpy frameSpy(p, &Pointer::frame);
QVERIFY(frameSpy.isValid());
[autotests] Verify Client::Pointer::enteredSurface
2014-12-03 07:41:00 +00:00
const Pointer &cp = *p;
Verify that Pointer isValid in the autotest
2014-09-22 09:02:16 +00:00
QVERIFY(p->isValid());
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
QScopedPointer<RelativePointer> relativePointer(m_relativePointerManager->createRelativePointer(p));
QVERIFY(relativePointer->isValid());
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
QSignalSpy pointerCreatedSpy(m_seatInterface, SIGNAL(pointerCreated(KWayland::Server::PointerInterface*)));
QVERIFY(pointerCreatedSpy.isValid());
// once the pointer is created it should be set as the focused pointer
QVERIFY(pointerCreatedSpy.wait());
QVERIFY(m_seatInterface->focusedPointer());
QCOMPARE(pointerCreatedSpy.first().first().value<PointerInterface*>(), m_seatInterface->focusedPointer());
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 2);
QCOMPARE(focusedPointerChangedSpy.last().first().value<PointerInterface*>(), m_seatInterface->focusedPointer());
[server] Add support for the frame semantics of Pointer version 5 Summary: This change implements the required changes for wl_seat version 5. There seem to be applications which require version 5 and refuse to start if the server doesn't provide it. Thus we need to provide it. The main difference with version 5 is that pointer need to send a frame event after each logical group of events. As we don't support the new events from version 5 yet, we just emit the frame after each event and implement the suggested semantics for the enter/leave behavior. To really make use of this, we will have to implement additions in the API and then in KWin to expose the new API elements. But to just support the semantics we don't need it. BUG: 389189 FIXED-IN: 5.45 Test Plan: Extended autotest Reviewers: #kwin, #plasma, #frameworks Subscribers: plasma-devel Tags: #frameworks, #plasma Differential Revision: https://phabricator.kde.org/D10235
2018-02-01 16:46:53 +00:00
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 1);
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
m_seatInterface->setFocusedPointerSurface(nullptr);
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 3);
QVERIFY(!focusedPointerChangedSpy.last().first().value<PointerInterface*>());
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
serverSurface->client()->flush();
[server] Add support for the frame semantics of Pointer version 5 Summary: This change implements the required changes for wl_seat version 5. There seem to be applications which require version 5 and refuse to start if the server doesn't provide it. Thus we need to provide it. The main difference with version 5 is that pointer need to send a frame event after each logical group of events. As we don't support the new events from version 5 yet, we just emit the frame after each event and implement the suggested semantics for the enter/leave behavior. To really make use of this, we will have to implement additions in the API and then in KWin to expose the new API elements. But to just support the semantics we don't need it. BUG: 389189 FIXED-IN: 5.45 Test Plan: Extended autotest Reviewers: #kwin, #plasma, #frameworks Subscribers: plasma-devel Tags: #frameworks, #plasma Differential Revision: https://phabricator.kde.org/D10235
2018-02-01 16:46:53 +00:00
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 2);
[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
QSignalSpy enteredSpy(p, SIGNAL(entered(quint32,QPointF)));
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(p, SIGNAL(left(quint32)));
QVERIFY(leftSpy.isValid());
QSignalSpy motionSpy(p, SIGNAL(motion(QPointF,quint32)));
QVERIFY(motionSpy.isValid());
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QSignalSpy axisSpy(p, SIGNAL(axisChanged(quint32,KWayland::Client::Pointer::Axis,qreal)));
[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(axisSpy.isValid());
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QSignalSpy buttonSpy(p, SIGNAL(buttonStateChanged(quint32,quint32,quint32,KWayland::Client::Pointer::ButtonState)));
[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(buttonSpy.isValid());
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
QSignalSpy relativeMotionSpy(relativePointer.data(), &RelativePointer::relativeMotion);
QVERIFY(relativeMotionSpy.isValid());
[autotests] Verify Client::Pointer::enteredSurface
2014-12-03 07:41:00 +00:00
QVERIFY(!p->enteredSurface());
QVERIFY(!cp.enteredSurface());
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(10, 15));
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
[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(enteredSpy.wait());
QCOMPARE(enteredSpy.first().first().value<quint32>(), m_display->serial());
QCOMPARE(enteredSpy.first().last().toPoint(), QPoint(10, 3));
[server] Add support for the frame semantics of Pointer version 5 Summary: This change implements the required changes for wl_seat version 5. There seem to be applications which require version 5 and refuse to start if the server doesn't provide it. Thus we need to provide it. The main difference with version 5 is that pointer need to send a frame event after each logical group of events. As we don't support the new events from version 5 yet, we just emit the frame after each event and implement the suggested semantics for the enter/leave behavior. To really make use of this, we will have to implement additions in the API and then in KWin to expose the new API elements. But to just support the semantics we don't need it. BUG: 389189 FIXED-IN: 5.45 Test Plan: Extended autotest Reviewers: #kwin, #plasma, #frameworks Subscribers: plasma-devel Tags: #frameworks, #plasma Differential Revision: https://phabricator.kde.org/D10235
2018-02-01 16:46:53 +00:00
QCOMPARE(frameSpy.count(), 3);
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
PointerInterface *serverPointer = m_seatInterface->focusedPointer();
QVERIFY(serverPointer);
[autotests] Verify Client::Pointer::enteredSurface
2014-12-03 07:41:00 +00:00
QCOMPARE(p->enteredSurface(), s);
QCOMPARE(cp.enteredSurface(), s);
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 4);
QCOMPARE(focusedPointerChangedSpy.last().first().value<PointerInterface*>(), serverPointer);
[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
// test motion
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(1);
Drop global position from PointerInterface No longer needed, not even as a convenience wrapper.
2014-11-26 10:54:53 +00:00
m_seatInterface->setPointerPos(QPoint(10, 16));
[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(motionSpy.wait());
[server] Add support for the frame semantics of Pointer version 5 Summary: This change implements the required changes for wl_seat version 5. There seem to be applications which require version 5 and refuse to start if the server doesn't provide it. Thus we need to provide it. The main difference with version 5 is that pointer need to send a frame event after each logical group of events. As we don't support the new events from version 5 yet, we just emit the frame after each event and implement the suggested semantics for the enter/leave behavior. To really make use of this, we will have to implement additions in the API and then in KWin to expose the new API elements. But to just support the semantics we don't need it. BUG: 389189 FIXED-IN: 5.45 Test Plan: Extended autotest Reviewers: #kwin, #plasma, #frameworks Subscribers: plasma-devel Tags: #frameworks, #plasma Differential Revision: https://phabricator.kde.org/D10235
2018-02-01 16:46:53 +00:00
QCOMPARE(frameSpy.count(), 4);
[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(motionSpy.first().first().toPoint(), QPoint(0, 1));
QCOMPARE(motionSpy.first().last().value<quint32>(), quint32(1));
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
// test relative motion
m_seatInterface->relativePointerMotion(QSizeF(1, 2), QSizeF(3, 4), quint64(-1));
QVERIFY(relativeMotionSpy.wait());
QCOMPARE(relativeMotionSpy.count(), 1);
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 5);
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
QCOMPARE(relativeMotionSpy.first().at(0).toSizeF(), QSizeF(1, 2));
QCOMPARE(relativeMotionSpy.first().at(1).toSizeF(), QSizeF(3, 4));
QCOMPARE(relativeMotionSpy.first().at(2).value<quint64>(), quint64(-1));
[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
// test axis
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(2);
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
m_seatInterface->pointerAxis(Qt::Horizontal, 10);
[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(axisSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 6);
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(3);
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
m_seatInterface->pointerAxis(Qt::Vertical, 20);
[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(axisSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 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
QCOMPARE(axisSpy.first().at(0).value<quint32>(), quint32(2));
QCOMPARE(axisSpy.first().at(1).value<Pointer::Axis>(), Pointer::Axis::Horizontal);
QCOMPARE(axisSpy.first().at(2).value<qreal>(), qreal(10));
QCOMPARE(axisSpy.last().at(0).value<quint32>(), quint32(3));
QCOMPARE(axisSpy.last().at(1).value<Pointer::Axis>(), Pointer::Axis::Vertical);
QCOMPARE(axisSpy.last().at(2).value<qreal>(), qreal(20));
// test button
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(4);
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
m_seatInterface->pointerButtonPressed(1);
[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(buttonSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 8);
[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(buttonSpy.at(0).at(0).value<quint32>(), m_display->serial());
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(5);
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
m_seatInterface->pointerButtonPressed(2);
[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(buttonSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 9);
[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(buttonSpy.at(1).at(0).value<quint32>(), m_display->serial());
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(6);
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
m_seatInterface->pointerButtonReleased(2);
[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(buttonSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 10);
[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(buttonSpy.at(2).at(0).value<quint32>(), m_display->serial());
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(7);
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
m_seatInterface->pointerButtonReleased(1);
[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(buttonSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 11);
[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(buttonSpy.count(), 4);
// timestamp
QCOMPARE(buttonSpy.at(0).at(1).value<quint32>(), quint32(4));
// button
QCOMPARE(buttonSpy.at(0).at(2).value<quint32>(), quint32(1));
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QCOMPARE(buttonSpy.at(0).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Pressed);
[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
// timestamp
QCOMPARE(buttonSpy.at(1).at(1).value<quint32>(), quint32(5));
// button
QCOMPARE(buttonSpy.at(1).at(2).value<quint32>(), quint32(2));
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QCOMPARE(buttonSpy.at(1).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Pressed);
[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
QCOMPARE(buttonSpy.at(2).at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(2));
[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
// timestamp
QCOMPARE(buttonSpy.at(2).at(1).value<quint32>(), quint32(6));
// button
QCOMPARE(buttonSpy.at(2).at(2).value<quint32>(), quint32(2));
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QCOMPARE(buttonSpy.at(2).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Released);
[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
QCOMPARE(buttonSpy.at(3).at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(1));
[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
// timestamp
QCOMPARE(buttonSpy.at(3).at(1).value<quint32>(), quint32(7));
// button
QCOMPARE(buttonSpy.at(3).at(2).value<quint32>(), quint32(1));
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QCOMPARE(buttonSpy.at(3).at(3).value<KWayland::Client::Pointer::ButtonState>(), KWayland::Client::Pointer::ButtonState::Released);
[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
// leave the surface
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
m_seatInterface->setFocusedPointerSurface(nullptr);
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 5);
[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(leftSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 12);
[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(leftSpy.first().first().value<quint32>(), m_display->serial());
[autotests] Verify Client::Pointer::enteredSurface
2014-12-03 07:41:00 +00:00
QVERIFY(!p->enteredSurface());
QVERIFY(!cp.enteredSurface());
[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 support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
// now a relative motion should not be sent to the relative pointer
m_seatInterface->relativePointerMotion(QSizeF(1, 2), QSizeF(3, 4), quint64(-1));
Reduce unnecessary long wait times on failing signal spies Summary: Several signal spies, which were supposed to fail, were waiting for the default 5 seconds, which is most often unnecessary long. This patch sets a time limit of 500ms in suitable cases. Reduces for me the total test time by 40%. Test Plan: Before (with fixed seat and selection tests): 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 173.31 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) After: 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 102.12 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14184
2018-07-17 09:30:16 +00:00
QVERIFY(!relativeMotionSpy.wait(500));
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
[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
// enter it again
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(0, 0));
[server] Add a signal SeatInterface::focusedPointerChanged Summary: The signal gets emitted whenever the focused PointerInterfaces gets newly set or reset to nullptr. This is needed to better track the current cursor image in the compositor. Reviewers: #plasma, sebas Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1007
2016-02-22 13:55:19 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 6);
[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(enteredSpy.wait());
Fix selection and seat auto tests Summary: The seat test is broken since 312298e2f6bc, because a frame event now also follows a relative pointer motion. The selection test is broken since d3f15a5388da, because clearing a selection, which never has been set, is a noop now. Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14183
2018-07-17 10:38:57 +00:00
QCOMPARE(frameSpy.count(), 13);
[autotests] Verify Client::Pointer::enteredSurface
2014-12-03 07:41:00 +00:00
QCOMPARE(p->enteredSurface(), s);
QCOMPARE(cp.enteredSurface(), s);
[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 support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
// send another relative motion event
m_seatInterface->relativePointerMotion(QSizeF(4, 5), QSizeF(6, 7), quint64(1));
QVERIFY(relativeMotionSpy.wait());
QCOMPARE(relativeMotionSpy.count(), 2);
QCOMPARE(relativeMotionSpy.last().at(0).toSizeF(), QSizeF(4, 5));
QCOMPARE(relativeMotionSpy.last().at(1).toSizeF(), QSizeF(6, 7));
QCOMPARE(relativeMotionSpy.last().at(2).value<quint64>(), quint64(1));
Properly handle destroying a Pointer resource Summary: On client side the newer wl_pointer_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the PointerInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound PointerInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2037
2016-06-28 16:57:08 +00:00
// destroy the focused pointer
QSignalSpy unboundSpy(serverPointer, &Resource::unbound);
QVERIFY(unboundSpy.isValid());
QSignalSpy destroyedSpy(serverPointer, &Resource::destroyed);
QVERIFY(destroyedSpy.isValid());
delete p;
QVERIFY(unboundSpy.wait());
QCOMPARE(unboundSpy.count(), 1);
QCOMPARE(destroyedSpy.count(), 0);
// now test that calling into the methods in Seat does not crash
QCOMPARE(m_seatInterface->focusedPointer(), serverPointer);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
m_seatInterface->setTimestamp(8);
m_seatInterface->setPointerPos(QPoint(10, 15));
m_seatInterface->setTimestamp(9);
m_seatInterface->pointerButtonPressed(1);
m_seatInterface->setTimestamp(10);
m_seatInterface->pointerButtonReleased(1);
m_seatInterface->setTimestamp(11);
m_seatInterface->pointerAxis(Qt::Horizontal, 10);
m_seatInterface->setTimestamp(12);
m_seatInterface->pointerAxis(Qt::Vertical, 20);
m_seatInterface->setFocusedPointerSurface(nullptr);
QCOMPARE(focusedPointerChangedSpy.count(), 7);
m_seatInterface->setFocusedPointerSurface(serverSurface);
QCOMPARE(focusedPointerChangedSpy.count(), 8);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedPointer());
// and now destroy
QVERIFY(destroyedSpy.wait());
QCOMPARE(unboundSpy.count(), 1);
QCOMPARE(destroyedSpy.count(), 1);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedPointer());
// create a pointer again
p = m_seat->createPointer(m_seat);
QVERIFY(focusedPointerChangedSpy.wait());
QCOMPARE(focusedPointerChangedSpy.count(), 9);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
serverPointer = m_seatInterface->focusedPointer();
QVERIFY(serverPointer);
[client] Use a QPointer for the enteredSurface in Pointer If the client deletes the currently entered Surface the Pointer should return null in Pointer::enteredSurface and not invalid memory. At the same time a now incorrect assert is removed. After the client deletes the Surface it might still get a left event for the Surface. In that case a comparison between the enteredSurface and the Surface from the leave event would fail. Reviewed-By: bshah
2016-08-04 08:02:38 +00:00
QSignalSpy entered2Spy(p, &Pointer::entered);
QVERIFY(entered2Spy.wait());
QCOMPARE(p->enteredSurface(), s);
[server] Send pointer leave if focused surface gets unbound Summary: As 9266a944007e1bc91282961f271a5f9d18043d1f just for pointer. Reviewers: #plasma, #frameworks Subscribers: plasma-devel Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D6754
2017-07-17 15:00:57 +00:00
QSignalSpy leftSpy2(p, &Pointer::left);
QVERIFY(leftSpy2.isValid());
[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
delete s;
[client] Use a QPointer for the enteredSurface in Pointer If the client deletes the currently entered Surface the Pointer should return null in Pointer::enteredSurface and not invalid memory. At the same time a now incorrect assert is removed. After the client deletes the Surface it might still get a left event for the Surface. In that case a comparison between the enteredSurface and the Surface from the leave event would fail. Reviewed-By: bshah
2016-08-04 08:02:38 +00:00
QVERIFY(!p->enteredSurface());
[server] Send pointer leave if focused surface gets unbound Summary: As 9266a944007e1bc91282961f271a5f9d18043d1f just for pointer. Reviewers: #plasma, #frameworks Subscribers: plasma-devel Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D6754
2017-07-17 15:00:57 +00:00
QVERIFY(leftSpy2.wait());
Properly handle destroying a Pointer resource Summary: On client side the newer wl_pointer_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the PointerInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound PointerInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2037
2016-06-28 16:57:08 +00:00
QCOMPARE(focusedPointerChangedSpy.count(), 10);
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
QVERIFY(!m_seatInterface->focusedPointerSurface());
Properly handle destroying a Pointer resource Summary: On client side the newer wl_pointer_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the PointerInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound PointerInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2037
2016-06-28 16:57:08 +00:00
QVERIFY(!m_seatInterface->focusedPointer());
[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] Add support for pointer input transformation So far we only supported mapping global to surface-local coordinates using a 2D-offset. With this change it's possible to register a QMatrix4x4 to describe the transformation for going from global to surface-local coordinates in a full 3D space. The existing 2D-offset is transformed to use the new matrix based variant describing a translation. REVIEW: 126271
2015-12-07 10:45:34 +00:00
void TestWaylandSeat::testPointerTransformation_data()
{
QTest::addColumn<QMatrix4x4>("enterTransformation");
// global position at 20/18
QTest::addColumn<QPointF>("expectedEnterPoint");
// global position at 10/16
QTest::addColumn<QPointF>("expectedMovePoint");
QMatrix4x4 tm;
tm.translate(-10, -15);
QTest::newRow("translation") << tm << QPointF(10, 3) << QPointF(0, 1);
QMatrix4x4 sm;
sm.scale(2, 2);
QTest::newRow("scale") << sm << QPointF(40, 36) << QPointF(20, 32);
QMatrix4x4 rotate;
rotate.rotate(90, 0, 0, 1);
QTest::newRow("rotate") << rotate << QPointF(-18, 20) << QPointF(-16, 10);
}
void TestWaylandSeat::testPointerTransformation()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy pointerSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
Surface *s = m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setPointerPos(QPoint(20, 18));
QFETCH(QMatrix4x4, enterTransformation);
m_seatInterface->setFocusedPointerSurface(serverSurface, enterTransformation);
QCOMPARE(m_seatInterface->focusedPointerSurfaceTransformation(), enterTransformation);
// no pointer yet
QVERIFY(m_seatInterface->focusedPointerSurface());
QVERIFY(!m_seatInterface->focusedPointer());
Pointer *p = m_seat->createPointer(m_seat);
const Pointer &cp = *p;
QVERIFY(p->isValid());
QSignalSpy pointerCreatedSpy(m_seatInterface, &SeatInterface::pointerCreated);
QVERIFY(pointerCreatedSpy.isValid());
// once the pointer is created it should be set as the focused pointer
QVERIFY(pointerCreatedSpy.wait());
QVERIFY(m_seatInterface->focusedPointer());
QCOMPARE(pointerCreatedSpy.first().first().value<PointerInterface*>(), m_seatInterface->focusedPointer());
m_seatInterface->setFocusedPointerSurface(nullptr);
serverSurface->client()->flush();
QTest::qWait(100);
QSignalSpy enteredSpy(p, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(p, &Pointer::left);
QVERIFY(leftSpy.isValid());
QSignalSpy motionSpy(p, &Pointer::motion);
QVERIFY(motionSpy.isValid());
QVERIFY(!p->enteredSurface());
QVERIFY(!cp.enteredSurface());
m_seatInterface->setFocusedPointerSurface(serverSurface, enterTransformation);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.first().first().value<quint32>(), m_display->serial());
QTEST(enteredSpy.first().last().toPointF(), "expectedEnterPoint");
PointerInterface *serverPointer = m_seatInterface->focusedPointer();
QVERIFY(serverPointer);
QCOMPARE(p->enteredSurface(), s);
QCOMPARE(cp.enteredSurface(), s);
// test motion
m_seatInterface->setTimestamp(1);
m_seatInterface->setPointerPos(QPoint(10, 16));
QVERIFY(motionSpy.wait());
QTEST(motionSpy.first().first().toPointF(), "expectedMovePoint");
QCOMPARE(motionSpy.first().last().value<quint32>(), quint32(1));
// leave the surface
m_seatInterface->setFocusedPointerSurface(nullptr);
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.first().first().value<quint32>(), m_display->serial());
QVERIFY(!p->enteredSurface());
QVERIFY(!cp.enteredSurface());
// enter it again
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(enteredSpy.wait());
QCOMPARE(p->enteredSurface(), s);
QCOMPARE(cp.enteredSurface(), s);
delete s;
wl_display_flush(m_connection->display());
QTest::qWait(100);
QVERIFY(!m_seatInterface->focusedPointerSurface());
}
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
Q_DECLARE_METATYPE(Qt::MouseButton)
void TestWaylandSeat::testPointerButton_data()
{
QTest::addColumn<Qt::MouseButton>("qtButton");
QTest::addColumn<quint32>("waylandButton");
QTest::newRow("left") << Qt::LeftButton << quint32(BTN_LEFT);
QTest::newRow("right") << Qt::RightButton << quint32(BTN_RIGHT);
QTest::newRow("mid") << Qt::MidButton << quint32(BTN_MIDDLE);
QTest::newRow("middle") << Qt::MiddleButton << quint32(BTN_MIDDLE);
QTest::newRow("back") << Qt::BackButton << quint32(BTN_BACK);
QTest::newRow("x1") << Qt::XButton1 << quint32(BTN_BACK);
QTest::newRow("extra1") << Qt::ExtraButton1 << quint32(BTN_BACK);
QTest::newRow("forward") << Qt::ForwardButton << quint32(BTN_FORWARD);
QTest::newRow("x2") << Qt::XButton2 << quint32(BTN_FORWARD);
QTest::newRow("extra2") << Qt::ExtraButton2 << quint32(BTN_FORWARD);
QTest::newRow("task") << Qt::TaskButton << quint32(BTN_TASK);
QTest::newRow("extra3") << Qt::ExtraButton3 << quint32(BTN_TASK);
QTest::newRow("extra4") << Qt::ExtraButton4 << quint32(BTN_EXTRA);
QTest::newRow("extra5") << Qt::ExtraButton5 << quint32(BTN_SIDE);
QTest::newRow("extra6") << Qt::ExtraButton6 << quint32(0x118);
QTest::newRow("extra7") << Qt::ExtraButton7 << quint32(0x119);
QTest::newRow("extra8") << Qt::ExtraButton8 << quint32(0x11a);
QTest::newRow("extra9") << Qt::ExtraButton9 << quint32(0x11b);
QTest::newRow("extra10") << Qt::ExtraButton10 << quint32(0x11c);
QTest::newRow("extra11") << Qt::ExtraButton11 << quint32(0x11d);
QTest::newRow("extra12") << Qt::ExtraButton12 << quint32(0x11e);
QTest::newRow("extra13") << Qt::ExtraButton13 << quint32(0x11f);
}
void TestWaylandSeat::testPointerButton()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
QVERIFY(surfaceCreatedSpy.isValid());
m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
QScopedPointer<Pointer> p(m_seat->createPointer());
QVERIFY(p->isValid());
Normalize SIGNAL syntax makes Krazy happy.
2014-12-12 07:33:10 +00:00
QSignalSpy buttonChangedSpy(p.data(), SIGNAL(buttonStateChanged(quint32,quint32,quint32,KWayland::Client::Pointer::ButtonState)));
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QVERIFY(buttonChangedSpy.isValid());
wl_display_flush(m_connection->display());
QCoreApplication::processEvents();
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
m_seatInterface->setPointerPos(QPoint(20, 18));
Move focused pointer surface API to SeatInterface There can only be one focused surface per Seat, thus the information should be hold in the seat. This only adjusts the API, the actual data is still hold in the PointerInterface. This still needs adjustment.
2014-11-25 14:54:28 +00:00
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(10, 15));
QVERIFY(m_seatInterface->focusedPointerSurface());
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(m_seatInterface->focusedPointer());
QCoreApplication::processEvents();
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
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
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(10, 15));
PointerInterface *serverPointer = m_seatInterface->focusedPointer();
QVERIFY(serverPointer);
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QFETCH(Qt::MouseButton, qtButton);
QFETCH(quint32, waylandButton);
quint32 msec = QDateTime::currentMSecsSinceEpoch();
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
QCOMPARE(m_seatInterface->isPointerButtonPressed(waylandButton), false);
QCOMPARE(m_seatInterface->isPointerButtonPressed(qtButton), false);
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(msec);
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
m_seatInterface->pointerButtonPressed(qtButton);
QCOMPARE(m_seatInterface->isPointerButtonPressed(waylandButton), true);
QCOMPARE(m_seatInterface->isPointerButtonPressed(qtButton), true);
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QVERIFY(buttonChangedSpy.wait());
QCOMPARE(buttonChangedSpy.count(), 1);
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
QCOMPARE(buttonChangedSpy.last().at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(waylandButton));
QCOMPARE(buttonChangedSpy.last().at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(qtButton));
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QCOMPARE(buttonChangedSpy.last().at(1).value<quint32>(), msec);
QCOMPARE(buttonChangedSpy.last().at(2).value<quint32>(), waylandButton);
QCOMPARE(buttonChangedSpy.last().at(3).value<KWayland::Client::Pointer::ButtonState>(), Pointer::ButtonState::Pressed);
msec = QDateTime::currentMSecsSinceEpoch();
[server] Keep timestamp in SeatInterface instead of PointerInterface
2014-11-25 14:29:01 +00:00
m_seatInterface->setTimestamp(QDateTime::currentMSecsSinceEpoch());
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
m_seatInterface->pointerButtonReleased(qtButton);
QCOMPARE(m_seatInterface->isPointerButtonPressed(waylandButton), false);
QCOMPARE(m_seatInterface->isPointerButtonPressed(qtButton), false);
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QVERIFY(buttonChangedSpy.wait());
QCOMPARE(buttonChangedSpy.count(), 2);
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
QCOMPARE(buttonChangedSpy.last().at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(waylandButton));
QCOMPARE(buttonChangedSpy.last().at(0).value<quint32>(), m_seatInterface->pointerButtonSerial(qtButton));
Overloads taking Qt::MouseButton added to Server::SeatInterface Qt::MouseButton is mapped to the linux buttons. The mapping does not match the mapping used in QtWayland module [1] as that seems to be incorrect to me. E.g. Qt::BackButton is not mapped to BTN_BACK. [1] qtwayland/src/client/qwaylandinputdevice.cpp
2014-11-10 13:51:09 +00:00
QCOMPARE(buttonChangedSpy.last().at(1).value<quint32>(), msec);
QCOMPARE(buttonChangedSpy.last().at(2).value<quint32>(), waylandButton);
QCOMPARE(buttonChangedSpy.last().at(3).value<KWayland::Client::Pointer::ButtonState>(), Pointer::ButtonState::Released);
}
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
void TestWaylandSeat::testPointerSubSurfaceTree()
{
// this test verifies that pointer motion on a surface with sub-surfaces sends motion enter/leave to the sub-surface
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the pointer
QSignalSpy hasPointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(hasPointerChangedSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(hasPointerChangedSpy.wait());
QScopedPointer<Pointer> pointer(m_seat->createPointer());
// create a sub surface tree
// parent surface (100, 100) with one sub surface taking the half of it's size (50, 100)
// which has two further children (50, 50) which are overlapping
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> parentSurface(m_compositor->createSurface());
QScopedPointer<Surface> childSurface(m_compositor->createSurface());
QScopedPointer<Surface> grandChild1Surface(m_compositor->createSurface());
QScopedPointer<Surface> grandChild2Surface(m_compositor->createSurface());
QScopedPointer<SubSurface> childSubSurface(m_subCompositor->createSubSurface(childSurface.data(), parentSurface.data()));
QScopedPointer<SubSurface> grandChild1SubSurface(m_subCompositor->createSubSurface(grandChild1Surface.data(), childSurface.data()));
QScopedPointer<SubSurface> grandChild2SubSurface(m_subCompositor->createSubSurface(grandChild2Surface.data(), childSurface.data()));
grandChild2SubSurface->setPosition(QPoint(0, 25));
// let's map the surfaces
auto render = [this] (Surface *s, const QSize &size) {
Treat input RGB buffers as premultiplied Summary: Currently the server treats incoming buffers as not premultiplied. KWayland::Client sends data that is ARGB32 and ARGB32_Premultiplied as the same WL_SHM_FORMAT_ARGB8888. According to a post on wayland-devel by Fredrik Höglund, all RGB data should be treated as premultiplied, which matches what Qt is doing. Client now performs a conversion rather than sending mismatched data, Note: This commit will still breaks a bunch of tests in kwin as it compares the server output to a fixed QImage with a format. Test Plan: Existing tests pass Modified surface test to check the pixel data relative to the output QImage format not the input format (i.e both input from ARGB32 and ARGB32_Premultiplied) should both end up in a QImage with format Premultiplied with premultiplied values. The existing test was confirming that data was corrupted, checking that even though the output format was not pre-multiplied, the data was. Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7460
2017-08-30 08:57:41 +00:00
QImage image(size, QImage::Format_ARGB32_Premultiplied);
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
image.fill(Qt::black);
s->attachBuffer(m_shm->createBuffer(image));
s->damage(QRect(QPoint(0, 0), size));
s->commit(Surface::CommitFlag::None);
};
render(grandChild2Surface.data(), QSize(50, 50));
render(grandChild1Surface.data(), QSize(50, 50));
render(childSurface.data(), QSize(50, 100));
render(parentSurface.data(), QSize(100, 100));
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(serverSurface->isMapped());
// send in pointer events
QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer.data(), &Pointer::left);
QVERIFY(leftSpy.isValid());
QSignalSpy motionSpy(pointer.data(), &Pointer::motion);
QVERIFY(motionSpy.isValid());
// first to the grandChild2 in the overlapped area
quint32 timestamp = 1;
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setPointerPos(QPointF(25, 50));
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
QCOMPARE(leftSpy.count(), 0);
QCOMPARE(motionSpy.count(), 0);
QCOMPARE(enteredSpy.last().last().toPointF(), QPointF(25, 25));
QCOMPARE(pointer->enteredSurface(), grandChild2Surface.data());
// a motion on grandchild2
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setPointerPos(QPointF(25, 60));
QVERIFY(motionSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
QCOMPARE(leftSpy.count(), 0);
QCOMPARE(motionSpy.count(), 1);
QCOMPARE(motionSpy.last().first().toPointF(), QPointF(25, 35));
// motion which changes to childSurface
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setPointerPos(QPointF(25, 80));
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(motionSpy.count(), 1);
QCOMPARE(enteredSpy.last().last().toPointF(), QPointF(25, 80));
QCOMPARE(pointer->enteredSurface(), childSurface.data());
// a leave for the whole surface
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setFocusedPointerSurface(nullptr);
QVERIFY(leftSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(leftSpy.count(), 2);
QCOMPARE(motionSpy.count(), 1);
// a new enter on the main surface
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setPointerPos(QPointF(75, 50));
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 3);
QCOMPARE(leftSpy.count(), 2);
QCOMPARE(motionSpy.count(), 1);
QCOMPARE(enteredSpy.last().last().toPointF(), QPointF(75, 50));
QCOMPARE(pointer->enteredSurface(), parentSurface.data());
}
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
void TestWaylandSeat::testPointerSwipeGesture_data()
{
QTest::addColumn<bool>("cancel");
QTest::addColumn<int>("expectedEndCount");
QTest::addColumn<int>("expectedCancelCount");
QTest::newRow("end") << false << 1 << 0;
QTest::newRow("cancel") << true << 0 << 1;
}
void TestWaylandSeat::testPointerSwipeGesture()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the pointer and pointer swipe gesture
QSignalSpy hasPointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(hasPointerChangedSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(hasPointerChangedSpy.wait());
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QScopedPointer<PointerSwipeGesture> gesture(m_pointerGestures->createSwipeGesture(pointer.data()));
QVERIFY(gesture);
QVERIFY(gesture->isValid());
QVERIFY(gesture->surface().isNull());
QCOMPARE(gesture->fingerCount(), 0u);
QSignalSpy startSpy(gesture.data(), &PointerSwipeGesture::started);
QVERIFY(startSpy.isValid());
QSignalSpy updateSpy(gesture.data(), &PointerSwipeGesture::updated);
QVERIFY(updateSpy.isValid());
QSignalSpy endSpy(gesture.data(), &PointerSwipeGesture::ended);
QVERIFY(endSpy.isValid());
QSignalSpy cancelledSpy(gesture.data(), &PointerSwipeGesture::cancelled);
QVERIFY(cancelledSpy.isValid());
// now create a surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setFocusedPointerSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(m_seatInterface->focusedPointer());
// send in the start
quint32 timestamp = 1;
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->startPointerSwipeGesture(2);
QVERIFY(startSpy.wait());
QCOMPARE(startSpy.count(), 1);
QCOMPARE(startSpy.first().at(0).value<quint32>(), m_display->serial());
QCOMPARE(startSpy.first().at(1).value<quint32>(), 1u);
QCOMPARE(gesture->fingerCount(), 2u);
QCOMPARE(gesture->surface().data(), surface.data());
// another start should not be possible
m_seatInterface->startPointerSwipeGesture(2);
Reduce unnecessary long wait times on failing signal spies Summary: Several signal spies, which were supposed to fail, were waiting for the default 5 seconds, which is most often unnecessary long. This patch sets a time limit of 500ms in suitable cases. Reduces for me the total test time by 40%. Test Plan: Before (with fixed seat and selection tests): 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 173.31 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) After: 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 102.12 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14184
2018-07-17 09:30:16 +00:00
QVERIFY(!startSpy.wait(500));
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
// send in some updates
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerSwipeGesture(QSizeF(2, 3));
QVERIFY(updateSpy.wait());
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerSwipeGesture(QSizeF(4, 5));
QVERIFY(updateSpy.wait());
QCOMPARE(updateSpy.count(), 2);
QCOMPARE(updateSpy.at(0).at(0).toSizeF(), QSizeF(2, 3));
QCOMPARE(updateSpy.at(0).at(1).value<quint32>(), 2u);
QCOMPARE(updateSpy.at(1).at(0).toSizeF(), QSizeF(4, 5));
QCOMPARE(updateSpy.at(1).at(1).value<quint32>(), 3u);
// now end or cancel
QFETCH(bool, cancel);
QSignalSpy *spy;
m_seatInterface->setTimestamp(timestamp++);
if (cancel) {
m_seatInterface->cancelPointerSwipeGesture();
spy = &cancelledSpy;
} else {
m_seatInterface->endPointerSwipeGesture();
spy = &endSpy;
}
QVERIFY(spy->wait());
QTEST(endSpy.count(), "expectedEndCount");
QTEST(cancelledSpy.count(), "expectedCancelCount");
QCOMPARE(spy->count(), 1);
QCOMPARE(spy->first().at(0).value<quint32>(), m_display->serial());
QCOMPARE(spy->first().at(1).value<quint32>(), 4u);
QCOMPARE(gesture->fingerCount(), 0u);
QVERIFY(gesture->surface().isNull());
// now a start should be possible again
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->startPointerSwipeGesture(2);
QVERIFY(startSpy.wait());
// unsetting the focused pointer surface should not change anything
m_seatInterface->setFocusedPointerSurface(nullptr);
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerSwipeGesture(QSizeF(6, 7));
QVERIFY(updateSpy.wait());
// and end
m_seatInterface->setTimestamp(timestamp++);
if (cancel) {
m_seatInterface->cancelPointerSwipeGesture();
} else {
m_seatInterface->endPointerSwipeGesture();
}
QVERIFY(spy->wait());
}
void TestWaylandSeat::testPointerPinchGesture_data()
{
QTest::addColumn<bool>("cancel");
QTest::addColumn<int>("expectedEndCount");
QTest::addColumn<int>("expectedCancelCount");
QTest::newRow("end") << false << 1 << 0;
QTest::newRow("cancel") << true << 0 << 1;
}
void TestWaylandSeat::testPointerPinchGesture()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the pointer and pointer swipe gesture
QSignalSpy hasPointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(hasPointerChangedSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(hasPointerChangedSpy.wait());
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QScopedPointer<PointerPinchGesture> gesture(m_pointerGestures->createPinchGesture(pointer.data()));
QVERIFY(gesture);
QVERIFY(gesture->isValid());
QVERIFY(gesture->surface().isNull());
QCOMPARE(gesture->fingerCount(), 0u);
QSignalSpy startSpy(gesture.data(), &PointerPinchGesture::started);
QVERIFY(startSpy.isValid());
QSignalSpy updateSpy(gesture.data(), &PointerPinchGesture::updated);
QVERIFY(updateSpy.isValid());
QSignalSpy endSpy(gesture.data(), &PointerPinchGesture::ended);
QVERIFY(endSpy.isValid());
QSignalSpy cancelledSpy(gesture.data(), &PointerPinchGesture::cancelled);
QVERIFY(cancelledSpy.isValid());
// now create a surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setFocusedPointerSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(m_seatInterface->focusedPointer());
// send in the start
quint32 timestamp = 1;
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->startPointerPinchGesture(3);
QVERIFY(startSpy.wait());
QCOMPARE(startSpy.count(), 1);
QCOMPARE(startSpy.first().at(0).value<quint32>(), m_display->serial());
QCOMPARE(startSpy.first().at(1).value<quint32>(), 1u);
QCOMPARE(gesture->fingerCount(), 3u);
QCOMPARE(gesture->surface().data(), surface.data());
// another start should not be possible
m_seatInterface->startPointerPinchGesture(3);
Reduce unnecessary long wait times on failing signal spies Summary: Several signal spies, which were supposed to fail, were waiting for the default 5 seconds, which is most often unnecessary long. This patch sets a time limit of 500ms in suitable cases. Reduces for me the total test time by 40%. Test Plan: Before (with fixed seat and selection tests): 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 173.31 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) After: 98% tests passed, 1 tests failed out of 45 Total Test time (real) = 102.12 sec The following tests FAILED: 19 - kwayland-testWindowmanagement (Failed) Reviewers: #plasma, davidedmundson Reviewed By: #plasma, davidedmundson Subscribers: kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14184
2018-07-17 09:30:16 +00:00
QVERIFY(!startSpy.wait(500));
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
// send in some updates
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerPinchGesture(QSizeF(2, 3), 2, 45);
QVERIFY(updateSpy.wait());
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerPinchGesture(QSizeF(4, 5), 1, 90);
QVERIFY(updateSpy.wait());
QCOMPARE(updateSpy.count(), 2);
QCOMPARE(updateSpy.at(0).at(0).toSizeF(), QSizeF(2, 3));
QCOMPARE(updateSpy.at(0).at(1).value<quint32>(), 2u);
QCOMPARE(updateSpy.at(0).at(2).value<quint32>(), 45u);
QCOMPARE(updateSpy.at(0).at(3).value<quint32>(), 2u);
QCOMPARE(updateSpy.at(1).at(0).toSizeF(), QSizeF(4, 5));
QCOMPARE(updateSpy.at(1).at(1).value<quint32>(), 1u);
QCOMPARE(updateSpy.at(1).at(2).value<quint32>(), 90u);
QCOMPARE(updateSpy.at(1).at(3).value<quint32>(), 3u);
// now end or cancel
QFETCH(bool, cancel);
QSignalSpy *spy;
m_seatInterface->setTimestamp(timestamp++);
if (cancel) {
m_seatInterface->cancelPointerPinchGesture();
spy = &cancelledSpy;
} else {
m_seatInterface->endPointerPinchGesture();
spy = &endSpy;
}
QVERIFY(spy->wait());
QTEST(endSpy.count(), "expectedEndCount");
QTEST(cancelledSpy.count(), "expectedCancelCount");
QCOMPARE(spy->count(), 1);
QCOMPARE(spy->first().at(0).value<quint32>(), m_display->serial());
QCOMPARE(spy->first().at(1).value<quint32>(), 4u);
QCOMPARE(gesture->fingerCount(), 0u);
QVERIFY(gesture->surface().isNull());
// now a start should be possible again
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->startPointerPinchGesture(3);
QVERIFY(startSpy.wait());
// unsetting the focused pointer surface should not change anything
m_seatInterface->setFocusedPointerSurface(nullptr);
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->updatePointerPinchGesture(QSizeF(6, 7), 2, -45);
QVERIFY(updateSpy.wait());
// and end
m_seatInterface->setTimestamp(timestamp++);
if (cancel) {
m_seatInterface->cancelPointerPinchGesture();
} else {
m_seatInterface->endPointerPinchGesture();
}
QVERIFY(spy->wait());
}
Allow compositors to send discrete axis values Summary: So far not all v5 features were implemented because most of them are optional. But given that XWayland needs axis_discrete event maybe it's time to implement them. CCBUG: 404152 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, mthw, kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D18933
2019-02-11 16:35:23 +00:00
void TestWaylandSeat::testPointerAxis()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the pointer
QSignalSpy hasPointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(hasPointerChangedSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(hasPointerChangedSpy.wait());
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(pointer);
// now create a surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setFocusedPointerSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedPointerSurface(), serverSurface);
QVERIFY(m_seatInterface->focusedPointer());
QSignalSpy frameSpy(pointer.data(), &Pointer::frame);
QVERIFY(frameSpy.isValid());
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 1);
// let's scroll vertically
QSignalSpy axisSourceSpy(pointer.data(), &Pointer::axisSourceChanged);
QVERIFY(axisSourceSpy.isValid());
QSignalSpy axisSpy(pointer.data(), &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
QSignalSpy axisDiscreteSpy(pointer.data(), &Pointer::axisDiscreteChanged);
QVERIFY(axisDiscreteSpy.isValid());
QSignalSpy axisStoppedSpy(pointer.data(), &Pointer::axisStopped);
QVERIFY(axisStoppedSpy.isValid());
quint32 timestamp = 1;
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerAxisV5(Qt::Vertical, 10, 1, PointerAxisSource::Wheel);
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 2);
QCOMPARE(axisSourceSpy.count(), 1);
QCOMPARE(axisSourceSpy.last().at(0).value<Pointer::AxisSource>(), Pointer::AxisSource::Wheel);
QCOMPARE(axisDiscreteSpy.count(), 1);
QCOMPARE(axisDiscreteSpy.last().at(0).value<Pointer::Axis>(), Pointer::Axis::Vertical);
QCOMPARE(axisDiscreteSpy.last().at(1).value<qint32>(), 1);
QCOMPARE(axisSpy.count(), 1);
QCOMPARE(axisSpy.last().at(0).value<quint32>(), quint32(1));
QCOMPARE(axisSpy.last().at(1).value<Pointer::Axis>(), Pointer::Axis::Vertical);
QCOMPARE(axisSpy.last().at(2).value<qreal>(), 10.0);
QCOMPARE(axisStoppedSpy.count(), 0);
// let's scroll using fingers
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerAxisV5(Qt::Horizontal, 42, 0, PointerAxisSource::Finger);
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 3);
QCOMPARE(axisSourceSpy.count(), 2);
QCOMPARE(axisSourceSpy.last().at(0).value<Pointer::AxisSource>(), Pointer::AxisSource::Finger);
QCOMPARE(axisDiscreteSpy.count(), 1);
QCOMPARE(axisSpy.count(), 2);
QCOMPARE(axisSpy.last().at(0).value<quint32>(), quint32(2));
QCOMPARE(axisSpy.last().at(1).value<Pointer::Axis>(), Pointer::Axis::Horizontal);
QCOMPARE(axisSpy.last().at(2).value<qreal>(), 42.0);
QCOMPARE(axisStoppedSpy.count(), 0);
// lift the fingers off the device
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerAxisV5(Qt::Horizontal, 0, 0, PointerAxisSource::Finger);
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 4);
QCOMPARE(axisSourceSpy.count(), 3);
QCOMPARE(axisSourceSpy.last().at(0).value<Pointer::AxisSource>(), Pointer::AxisSource::Finger);
QCOMPARE(axisDiscreteSpy.count(), 1);
QCOMPARE(axisSpy.count(), 2);
QCOMPARE(axisStoppedSpy.count(), 1);
QCOMPARE(axisStoppedSpy.last().at(0).value<quint32>(), 3);
QCOMPARE(axisStoppedSpy.last().at(1).value<Pointer::Axis>(), Pointer::Axis::Horizontal);
// if the device is unknown, no axis_source event should be sent
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerAxisV5(Qt::Horizontal, 42, 1, PointerAxisSource::Unknown);
QVERIFY(frameSpy.wait());
QCOMPARE(frameSpy.count(), 5);
QCOMPARE(axisSourceSpy.count(), 3);
QCOMPARE(axisDiscreteSpy.count(), 2);
QCOMPARE(axisDiscreteSpy.last().at(0).value<Pointer::Axis>(), Pointer::Axis::Horizontal);
QCOMPARE(axisDiscreteSpy.last().at(1).value<qint32>(), 1);
QCOMPARE(axisSpy.count(), 3);
QCOMPARE(axisSpy.last().at(0).value<quint32>(), quint32(4));
QCOMPARE(axisSpy.last().at(1).value<Pointer::Axis>(), Pointer::Axis::Horizontal);
QCOMPARE(axisSpy.last().at(2).value<qreal>(), 42.0);
QCOMPARE(axisStoppedSpy.count(), 1);
}
[server] Pass keyboard focus to child surface on pointer click If the focused pointer and keyboard surface is the same we use pointer clicks as a hint to which child surface should have keyboard focus. Keyboard focus handling for sub surfaces is rather limited overall. We just don't have a good model on how to determine which child surface should get the keyboard focus. When passing focus to a surface there is no way to know which of the sub-surfaces should get the focus. Ideally the client should handle this, but that's just not the case. The best we have is a reference through the pointer. But that's of course also limited. Keyboard focus passed to the surface for another reason (Alt+Tab) cannot select the proper sub-surface without interaction from another input device. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1330
2016-04-06 11:50:19 +00:00
void TestWaylandSeat::testKeyboardSubSurfaceTreeFromPointer()
{
// this test verifies that when clicking on a sub-surface the keyboard focus passes to it
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the pointer
QSignalSpy hasPointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(hasPointerChangedSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(hasPointerChangedSpy.wait());
QScopedPointer<Pointer> pointer(m_seat->createPointer());
// and create keyboard
QSignalSpy hasKeyboardChangedSpy(m_seat, &Seat::hasKeyboardChanged);
QVERIFY(hasKeyboardChangedSpy.isValid());
m_seatInterface->setHasKeyboard(true);
QVERIFY(hasKeyboardChangedSpy.wait());
QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
// create a sub surface tree
// parent surface (100, 100) with one sub surface taking the half of it's size (50, 100)
// which has two further children (50, 50) which are overlapping
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> parentSurface(m_compositor->createSurface());
QScopedPointer<Surface> childSurface(m_compositor->createSurface());
QScopedPointer<Surface> grandChild1Surface(m_compositor->createSurface());
QScopedPointer<Surface> grandChild2Surface(m_compositor->createSurface());
QScopedPointer<SubSurface> childSubSurface(m_subCompositor->createSubSurface(childSurface.data(), parentSurface.data()));
QScopedPointer<SubSurface> grandChild1SubSurface(m_subCompositor->createSubSurface(grandChild1Surface.data(), childSurface.data()));
QScopedPointer<SubSurface> grandChild2SubSurface(m_subCompositor->createSubSurface(grandChild2Surface.data(), childSurface.data()));
grandChild2SubSurface->setPosition(QPoint(0, 25));
// let's map the surfaces
auto render = [this] (Surface *s, const QSize &size) {
Treat input RGB buffers as premultiplied Summary: Currently the server treats incoming buffers as not premultiplied. KWayland::Client sends data that is ARGB32 and ARGB32_Premultiplied as the same WL_SHM_FORMAT_ARGB8888. According to a post on wayland-devel by Fredrik Höglund, all RGB data should be treated as premultiplied, which matches what Qt is doing. Client now performs a conversion rather than sending mismatched data, Note: This commit will still breaks a bunch of tests in kwin as it compares the server output to a fixed QImage with a format. Test Plan: Existing tests pass Modified surface test to check the pixel data relative to the output QImage format not the input format (i.e both input from ARGB32 and ARGB32_Premultiplied) should both end up in a QImage with format Premultiplied with premultiplied values. The existing test was confirming that data was corrupted, checking that even though the output format was not pre-multiplied, the data was. Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7460
2017-08-30 08:57:41 +00:00
QImage image(size, QImage::Format_ARGB32_Premultiplied);
[server] Pass keyboard focus to child surface on pointer click If the focused pointer and keyboard surface is the same we use pointer clicks as a hint to which child surface should have keyboard focus. Keyboard focus handling for sub surfaces is rather limited overall. We just don't have a good model on how to determine which child surface should get the keyboard focus. When passing focus to a surface there is no way to know which of the sub-surfaces should get the focus. Ideally the client should handle this, but that's just not the case. The best we have is a reference through the pointer. But that's of course also limited. Keyboard focus passed to the surface for another reason (Alt+Tab) cannot select the proper sub-surface without interaction from another input device. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1330
2016-04-06 11:50:19 +00:00
image.fill(Qt::black);
s->attachBuffer(m_shm->createBuffer(image));
s->damage(QRect(QPoint(0, 0), size));
s->commit(Surface::CommitFlag::None);
};
render(grandChild2Surface.data(), QSize(50, 50));
render(grandChild1Surface.data(), QSize(50, 50));
render(childSurface.data(), QSize(50, 100));
render(parentSurface.data(), QSize(100, 100));
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(serverSurface->isMapped());
// pass keyboard focus to the main surface
QSignalSpy enterSpy(keyboard.data(), &Keyboard::entered);
QVERIFY(enterSpy.isValid());
QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
QVERIFY(leftSpy.isValid());
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QVERIFY(enterSpy.wait());
QCOMPARE(enterSpy.count(), 1);
QCOMPARE(leftSpy.count(), 0);
QCOMPARE(keyboard->enteredSurface(), parentSurface.data());
// now pass also pointer focus to the surface
QSignalSpy pointerEnterSpy(pointer.data(), &Pointer::entered);
QVERIFY(pointerEnterSpy.isValid());
quint32 timestamp = 1;
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->setPointerPos(QPointF(25, 50));
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(pointerEnterSpy.wait());
QCOMPARE(pointerEnterSpy.count(), 1);
// should not have affected the keyboard
QCOMPARE(enterSpy.count(), 1);
QCOMPARE(leftSpy.count(), 0);
// let's click
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerButtonPressed(Qt::LeftButton);
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerButtonReleased(Qt::LeftButton);
QVERIFY(enterSpy.wait());
QCOMPARE(enterSpy.count(), 2);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(keyboard->enteredSurface(), grandChild2Surface.data());
// click on same surface should not trigger another enter
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerButtonPressed(Qt::LeftButton);
m_seatInterface->setTimestamp(timestamp++);
m_seatInterface->pointerButtonReleased(Qt::LeftButton);
QVERIFY(!enterSpy.wait(200));
QCOMPARE(enterSpy.count(), 2);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(keyboard->enteredSurface(), grandChild2Surface.data());
// unfocus keyboard
m_seatInterface->setFocusedKeyboardSurface(nullptr);
QVERIFY(leftSpy.wait());
QCOMPARE(enterSpy.count(), 2);
QCOMPARE(leftSpy.count(), 2);
}
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
void TestWaylandSeat::testCursor()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
QVERIFY(surfaceCreatedSpy.isValid());
m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
QScopedPointer<Pointer> p(m_seat->createPointer());
QVERIFY(p->isValid());
wl_display_flush(m_connection->display());
QCoreApplication::processEvents();
QSignalSpy enteredSpy(p.data(), SIGNAL(entered(quint32,QPointF)));
QVERIFY(enteredSpy.isValid());
m_seatInterface->setPointerPos(QPoint(20, 18));
m_seatInterface->setFocusedPointerSurface(serverSurface, QPoint(10, 15));
quint32 serial = m_seatInterface->display()->serial();
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.first().first().value<quint32>(), serial);
QVERIFY(m_seatInterface->focusedPointerSurface());
QVERIFY(m_seatInterface->focusedPointer());
QVERIFY(!m_seatInterface->focusedPointer()->cursor());
QSignalSpy cursorChangedSpy(m_seatInterface->focusedPointer(), SIGNAL(cursorChanged()));
QVERIFY(cursorChangedSpy.isValid());
// just remove the pointer
p->setCursor(nullptr);
QVERIFY(cursorChangedSpy.wait());
QCOMPARE(cursorChangedSpy.count(), 1);
auto cursor = m_seatInterface->focusedPointer()->cursor();
QVERIFY(cursor);
QVERIFY(!cursor->surface());
QCOMPARE(cursor->hotspot(), QPoint());
QCOMPARE(cursor->enteredSerial(), serial);
[autotests] Get Server::Cursor::pointer under coverage Just verifying that it's returning the expected value.
2016-06-28 16:39:19 +00:00
QCOMPARE(cursor->pointer(), m_seatInterface->focusedPointer());
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
QSignalSpy hotspotChangedSpy(cursor, SIGNAL(hotspotChanged()));
QVERIFY(hotspotChangedSpy.isValid());
QSignalSpy surfaceChangedSpy(cursor, SIGNAL(surfaceChanged()));
QVERIFY(surfaceChangedSpy.isValid());
QSignalSpy enteredSerialChangedSpy(cursor, SIGNAL(enteredSerialChanged()));
QVERIFY(enteredSerialChangedSpy.isValid());
QSignalSpy changedSpy(cursor, SIGNAL(changed()));
QVERIFY(changedSpy.isValid());
// test changing hotspot
p->setCursor(nullptr, QPoint(1, 2));
QVERIFY(hotspotChangedSpy.wait());
QCOMPARE(hotspotChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 1);
QCOMPARE(cursorChangedSpy.count(), 2);
QCOMPARE(cursor->hotspot(), QPoint(1, 2));
QVERIFY(enteredSerialChangedSpy.isEmpty());
QVERIFY(surfaceChangedSpy.isEmpty());
// set surface
auto cursorSurface = m_compositor->createSurface(m_compositor);
QVERIFY(cursorSurface->isValid());
p->setCursor(cursorSurface, QPoint(1, 2));
QVERIFY(surfaceChangedSpy.wait());
QCOMPARE(surfaceChangedSpy.count(), 1);
QCOMPARE(changedSpy.count(), 2);
QCOMPARE(cursorChangedSpy.count(), 3);
QVERIFY(enteredSerialChangedSpy.isEmpty());
QCOMPARE(cursor->hotspot(), QPoint(1, 2));
QVERIFY(cursor->surface());
// and add an image to the surface
QImage img(QSize(10, 20), QImage::Format_RGB32);
img.fill(Qt::red);
cursorSurface->attachBuffer(m_shm->createBuffer(img));
cursorSurface->damage(QRect(0, 0, 10, 20));
cursorSurface->commit(Surface::CommitFlag::None);
QVERIFY(changedSpy.wait());
QCOMPARE(changedSpy.count(), 3);
QCOMPARE(cursorChangedSpy.count(), 4);
QCOMPARE(surfaceChangedSpy.count(), 1);
QCOMPARE(cursor->surface()->buffer()->data(), img);
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
// and add another image to the surface
Treat input RGB buffers as premultiplied Summary: Currently the server treats incoming buffers as not premultiplied. KWayland::Client sends data that is ARGB32 and ARGB32_Premultiplied as the same WL_SHM_FORMAT_ARGB8888. According to a post on wayland-devel by Fredrik Höglund, all RGB data should be treated as premultiplied, which matches what Qt is doing. Client now performs a conversion rather than sending mismatched data, Note: This commit will still breaks a bunch of tests in kwin as it compares the server output to a fixed QImage with a format. Test Plan: Existing tests pass Modified surface test to check the pixel data relative to the output QImage format not the input format (i.e both input from ARGB32 and ARGB32_Premultiplied) should both end up in a QImage with format Premultiplied with premultiplied values. The existing test was confirming that data was corrupted, checking that even though the output format was not pre-multiplied, the data was. Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7460
2017-08-30 08:57:41 +00:00
QImage blue(QSize(10, 20), QImage::Format_ARGB32_Premultiplied);
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
blue.fill(Qt::blue);
cursorSurface->attachBuffer(m_shm->createBuffer(blue));
cursorSurface->damage(QRect(0, 0, 10, 20));
cursorSurface->commit(Surface::CommitFlag::None);
QVERIFY(changedSpy.wait());
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
QCOMPARE(changedSpy.count(), 4);
QCOMPARE(cursorChangedSpy.count(), 5);
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
QCOMPARE(cursor->surface()->buffer()->data(), blue);
p->hideCursor();
QVERIFY(surfaceChangedSpy.wait());
QCOMPARE(changedSpy.count(), 5);
QCOMPARE(cursorChangedSpy.count(), 6);
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
QCOMPARE(surfaceChangedSpy.count(), 2);
QVERIFY(!cursor->surface());
}
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
void TestWaylandSeat::testCursorDamage()
{
// this test verifies that damaging a cursor surface triggers a cursor changed on the server
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy pointerSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
// create pointer
QScopedPointer<Pointer> p(m_seat->createPointer());
QVERIFY(p->isValid());
QSignalSpy enteredSpy(p.data(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
// create surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
// send enter to the surface
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(enteredSpy.wait());
// create a signal spy for the cursor changed signal
auto pointer = m_seatInterface->focusedPointer();
QSignalSpy cursorChangedSpy(pointer, &PointerInterface::cursorChanged);
QVERIFY(cursorChangedSpy.isValid());
// now let's set the cursor
Surface *cursorSurface = m_compositor->createSurface(m_compositor);
QVERIFY(cursorSurface);
Treat input RGB buffers as premultiplied Summary: Currently the server treats incoming buffers as not premultiplied. KWayland::Client sends data that is ARGB32 and ARGB32_Premultiplied as the same WL_SHM_FORMAT_ARGB8888. According to a post on wayland-devel by Fredrik Höglund, all RGB data should be treated as premultiplied, which matches what Qt is doing. Client now performs a conversion rather than sending mismatched data, Note: This commit will still breaks a bunch of tests in kwin as it compares the server output to a fixed QImage with a format. Test Plan: Existing tests pass Modified surface test to check the pixel data relative to the output QImage format not the input format (i.e both input from ARGB32 and ARGB32_Premultiplied) should both end up in a QImage with format Premultiplied with premultiplied values. The existing test was confirming that data was corrupted, checking that even though the output format was not pre-multiplied, the data was. Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7460
2017-08-30 08:57:41 +00:00
QImage red(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
red.fill(Qt::red);
cursorSurface->attachBuffer(m_shm->createBuffer(red));
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit(Surface::CommitFlag::None);
p->setCursor(cursorSurface, QPoint(0, 0));
QVERIFY(cursorChangedSpy.wait());
QCOMPARE(pointer->cursor()->surface()->buffer()->data(), red);
// and damage the surface
Treat input RGB buffers as premultiplied Summary: Currently the server treats incoming buffers as not premultiplied. KWayland::Client sends data that is ARGB32 and ARGB32_Premultiplied as the same WL_SHM_FORMAT_ARGB8888. According to a post on wayland-devel by Fredrik Höglund, all RGB data should be treated as premultiplied, which matches what Qt is doing. Client now performs a conversion rather than sending mismatched data, Note: This commit will still breaks a bunch of tests in kwin as it compares the server output to a fixed QImage with a format. Test Plan: Existing tests pass Modified surface test to check the pixel data relative to the output QImage format not the input format (i.e both input from ARGB32 and ARGB32_Premultiplied) should both end up in a QImage with format Premultiplied with premultiplied values. The existing test was confirming that data was corrupted, checking that even though the output format was not pre-multiplied, the data was. Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7460
2017-08-30 08:57:41 +00:00
QImage blue(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
[server] Properly initialize Cursor Summary: The Cursor wasn't properly initialized. E.g. the damage signal didn't get connected resulting in the server not noticing when the cursor changes. The damage only got connected if a new cursor got instelled by the client on the same pointer. This change ensures that the Cursor is properly initialized by calling into the same method as when the cursor changed. The tests are extended by a new test case for damaging the surface. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1022
2016-02-24 15:46:21 +00:00
blue.fill(Qt::blue);
cursorSurface->attachBuffer(m_shm->createBuffer(blue));
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit(Surface::CommitFlag::None);
QVERIFY(cursorChangedSpy.wait());
QCOMPARE(pointer->cursor()->surface()->buffer()->data(), blue);
}
[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 TestWaylandSeat::testKeyboard()
{
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
using namespace KWayland::Client;
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
using namespace KWayland::Server;
[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
QSignalSpy keyboardSpy(m_seat, SIGNAL(hasKeyboardChanged(bool)));
QVERIFY(keyboardSpy.isValid());
m_seatInterface->setHasKeyboard(true);
QVERIFY(keyboardSpy.wait());
// create the surface
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
[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(surfaceCreatedSpy.isValid());
Surface *s = m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
Use namespace KWayland::Server instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:10:38 +00:00
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
[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(serverSurface);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
// no keyboard yet
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedKeyboard());
[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
Pass parent to Client::Keyboard in TestWaylandSeat This ensures that the Keyboard doesn't leak in the test.
2014-09-22 09:00:02 +00:00
Keyboard *keyboard = m_seat->createKeyboard(m_seat);
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
QSignalSpy repeatInfoSpy(keyboard, &Keyboard::keyRepeatChanged);
QVERIFY(repeatInfoSpy.isValid());
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
const Keyboard &ckeyboard = *keyboard;
[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(keyboard->isValid());
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
QCOMPARE(keyboard->isKeyRepeatEnabled(), false);
QCOMPARE(keyboard->keyRepeatDelay(), 0);
QCOMPARE(keyboard->keyRepeatRate(), 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
wl_display_flush(m_connection->display());
QTest::qWait(100);
Properly handle destroying a Keyboard resource Summary: On client side the newer wl_keyboard_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the KeyboardInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound KeyboardInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2036
2016-06-28 15:02:22 +00:00
auto serverKeyboard = m_seatInterface->focusedKeyboard();
QVERIFY(serverKeyboard);
[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
// we should get the repeat info announced
QCOMPARE(repeatInfoSpy.count(), 1);
QCOMPARE(keyboard->isKeyRepeatEnabled(), false);
QCOMPARE(keyboard->keyRepeatDelay(), 0);
QCOMPARE(keyboard->keyRepeatRate(), 0);
// let's change repeat in server
m_seatInterface->setKeyRepeatInfo(25, 660);
m_seatInterface->focusedKeyboard()->client()->flush();
QVERIFY(repeatInfoSpy.wait());
QCOMPARE(repeatInfoSpy.count(), 2);
QCOMPARE(keyboard->isKeyRepeatEnabled(), true);
QCOMPARE(keyboard->keyRepeatRate(), 25);
QCOMPARE(keyboard->keyRepeatDelay(), 660);
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(1);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyPressed(KEY_K);
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(2);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyPressed(KEY_D);
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(3);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyPressed(KEY_E);
[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
QSignalSpy modifierSpy(keyboard, SIGNAL(modifiersChanged(quint32,quint32,quint32,quint32)));
QVERIFY(modifierSpy.isValid());
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QSignalSpy enteredSpy(keyboard, SIGNAL(entered(quint32)));
QVERIFY(enteredSpy.isValid());
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboard()->focusedSurface(), serverSurface);
[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
// we get the modifiers sent after the enter
QVERIFY(modifierSpy.wait());
QCOMPARE(modifierSpy.count(), 1);
QCOMPARE(modifierSpy.first().at(0).value<quint32>(), quint32(0));
QCOMPARE(modifierSpy.first().at(1).value<quint32>(), quint32(0));
QCOMPARE(modifierSpy.first().at(2).value<quint32>(), quint32(0));
QCOMPARE(modifierSpy.first().at(3).value<quint32>(), quint32(0));
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QCOMPARE(enteredSpy.count(), 1);
[autotest] Adjust Seat test for changes in 990e88ac The text input change creates an additional serial, so the check for last generated serial on the Display fails. The test is now adjusted to the new semantics. A more reliable way would be to verify the serial on the SeatInterface, though.
2016-05-25 13:32:59 +00:00
// TODO: get through API
QCOMPARE(enteredSpy.first().first().value<quint32>(), m_display->serial() - 1);
[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
Use namespace KWayland::Client instead of KWin::WaylandServer It's no longer part of KWin.
2014-09-17 14:17:26 +00:00
QSignalSpy keyChangedSpy(keyboard, SIGNAL(keyChanged(quint32,KWayland::Client::Keyboard::KeyState,quint32)));
[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(keyChangedSpy.isValid());
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(4);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyReleased(KEY_E);
[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(keyChangedSpy.wait());
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(5);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyReleased(KEY_D);
[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(keyChangedSpy.wait());
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(6);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyReleased(KEY_K);
[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(keyChangedSpy.wait());
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(7);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyPressed(KEY_F1);
[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(keyChangedSpy.wait());
Get event timestamp from SeatInterface in KeyboardInterface
2014-11-26 12:04:36 +00:00
m_seatInterface->setTimestamp(8);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->keyReleased(KEY_F1);
[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(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 5);
QCOMPARE(keyChangedSpy.at(0).at(0).value<quint32>(), quint32(KEY_E));
QCOMPARE(keyChangedSpy.at(0).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
QCOMPARE(keyChangedSpy.at(0).at(2).value<quint32>(), quint32(4));
QCOMPARE(keyChangedSpy.at(1).at(0).value<quint32>(), quint32(KEY_D));
QCOMPARE(keyChangedSpy.at(1).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
QCOMPARE(keyChangedSpy.at(1).at(2).value<quint32>(), quint32(5));
QCOMPARE(keyChangedSpy.at(2).at(0).value<quint32>(), quint32(KEY_K));
QCOMPARE(keyChangedSpy.at(2).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
QCOMPARE(keyChangedSpy.at(2).at(2).value<quint32>(), quint32(6));
QCOMPARE(keyChangedSpy.at(3).at(0).value<quint32>(), quint32(KEY_F1));
QCOMPARE(keyChangedSpy.at(3).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
QCOMPARE(keyChangedSpy.at(3).at(2).value<quint32>(), quint32(7));
QCOMPARE(keyChangedSpy.at(4).at(0).value<quint32>(), quint32(KEY_F1));
QCOMPARE(keyChangedSpy.at(4).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
QCOMPARE(keyChangedSpy.at(4).at(2).value<quint32>(), quint32(8));
[server] Don't send key release for not pressed keys and no double key press Summary: This change makes use of the internal key state in better way. If a key is not considered pressed, no key release is sent. This can happen for example if the compositor grabs a key press (global shortcut) but not the release. The Wayland client cannot do anything with the release as it never got the press. Thus it doesn't make sense to send the release. Similar if a key is already pressed, it doesn't make sense to send another press event. This ensures that if the server sends in repeating key presses they are filtered out. Key repeat is handled on client side. Also if several physical keys send the same key code, pressing them at the same time won't send double press/release event. This change might cause regressions in KWin in case KWin does not handle the situation correctly. But that would be a bug in KWin which needs to be fixed there. If it causes regressions the bug might have shown in other situations as well. BUG: 366625 FIXED-IN: 5.27 Reviewers: #plasma_on_wayland, #kwin Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2786
2016-09-15 07:27:03 +00:00
// releasing a key which is already released should not set a key changed
m_seatInterface->keyReleased(KEY_F1);
QVERIFY(!keyChangedSpy.wait(200));
// let's press it again
m_seatInterface->keyPressed(KEY_F1);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 6);
// press again should be ignored
m_seatInterface->keyPressed(KEY_F1);
QVERIFY(!keyChangedSpy.wait(200));
// and release
m_seatInterface->keyReleased(KEY_F1);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 7);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->updateKeyboardModifiers(1, 2, 3, 4);
[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(modifierSpy.wait());
QCOMPARE(modifierSpy.count(), 2);
QCOMPARE(modifierSpy.last().at(0).value<quint32>(), quint32(1));
QCOMPARE(modifierSpy.last().at(1).value<quint32>(), quint32(2));
QCOMPARE(modifierSpy.last().at(2).value<quint32>(), quint32(3));
QCOMPARE(modifierSpy.last().at(3).value<quint32>(), quint32(4));
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QSignalSpy leftSpy(keyboard, SIGNAL(left(quint32)));
QVERIFY(leftSpy.isValid());
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->setFocusedKeyboardSurface(nullptr);
QVERIFY(!m_seatInterface->focusedKeyboardSurface());
QVERIFY(!m_seatInterface->focusedKeyboard());
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
[autotest] Adjust Seat test for changes in 990e88ac The text input change creates an additional serial, so the check for last generated serial on the Display fails. The test is now adjusted to the new semantics. A more reliable way would be to verify the serial on the SeatInterface, though.
2016-05-25 13:32:59 +00:00
// TODO: get through API
QCOMPARE(leftSpy.first().first().value<quint32>(), m_display->serial() -1 );
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QVERIFY(!keyboard->enteredSurface());
QVERIFY(!ckeyboard.enteredSurface());
[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
// enter it again
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
[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(modifierSpy.wait());
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboard()->focusedSurface(), serverSurface);
Implement entered surface for Keyboard Anologous to the implementation in Pointer: * signal entered and left * Surface *enteredSurface() The passed in keys are not yet passed along and currently ignored.
2014-12-06 20:56:12 +00:00
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(keyboard->enteredSurface(), s);
QCOMPARE(ckeyboard.enteredSurface(), s);
[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
Properly handle destroying a Keyboard resource Summary: On client side the newer wl_keyboard_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the KeyboardInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound KeyboardInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2036
2016-06-28 15:02:22 +00:00
QSignalSpy serverSurfaceDestroyedSpy(serverSurface, &QObject::destroyed);
QVERIFY(serverSurfaceDestroyedSpy.isValid());
[client] Properly track enteredSurface in Keyboard Summary: ASAN found a heap-use-after-free when deleting the focused keyboard surface in the client library. Keyboard did not track the lifetime of the focused surface and thus one can access already freed memory. Test Plan: Adjusted auto test to verify the variable gets cleared Reviewers: #frameworks, #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D6741
2017-07-16 16:36:14 +00:00
QCOMPARE(keyboard->enteredSurface(), s);
[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
delete s;
[client] Properly track enteredSurface in Keyboard Summary: ASAN found a heap-use-after-free when deleting the focused keyboard surface in the client library. Keyboard did not track the lifetime of the focused surface and thus one can access already freed memory. Test Plan: Adjusted auto test to verify the variable gets cleared Reviewers: #frameworks, #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D6741
2017-07-16 16:36:14 +00:00
QVERIFY(!keyboard->enteredSurface());
[server] Send keyboard leave when client destroys the focused surface Summary: This is a change inspired by https://bugreports.qt.io/browse/QTBUG-61930. When Qt closes a window due to a key press event it starts to repeat the event as KWayland does not send a keyboard leave event. Weston on the other hand does send out the keyboard leave. In my opinion it doesn't make much sense to send out the keyboard leave in this situation and in my opinion that is a client bug, but if it makes clients happy we can send them the keyboard leave. Similar this should be done for pointer, touch, etc. BUG: 382280 Test Plan: Run the example added to the Qt bug and it worked fine Reviewers: #frameworks, #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D6683
2017-07-13 15:45:24 +00:00
QVERIFY(leftSpy.wait());
QCOMPARE(serverSurfaceDestroyedSpy.count(), 1);
Refactor KeyboardInterface The KeyboardInterface gets created per wl_resource. For this all more global information (e.g. key states) is moved into the SeatInterface.
2014-11-26 14:00:44 +00:00
QVERIFY(!m_seatInterface->focusedKeyboardSurface());
QVERIFY(!m_seatInterface->focusedKeyboard());
Properly handle destroying a Keyboard resource Summary: On client side the newer wl_keyboard_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the KeyboardInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound KeyboardInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2036
2016-06-28 15:02:22 +00:00
QVERIFY(!serverKeyboard->focusedSurface());
// let's create a Surface again
QScopedPointer<Surface> s2(m_compositor->createSurface());
QVERIFY(surfaceCreatedSpy.wait());
QCOMPARE(surfaceCreatedSpy.count(), 2);
serverSurface = surfaceCreatedSpy.last().first().value<SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboard(), serverKeyboard);
// delete the Keyboard
QSignalSpy unboundSpy(serverKeyboard, &Resource::unbound);
QVERIFY(unboundSpy.isValid());
QSignalSpy destroyedSpy(serverKeyboard, &Resource::destroyed);
QVERIFY(destroyedSpy.isValid());
delete keyboard;
QVERIFY(unboundSpy.wait());
QCOMPARE(unboundSpy.count(), 1);
QCOMPARE(destroyedSpy.count(), 0);
// verify that calling into the Keyboard related functionality doesn't crash
m_seatInterface->setTimestamp(9);
m_seatInterface->keyPressed(KEY_F2);
m_seatInterface->setTimestamp(10);
m_seatInterface->keyReleased(KEY_F2);
m_seatInterface->setKeyRepeatInfo(30, 560);
m_seatInterface->setKeyRepeatInfo(25, 660);
m_seatInterface->updateKeyboardModifiers(5, 6, 7, 8);
m_seatInterface->setFocusedKeyboardSurface(nullptr);
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedKeyboard());
QVERIFY(destroyedSpy.wait());
QCOMPARE(destroyedSpy.count(), 1);
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
// create a second Keyboard to verify that repeat info is announced properly
Keyboard *keyboard2 = m_seat->createKeyboard(m_seat);
QSignalSpy repeatInfoSpy2(keyboard2, &Keyboard::keyRepeatChanged);
QVERIFY(repeatInfoSpy2.isValid());
QVERIFY(keyboard2->isValid());
QCOMPARE(keyboard2->isKeyRepeatEnabled(), false);
QCOMPARE(keyboard2->keyRepeatDelay(), 0);
QCOMPARE(keyboard2->keyRepeatRate(), 0);
wl_display_flush(m_connection->display());
QVERIFY(repeatInfoSpy2.wait());
QCOMPARE(keyboard2->isKeyRepeatEnabled(), true);
QCOMPARE(keyboard2->keyRepeatRate(), 25);
QCOMPARE(keyboard2->keyRepeatDelay(), 660);
Properly handle destroying a Keyboard resource Summary: On client side the newer wl_keyboard_release is used which is a destructor call. On server side the shared destroy callback is used and it's ensured that KWayland doesn't crash if called into the KeyboardInterface between unbound and destroyed. Test Plan: Test case extended to cover the condition of an unbound KeyboardInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2036
2016-06-28 15:02:22 +00:00
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
serverKeyboard = m_seatInterface->focusedKeyboard();
QVERIFY(serverKeyboard);
QSignalSpy keyboard2DestroyedSpy(serverKeyboard, &QObject::destroyed);
QVERIFY(keyboard2DestroyedSpy.isValid());
delete keyboard2;
QVERIFY(keyboard2DestroyedSpy.wait());
// this should have unset it on the server
QVERIFY(!m_seatInterface->focusedKeyboard());
// but not the surface
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
[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
}
Add test case for operator cast in Client::Seat
2014-09-22 09:56:48 +00:00
void TestWaylandSeat::testCast()
{
using namespace KWayland::Client;
Registry registry;
QSignalSpy seatSpy(&registry, SIGNAL(seatAnnounced(quint32,quint32)));
registry.create(m_connection->display());
QVERIFY(registry.isValid());
registry.setup();
QVERIFY(seatSpy.wait());
Seat s;
QVERIFY(!s.isValid());
auto wlSeat = registry.bindSeat(seatSpy.first().first().value<quint32>(), seatSpy.first().last().value<quint32>());
QVERIFY(wlSeat);
s.setup(wlSeat);
QVERIFY(s.isValid());
QCOMPARE((wl_seat*)s, wlSeat);
const Seat &s2(s);
QCOMPARE((wl_seat*)s2, wlSeat);
}
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
void TestWaylandSeat::testDestroy()
{
using namespace KWayland::Client;
Add ::destroy to Client::Keyboard and Client::Pointer This makes the API more consistent and allows to properly cleanup Keyboard and Pointer if the connection dies. Like with Shell and ShellSurface signals are emitted from Seat when the interface is going to be released or destroyed. These are connected to the methods of the created Pointer and Keyboard.
2014-09-22 11:12:08 +00:00
QSignalSpy keyboardSpy(m_seat, SIGNAL(hasKeyboardChanged(bool)));
QVERIFY(keyboardSpy.isValid());
m_seatInterface->setHasKeyboard(true);
QVERIFY(keyboardSpy.wait());
Keyboard *k = m_seat->createKeyboard(m_seat);
QVERIFY(k->isValid());
QSignalSpy pointerSpy(m_seat, SIGNAL(hasPointerChanged(bool)));
QVERIFY(pointerSpy.isValid());
m_seatInterface->setHasPointer(true);
QVERIFY(pointerSpy.wait());
Pointer *p = m_seat->createPointer(m_seat);
QVERIFY(p->isValid());
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
QSignalSpy touchSpy(m_seat, SIGNAL(hasTouchChanged(bool)));
QVERIFY(touchSpy.isValid());
m_seatInterface->setHasTouch(true);
QVERIFY(touchSpy.wait());
Touch *t = m_seat->createTouch(m_seat);
QVERIFY(t->isValid());
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
delete m_compositor;
m_compositor = nullptr;
connect(m_connection, &ConnectionThread::connectionDied, m_seat, &Seat::destroy);
Add support for setting cursor on the Pointer Methods on client side added and proper handling on server side.
2015-02-27 16:36:43 +00:00
connect(m_connection, &ConnectionThread::connectionDied, m_shm, &ShmPool::destroy);
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
connect(m_connection, &ConnectionThread::connectionDied, m_subCompositor, &SubCompositor::destroy);
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
connect(m_connection, &ConnectionThread::connectionDied, m_relativePointerManager, &RelativePointerManager::destroy);
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
connect(m_connection, &ConnectionThread::connectionDied, m_pointerGestures, &PointerGestures::destroy);
Add a Client::EventQueue The EventQueue is a wrapper for wl_event_queue. The usage is for the case that the connection is in a different thread. The EventQueue needs to be added to the Registry before Registry::create is invoked. This ensures that the Registry gets added to the EventQueue and all objects created by the Registry (and further down the tree) will be added to the same EventQueue. The auto-tests which already used a wl_event_queue are transited to the EventQueue class. That's also the reason why there is no dedicated unit test: the new code is sufficiently tested by the existing tests.
2014-09-23 09:55:07 +00:00
connect(m_connection, &ConnectionThread::connectionDied, m_queue, &EventQueue::destroy);
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
QVERIFY(m_seat->isValid());
QSignalSpy connectionDiedSpy(m_connection, SIGNAL(connectionDied()));
QVERIFY(connectionDiedSpy.isValid());
delete m_display;
m_display = nullptr;
m_compositorInterface = nullptr;
m_seatInterface = nullptr;
[server] Support sub-surfaces from PointerInterface Summary: The idea behind this change is to make the existance of sub-surfaces an implementation detail for pointer events. The user of the library does not need to care about on which sub-surface the pointer is on. It only needs to care about the main surface and passes the focus to the main surface. Internally the PointerInterface takes care of sending the enter to the sub-surface at the current pointer position. Also whenever the pointer position changes, the PointerInterface evaluates whether it triggered a change for the focused sub-surface and sends enter/leave events accordingly. If the focused sub-surface does not change, it sends motion events as normally, but of course under consideration of the sub-surface position. Overall this means that from pointer usage perspective a user of the library doesn't need to care about the fact that there are sub-surfaces at all. The library does the correct thing for it. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1329
2016-04-06 07:52:13 +00:00
m_subCompositorInterface = nullptr;
Implement support for the relative pointer protocol Summary: This change implements the zwp_relative_pointer_v1 protocol which allows to send relative motion events. The (unstable) protocol consists of a RelativePointerManager which creates RelativePointers for a given Pointer. This interface currently only has one event to report the relative motion. It carries the delta, the non-accelerated-delta and a timestamp in microsends granularity. On the server side the implementation is mostly internal. Once a RelativePointerManagerInterface is created one can send relative motion events through the SeatInterface. The SeatInterface takes care of sending it to the responding RelativePointerInterface. The protocol does not restrict the sending of "normal" and relative motion events. Thus it can be combined in any way one wants. This allows to have a rather simple implementation. A user of the SeatInterface can just start to feed the relative motion events (if the information is available) to the SeatInterface together with the pointer events. On client side a new RelativePointerManager and RelativePointer class are added. The RelativePointerManager creates the RelativePointer for a given Pointer. The event sent to RelativePointer is transformed in a normal signal. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2978
2016-10-07 07:07:34 +00:00
m_relativePointerManagerInterface = nullptr;
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
m_pointerGesturesInterface = nullptr;
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
QVERIFY(connectionDiedSpy.wait());
// now the seat should be destroyed;
QVERIFY(!m_seat->isValid());
Add ::destroy to Client::Keyboard and Client::Pointer This makes the API more consistent and allows to properly cleanup Keyboard and Pointer if the connection dies. Like with Shell and ShellSurface signals are emitted from Seat when the interface is going to be released or destroyed. These are connected to the methods of the created Pointer and Keyboard.
2014-09-22 11:12:08 +00:00
QVERIFY(!k->isValid());
QVERIFY(!p->isValid());
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
QVERIFY(!t->isValid());
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
// calling destroy again should not fail
m_seat->destroy();
Add ::destroy to Client::Keyboard and Client::Pointer This makes the API more consistent and allows to properly cleanup Keyboard and Pointer if the connection dies. Like with Shell and ShellSurface signals are emitted from Seat when the interface is going to be released or destroyed. These are connected to the methods of the created Pointer and Keyboard.
2014-09-22 11:12:08 +00:00
k->destroy();
p->destroy();
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
t->destroy();
Add test case for Seat::destroy
2014-09-22 10:02:57 +00:00
}
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
void TestWaylandSeat::testSelection()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
QScopedPointer<DataDeviceManagerInterface> ddmi(m_display->createDataDeviceManager());
ddmi->create();
Registry registry;
QSignalSpy dataDeviceManagerSpy(&registry, SIGNAL(dataDeviceManagerAnnounced(quint32,quint32)));
QVERIFY(dataDeviceManagerSpy.isValid());
registry.setEventQueue(m_queue);
registry.create(m_connection->display());
QVERIFY(registry.isValid());
registry.setup();
QVERIFY(dataDeviceManagerSpy.wait());
QScopedPointer<DataDeviceManager> ddm(registry.createDataDeviceManager(dataDeviceManagerSpy.first().first().value<quint32>(),
dataDeviceManagerSpy.first().last().value<quint32>()));
QVERIFY(ddm->isValid());
QScopedPointer<DataDevice> dd1(ddm->getDataDevice(m_seat));
QVERIFY(dd1->isValid());
QSignalSpy selectionSpy(dd1.data(), SIGNAL(selectionOffered(KWayland::Client::DataOffer*)));
QVERIFY(selectionSpy.isValid());
QSignalSpy selectionClearedSpy(dd1.data(), SIGNAL(selectionCleared()));
QVERIFY(selectionClearedSpy.isValid());
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surface->isValid());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
[server] Add support for setting the clipboard selection DataDeviceInterface manually Summary: So far SeatInterface handled automatically which DataDeviceInterface holds the current clipboard selection. While this works fine and is correct it doesn't support use cases like a clipboard manager where the clipboard is hold by a different ClientConnection than the one from the focused keyboard. This change allows to manually set the selected DataDeviceInterface to override the automatic selection, though the automatic selection is still in place. Thus the next update of a selection will override the manually set selection again. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D1972
2016-06-21 09:14:46 +00:00
QVERIFY(!m_seatInterface->selection());
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedKeyboard());
[server] Properly send a selection clear prior to keyboard focus enter Summary: When setting the keyboard focus the server needs also to send the current selection to the client. So far KWayland only sent the selection if it was set. That is if the last focused client cleared the selection it was not updated and the client might have had an outdated selection. To prevent this situation the server now explicitly sends the clear to the client on enter if there is no selection. Also if the selection is cleared, the SeatInterface now unsets it's current selection to make sure that the next focused keyboard will get the clear selection sent. Test Plan: Existing test case adjusted and a new test case added which simulates the interaction of two clients. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2091
2016-07-05 08:56:22 +00:00
QVERIFY(selectionClearedSpy.wait());
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
QVERIFY(selectionSpy.isEmpty());
[server] Properly send a selection clear prior to keyboard focus enter Summary: When setting the keyboard focus the server needs also to send the current selection to the client. So far KWayland only sent the selection if it was set. That is if the last focused client cleared the selection it was not updated and the client might have had an outdated selection. To prevent this situation the server now explicitly sends the clear to the client on enter if there is no selection. Also if the selection is cleared, the SeatInterface now unsets it's current selection to make sure that the next focused keyboard will get the clear selection sent. Test Plan: Existing test case adjusted and a new test case added which simulates the interaction of two clients. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2091
2016-07-05 08:56:22 +00:00
QVERIFY(!selectionClearedSpy.isEmpty());
selectionClearedSpy.clear();
[server] Add support for setting the clipboard selection DataDeviceInterface manually Summary: So far SeatInterface handled automatically which DataDeviceInterface holds the current clipboard selection. While this works fine and is correct it doesn't support use cases like a clipboard manager where the clipboard is hold by a different ClientConnection than the one from the focused keyboard. This change allows to manually set the selected DataDeviceInterface to override the automatic selection, though the automatic selection is still in place. Thus the next update of a selection will override the manually set selection again. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D1972
2016-06-21 09:14:46 +00:00
QVERIFY(!m_seatInterface->selection());
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
// now let's try to set a selection - we have keyboard focus, so it should be sent to us
QScopedPointer<DataSource> ds(ddm->createDataSource());
QVERIFY(ds->isValid());
ds->offer(QStringLiteral("text/plain"));
dd1->setSelection(0, ds.data());
QVERIFY(selectionSpy.wait());
QCOMPARE(selectionSpy.count(), 1);
[server] Add support for setting the clipboard selection DataDeviceInterface manually Summary: So far SeatInterface handled automatically which DataDeviceInterface holds the current clipboard selection. While this works fine and is correct it doesn't support use cases like a clipboard manager where the clipboard is hold by a different ClientConnection than the one from the focused keyboard. This change allows to manually set the selected DataDeviceInterface to override the automatic selection, though the automatic selection is still in place. Thus the next update of a selection will override the manually set selection again. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D1972
2016-06-21 09:14:46 +00:00
auto ddi = m_seatInterface->selection();
QVERIFY(ddi);
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
auto df = selectionSpy.first().first().value<DataOffer*>();
QCOMPARE(df->offeredMimeTypes().count(), 1);
QCOMPARE(df->offeredMimeTypes().first().name(), QStringLiteral("text/plain"));
// try to clear
dd1->setSelection(0);
QVERIFY(selectionClearedSpy.wait());
QCOMPARE(selectionClearedSpy.count(), 1);
QCOMPARE(selectionSpy.count(), 1);
// unset the keyboard focus
m_seatInterface->setFocusedKeyboardSurface(nullptr);
QVERIFY(!m_seatInterface->focusedKeyboardSurface());
QVERIFY(!m_seatInterface->focusedKeyboard());
serverSurface->client()->flush();
QCoreApplication::processEvents();
QCoreApplication::processEvents();
// try to set Selection
dd1->setSelection(0, ds.data());
wl_display_flush(m_connection->display());
QCoreApplication::processEvents();
QCoreApplication::processEvents();
QCOMPARE(selectionSpy.count(), 1);
[server] Add support for setting the clipboard selection DataDeviceInterface manually Summary: So far SeatInterface handled automatically which DataDeviceInterface holds the current clipboard selection. While this works fine and is correct it doesn't support use cases like a clipboard manager where the clipboard is hold by a different ClientConnection than the one from the focused keyboard. This change allows to manually set the selected DataDeviceInterface to override the automatic selection, though the automatic selection is still in place. Thus the next update of a selection will override the manually set selection again. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D1972
2016-06-21 09:14:46 +00:00
// let's unset the selection on the seat
m_seatInterface->setSelection(nullptr);
// and pass focus back on our surface
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
// we don't have a selection, so it should not send a selection
QVERIFY(!selectionSpy.wait(100));
// now let's set it manually
m_seatInterface->setSelection(ddi);
QCOMPARE(m_seatInterface->selection(), ddi);
QVERIFY(selectionSpy.wait());
QCOMPARE(selectionSpy.count(), 2);
[autotests] Extend test case for SeatInterface::setSelection Verifies the condition that the currentSelection is the same as the DataDeviceInterface passed to setSelection.
2016-06-28 12:57:42 +00:00
// setting the same again should not change
m_seatInterface->setSelection(ddi);
QVERIFY(!selectionSpy.wait(100));
Fix minor EBN issues
2018-09-12 17:49:38 +00:00
// now clear it manually
[server] Add support for setting the clipboard selection DataDeviceInterface manually Summary: So far SeatInterface handled automatically which DataDeviceInterface holds the current clipboard selection. While this works fine and is correct it doesn't support use cases like a clipboard manager where the clipboard is hold by a different ClientConnection than the one from the focused keyboard. This change allows to manually set the selected DataDeviceInterface to override the automatic selection, though the automatic selection is still in place. Thus the next update of a selection will override the manually set selection again. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D1972
2016-06-21 09:14:46 +00:00
m_seatInterface->setSelection(nullptr);
QVERIFY(selectionClearedSpy.wait());
[autotests] Extend test case for SeatInterface::setSelection Verifies the condition that the currentSelection is the same as the DataDeviceInterface passed to setSelection.
2016-06-28 12:57:42 +00:00
QCOMPARE(selectionSpy.count(), 2);
[server] Cancel previous selection from SeatInterface::setSelection Summary: When changing the selection the previous selection needs to be cancelled. This is already done in the "normal" updating of the selection. If the previous selection doesn't get cancelled QtWayland is not able to accept anything new from the clipboard. The setSelection didn't cancel it yet, due to that copy from Xwayland to QtWayland windows doesn't work in KWin as KWin uses the setSelection call for the Xwayland clipboard. With this change the cancelling of previous selection is moved into a dedicated method and called from the normal way and the setSelection way. Reviewers: #plasma_on_wayland, bshah Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2997
2016-10-10 08:43:15 +00:00
// create a second ddi and a data source
QScopedPointer<DataDevice> dd2(ddm->getDataDevice(m_seat));
QVERIFY(dd2->isValid());
QScopedPointer<DataSource> ds2(ddm->createDataSource());
QVERIFY(ds2->isValid());
ds2->offer(QStringLiteral("text/plain"));
dd2->setSelection(0, ds2.data());
QVERIFY(selectionSpy.wait());
QSignalSpy cancelledSpy(ds2.data(), &DataSource::cancelled);
QVERIFY(cancelledSpy.isValid());
m_seatInterface->setSelection(ddi);
QVERIFY(cancelledSpy.wait());
Avoid sending data offers from an invalid source. Summary: A DataDevice will have a source when offers are available, but it can also be legitimately cleared. When calling DataDeviceInterface::sendSelection(DataDeviceInterface *other) if the other data device has no source, we should be setting that we also have no source. In addition this also guards against Seat tracking a DataDeviceInterface with no source when trying to sync x clipboards. BUG: 383054 Reviewers: #plasma Subscribers: graesslin, plasma-devel, #frameworks Tags: #plasma_on_wayland, #frameworks Differential Revision: https://phabricator.kde.org/D7316
2017-08-15 23:16:57 +00:00
// Copy already cleared selection, BUG 383054
ddi->sendSelection(ddi);
Handle DataDeviceInterface selection in SeatInterface The selection is supposed to be sent to the DataDeviceInterface just before getting keyboard focus. In order to do that the SeatInterface keeps track of the DataDeviceInterface which is the current selection and the DataDeviceInterface of the focused keyboard client. SeatInterface friends DataDeviceManagerInterface so that the latter can register each created DataDevice for the SeatInterface.
2014-11-27 12:38:24 +00:00
}
[server] Ensure we have a DataSource on the DataDevice in setSelection Summary: SeatInterface provides a way to set the current selection. This method did not verify whether the new DataDeviceInterface actually has a DataSourceInterface. If there is no DataSourceInterface on that DataDeviceInterface the selection should not be sent to the current selection owner. This results in a crash as DataOfferInterface (correctly) doesn't expect the passed in DataSourceInterface to be null. To ensure we don't hit this again the DataOfferInterface ctor gained an Q_ASSERT to validate the DataSourceInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3148
2016-10-24 08:04:33 +00:00
void TestWaylandSeat::testSelectionNoDataSource()
{
// this test verifies that the server doesn't crash when using setSelection with
// a DataDevice which doesn't have a DataSource yet
using namespace KWayland::Client;
using namespace KWayland::Server;
// first create the DataDevice
QScopedPointer<DataDeviceManagerInterface> ddmi(m_display->createDataDeviceManager());
ddmi->create();
QSignalSpy ddiCreatedSpy(ddmi.data(), &DataDeviceManagerInterface::dataDeviceCreated);
QVERIFY(ddiCreatedSpy.isValid());
Registry registry;
QSignalSpy dataDeviceManagerSpy(&registry, &Registry::dataDeviceManagerAnnounced);
QVERIFY(dataDeviceManagerSpy.isValid());
registry.setEventQueue(m_queue);
registry.create(m_connection->display());
QVERIFY(registry.isValid());
registry.setup();
QVERIFY(dataDeviceManagerSpy.wait());
QScopedPointer<DataDeviceManager> ddm(registry.createDataDeviceManager(dataDeviceManagerSpy.first().first().value<quint32>(),
dataDeviceManagerSpy.first().last().value<quint32>()));
QVERIFY(ddm->isValid());
QScopedPointer<DataDevice> dd(ddm->getDataDevice(m_seat));
QVERIFY(dd->isValid());
QVERIFY(ddiCreatedSpy.wait());
auto ddi = ddiCreatedSpy.first().first().value<DataDeviceInterface*>();
QVERIFY(ddi);
// now create a surface and pass it keyboard focus
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surface->isValid());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
QVERIFY(!m_seatInterface->selection());
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
// now let's set the selection
m_seatInterface->setSelection(ddi);
}
[server] Fix possible crash on creation of DataDevice Summary: This is a similar condition as D3148. If a DataDeviceInterface is created for the currently focused keyboard Surface the current selection is sent to the new DataDeviceInterface. If the current selection does not have a DataSourceInterface a DataOfferInterface for a null DataSourceInterface would be created and result in a crash. This change verifies that there is a DataSourcInterface on the current selection prior to sending out the selection. Test Plan: A test case is added which simulates the condition by using two clients. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3149
2016-10-24 09:05:04 +00:00
void TestWaylandSeat::testDataDeviceForKeyboardSurface()
{
// this test verifies that the server does not crash when creating a datadevice for the focused keyboard surface
// and the currentSelection does not have a DataSource.
// to properly test the functionality this test requires a second client
using namespace KWayland::Client;
using namespace KWayland::Server;
// create the DataDeviceManager
QScopedPointer<DataDeviceManagerInterface> ddmi(m_display->createDataDeviceManager());
ddmi->create();
QSignalSpy ddiCreatedSpy(ddmi.data(), &DataDeviceManagerInterface::dataDeviceCreated);
QVERIFY(ddiCreatedSpy.isValid());
// create a second Wayland client connection to use it for setSelection
auto c = new ConnectionThread;
QSignalSpy connectedSpy(c, &ConnectionThread::connected);
QVERIFY(connectedSpy.isValid());
c->setSocketName(s_socketName);
auto thread = new QThread(this);
c->moveToThread(thread);
thread->start();
c->initConnection();
QVERIFY(connectedSpy.wait());
QScopedPointer<EventQueue> queue(new EventQueue);
queue->setup(c);
QScopedPointer<Registry> registry(new Registry);
QSignalSpy interfacesAnnouncedSpy(registry.data(), &Registry::interfacesAnnounced);
QVERIFY(interfacesAnnouncedSpy.isValid());
registry->setEventQueue(queue.data());
registry->create(c);
QVERIFY(registry->isValid());
registry->setup();
QVERIFY(interfacesAnnouncedSpy.wait());
QScopedPointer<Seat> seat(registry->createSeat(registry->interface(Registry::Interface::Seat).name,
registry->interface(Registry::Interface::Seat).version));
QVERIFY(seat->isValid());
QScopedPointer<DataDeviceManager> ddm1(registry->createDataDeviceManager(registry->interface(Registry::Interface::DataDeviceManager).name,
registry->interface(Registry::Interface::DataDeviceManager).version));
QVERIFY(ddm1->isValid());
// now create our first datadevice
QScopedPointer<DataDevice> dd1(ddm1->getDataDevice(seat.data()));
QVERIFY(ddiCreatedSpy.wait());
auto ddi = ddiCreatedSpy.first().first().value<DataDeviceInterface*>();
QVERIFY(ddi);
m_seatInterface->setSelection(ddi);
// switch to other client
// create a surface and pass it keyboard focus
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> surface(m_compositor->createSurface());
QVERIFY(surface->isValid());
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface*>();
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
QCOMPARE(m_seatInterface->focusedKeyboardSurface(), serverSurface);
// now create a DataDevice
Registry registry2;
QSignalSpy dataDeviceManagerSpy(&registry2, &Registry::dataDeviceManagerAnnounced);
QVERIFY(dataDeviceManagerSpy.isValid());
registry2.setEventQueue(m_queue);
registry2.create(m_connection->display());
QVERIFY(registry2.isValid());
registry2.setup();
QVERIFY(dataDeviceManagerSpy.wait());
QScopedPointer<DataDeviceManager> ddm(registry2.createDataDeviceManager(dataDeviceManagerSpy.first().first().value<quint32>(),
dataDeviceManagerSpy.first().last().value<quint32>()));
QVERIFY(ddm->isValid());
QScopedPointer<DataDevice> dd(ddm->getDataDevice(m_seat));
QVERIFY(dd->isValid());
QVERIFY(ddiCreatedSpy.wait());
[server] Fix crash on updating focused keyboard surface Summary: In case the current selection does not have a DataSourceInterface updating the focused keyboard surface resulted in a crash. The current selection is sent to the DataDeviceInterface of the newly focused client and thus a DataOfferInterface would be created for a null DataSourceInterface. This is a similar fix as D3148 and D3149. Test Plan: Test case added which used to crash before Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3150
2016-10-24 09:17:36 +00:00
// unset surface and set again
m_seatInterface->setFocusedKeyboardSurface(nullptr);
m_seatInterface->setFocusedKeyboardSurface(serverSurface);
[server] Fix possible crash on creation of DataDevice Summary: This is a similar condition as D3148. If a DataDeviceInterface is created for the currently focused keyboard Surface the current selection is sent to the new DataDeviceInterface. If the current selection does not have a DataSourceInterface a DataOfferInterface for a null DataSourceInterface would be created and result in a crash. This change verifies that there is a DataSourcInterface on the current selection prior to sending out the selection. Test Plan: A test case is added which simulates the condition by using two clients. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3149
2016-10-24 09:05:04 +00:00
// and delete the connection thread again
dd1.reset();
ddm1.reset();
seat.reset();
registry.reset();
queue.reset();
c->deleteLater();
thread->quit();
thread->wait();
delete thread;
}
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
void TestWaylandSeat::testTouch()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy touchSpy(m_seat, SIGNAL(hasTouchChanged(bool)));
QVERIFY(touchSpy.isValid());
m_seatInterface->setHasTouch(true);
QVERIFY(touchSpy.wait());
// create the surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, SIGNAL(surfaceCreated(KWayland::Server::SurfaceInterface*)));
QVERIFY(surfaceCreatedSpy.isValid());
Surface *s = m_compositor->createSurface(m_compositor);
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
m_seatInterface->setFocusedTouchSurface(serverSurface);
// no keyboard yet
QCOMPARE(m_seatInterface->focusedTouchSurface(), serverSurface);
QVERIFY(!m_seatInterface->focusedTouch());
QSignalSpy touchCreatedSpy(m_seatInterface, SIGNAL(touchCreated(KWayland::Server::TouchInterface*)));
QVERIFY(touchCreatedSpy.isValid());
Touch *touch = m_seat->createTouch(m_seat);
QVERIFY(touch->isValid());
QVERIFY(touchCreatedSpy.wait());
Properly handle release of a touch resource Summary: On client side use wl_touch_release to get into the proper destroy handler on server side. There the shared destroy implementation is used. The test case is extended to verify the condition and ensure that our code doesn't crash in case SeatInterface calls into the already unbound TouchInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2035
2016-06-28 14:15:46 +00:00
auto serverTouch = m_seatInterface->focusedTouch();
QVERIFY(serverTouch);
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
QCOMPARE(touchCreatedSpy.first().first().value<KWayland::Server::TouchInterface*>(), m_seatInterface->focusedTouch());
QSignalSpy sequenceStartedSpy(touch, SIGNAL(sequenceStarted(KWayland::Client::TouchPoint*)));
QVERIFY(sequenceStartedSpy.isValid());
QSignalSpy sequenceEndedSpy(touch, SIGNAL(sequenceEnded()));
QVERIFY(sequenceEndedSpy.isValid());
QSignalSpy sequenceCanceledSpy(touch, SIGNAL(sequenceCanceled()));
QVERIFY(sequenceCanceledSpy.isValid());
QSignalSpy frameEndedSpy(touch, SIGNAL(frameEnded()));
QVERIFY(frameEndedSpy.isValid());
QSignalSpy pointAddedSpy(touch, SIGNAL(pointAdded(KWayland::Client::TouchPoint*)));
QVERIFY(pointAddedSpy.isValid());
QSignalSpy pointMovedSpy(touch, SIGNAL(pointMoved(KWayland::Client::TouchPoint*)));
QVERIFY(pointMovedSpy.isValid());
QSignalSpy pointRemovedSpy(touch, SIGNAL(pointRemoved(KWayland::Client::TouchPoint*)));
QVERIFY(pointRemovedSpy.isValid());
// try a few things
m_seatInterface->setFocusedTouchSurfacePosition(QPointF(10, 20));
QCOMPARE(m_seatInterface->focusedTouchSurfacePosition(), QPointF(10, 20));
m_seatInterface->setTimestamp(1);
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 0);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(sequenceEndedSpy.count(), 0);
QCOMPARE(sequenceCanceledSpy.count(), 0);
QCOMPARE(frameEndedSpy.count(), 0);
QCOMPARE(pointAddedSpy.count(), 0);
QCOMPARE(pointMovedSpy.count(), 0);
QCOMPARE(pointRemovedSpy.count(), 0);
TouchPoint *tp = sequenceStartedSpy.first().first().value<TouchPoint*>();
QVERIFY(tp);
QCOMPARE(tp->downSerial(), m_seatInterface->display()->serial());
QCOMPARE(tp->id(), 0);
QVERIFY(tp->isDown());
QCOMPARE(tp->position(), QPointF(5, 6));
QCOMPARE(tp->positions().size(), 1);
QCOMPARE(tp->time(), 1u);
QCOMPARE(tp->timestamps().count(), 1);
QCOMPARE(tp->upSerial(), 0u);
QCOMPARE(tp->surface().data(), s);
QCOMPARE(touch->sequence().count(), 1);
QCOMPARE(touch->sequence().first(), tp);
// let's end the frame
m_seatInterface->touchFrame();
QVERIFY(frameEndedSpy.wait());
QCOMPARE(frameEndedSpy.count(), 1);
// move the one point
m_seatInterface->setTimestamp(2);
m_seatInterface->touchMove(0, QPointF(10, 20));
m_seatInterface->touchFrame();
QVERIFY(frameEndedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(sequenceEndedSpy.count(), 0);
QCOMPARE(sequenceCanceledSpy.count(), 0);
QCOMPARE(frameEndedSpy.count(), 2);
QCOMPARE(pointAddedSpy.count(), 0);
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.count(), 0);
QCOMPARE(pointMovedSpy.first().first().value<TouchPoint*>(), tp);
QCOMPARE(tp->id(), 0);
QVERIFY(tp->isDown());
QCOMPARE(tp->position(), QPointF(0, 0));
QCOMPARE(tp->positions().size(), 2);
QCOMPARE(tp->time(), 2u);
QCOMPARE(tp->timestamps().count(), 2);
QCOMPARE(tp->upSerial(), 0u);
QCOMPARE(tp->surface().data(), s);
// add onther point
m_seatInterface->setTimestamp(3);
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 1);
m_seatInterface->touchFrame();
QVERIFY(frameEndedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(sequenceEndedSpy.count(), 0);
QCOMPARE(sequenceCanceledSpy.count(), 0);
QCOMPARE(frameEndedSpy.count(), 3);
QCOMPARE(pointAddedSpy.count(), 1);
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.count(), 0);
QCOMPARE(touch->sequence().count(), 2);
QCOMPARE(touch->sequence().first(), tp);
TouchPoint *tp2 = pointAddedSpy.first().first().value<TouchPoint*>();
QVERIFY(tp2);
QCOMPARE(touch->sequence().last(), tp2);
QCOMPARE(tp2->id(), 1);
QVERIFY(tp2->isDown());
QCOMPARE(tp2->position(), QPointF(5, 6));
QCOMPARE(tp2->positions().size(), 1);
QCOMPARE(tp2->time(), 3u);
QCOMPARE(tp2->timestamps().count(), 1);
QCOMPARE(tp2->upSerial(), 0u);
QCOMPARE(tp2->surface().data(), s);
// send it an up
m_seatInterface->setTimestamp(4);
m_seatInterface->touchUp(1);
m_seatInterface->touchFrame();
QVERIFY(frameEndedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(sequenceEndedSpy.count(), 0);
QCOMPARE(sequenceCanceledSpy.count(), 0);
QCOMPARE(frameEndedSpy.count(), 4);
QCOMPARE(pointAddedSpy.count(), 1);
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.first().first().value<TouchPoint*>(), tp2);
QCOMPARE(tp2->id(), 1);
QVERIFY(!tp2->isDown());
QCOMPARE(tp2->position(), QPointF(5, 6));
QCOMPARE(tp2->positions().size(), 1);
QCOMPARE(tp2->time(), 4u);
QCOMPARE(tp2->timestamps().count(), 2);
QCOMPARE(tp2->upSerial(), m_seatInterface->display()->serial());
QCOMPARE(tp2->surface().data(), s);
// send another down and up
m_seatInterface->setTimestamp(5);
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 1);
m_seatInterface->touchFrame();
m_seatInterface->setTimestamp(6);
m_seatInterface->touchUp(1);
// and send an up for the first point
m_seatInterface->touchUp(0);
m_seatInterface->touchFrame();
QVERIFY(frameEndedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
QCOMPARE(sequenceEndedSpy.count(), 1);
QCOMPARE(sequenceCanceledSpy.count(), 0);
QCOMPARE(frameEndedSpy.count(), 6);
QCOMPARE(pointAddedSpy.count(), 2);
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.count(), 3);
QCOMPARE(touch->sequence().count(), 3);
QVERIFY(!touch->sequence().at(0)->isDown());
QVERIFY(!touch->sequence().at(1)->isDown());
QVERIFY(!touch->sequence().at(2)->isDown());
QVERIFY(!m_seatInterface->isTouchSequence());
// try cancel
Fix unused variable warnings Thanks CI system for reporting them.
2015-03-25 12:46:29 +00:00
m_seatInterface->setFocusedTouchSurface(serverSurface, QPointF(15, 26));
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
m_seatInterface->setTimestamp(7);
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 0);
m_seatInterface->touchFrame();
m_seatInterface->cancelTouchSequence();
QVERIFY(sequenceCanceledSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 2);
QCOMPARE(sequenceEndedSpy.count(), 1);
QCOMPARE(sequenceCanceledSpy.count(), 1);
QCOMPARE(frameEndedSpy.count(), 7);
QCOMPARE(pointAddedSpy.count(), 2);
QCOMPARE(pointMovedSpy.count(), 1);
QCOMPARE(pointRemovedSpy.count(), 3);
Fix unused variable warnings Thanks CI system for reporting them.
2015-03-25 12:46:29 +00:00
QCOMPARE(touch->sequence().first()->position(), QPointF(0, 0));
Properly handle release of a touch resource Summary: On client side use wl_touch_release to get into the proper destroy handler on server side. There the shared destroy implementation is used. The test case is extended to verify the condition and ensure that our code doesn't crash in case SeatInterface calls into the already unbound TouchInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2035
2016-06-28 14:15:46 +00:00
// destroy touch on client side
QSignalSpy unboundSpy(serverTouch, &TouchInterface::unbound);
QVERIFY(unboundSpy.isValid());
QSignalSpy destroyedSpy(serverTouch, &TouchInterface::destroyed);
QVERIFY(destroyedSpy.isValid());
delete touch;
QVERIFY(unboundSpy.wait());
QCOMPARE(unboundSpy.count(), 1);
QCOMPARE(destroyedSpy.count(), 0);
QVERIFY(!serverTouch->resource());
Fix minor EBN issues
2018-09-06 19:24:21 +00:00
// try to call into all the methods of the touch interface, should not crash
Properly handle release of a touch resource Summary: On client side use wl_touch_release to get into the proper destroy handler on server side. There the shared destroy implementation is used. The test case is extended to verify the condition and ensure that our code doesn't crash in case SeatInterface calls into the already unbound TouchInterface. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2035
2016-06-28 14:15:46 +00:00
QCOMPARE(m_seatInterface->focusedTouch(), serverTouch);
m_seatInterface->setTimestamp(8);
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 0);
m_seatInterface->touchFrame();
m_seatInterface->touchMove(0, QPointF(0, 0));
QCOMPARE(m_seatInterface->touchDown(QPointF(15, 26)), 1);
m_seatInterface->cancelTouchSequence();
QVERIFY(destroyedSpy.wait());
QCOMPARE(destroyedSpy.count(), 1);
// should have unset the focused touch
QVERIFY(!m_seatInterface->focusedTouch());
// but not the focused touch surface
QCOMPARE(m_seatInterface->focusedTouchSurface(), serverSurface);
[server] Add support for touch events in SeatInterface
2015-03-25 12:31:38 +00:00
}
[server] Improve the handling when clients disconnect Summary: So far the server component performed manual cleanup in some cases when a client disconnects. But this is not needed: the Wayland library calls the static unbind methods which do cleanup. If we cleanup ourselves this can result in double deletes in the worst case, so let's only use the Wayland functionality. Adjusted: * RegionInterface * SurfaceInterface * ShellSurfaceInterface (doesn't take a parent anymore) * DpmsInterface * QtSurfaceExtensionInterface * KeyboardInterface * PointerInterface * TouchInterface * DataOfferInterface * PlasmaShellSurfaceInterface For each adjusted case a test case is added to verify that the cleanup works. Exceptions are DpmsInterface as the actual Resource is not exposed at all in the Server component and DataOfferInterface as that is server side created. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma Differential Revision: https://phabricator.kde.org/D1640
2016-05-19 13:17:07 +00:00
void TestWaylandSeat::testDisconnect()
{
// this test verifies that disconnecting the client cleans up correctly
using namespace KWayland::Client;
using namespace KWayland::Server;
QSignalSpy keyboardCreatedSpy(m_seatInterface, &SeatInterface::keyboardCreated);
QVERIFY(keyboardCreatedSpy.isValid());
QSignalSpy pointerCreatedSpy(m_seatInterface, &SeatInterface::pointerCreated);
QVERIFY(pointerCreatedSpy.isValid());
QSignalSpy touchCreatedSpy(m_seatInterface, &SeatInterface::touchCreated);
QVERIFY(touchCreatedSpy.isValid());
// create the things we need
m_seatInterface->setHasKeyboard(true);
m_seatInterface->setHasPointer(true);
m_seatInterface->setHasTouch(true);
QSignalSpy touchSpy(m_seat, &Seat::hasTouchChanged);
QVERIFY(touchSpy.isValid());
QVERIFY(touchSpy.wait());
QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
QVERIFY(!keyboard.isNull());
QVERIFY(keyboardCreatedSpy.wait());
auto serverKeyboard = keyboardCreatedSpy.first().first().value<KeyboardInterface*>();
QVERIFY(serverKeyboard);
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(!pointer.isNull());
QVERIFY(pointerCreatedSpy.wait());
auto serverPointer = pointerCreatedSpy.first().first().value<PointerInterface*>();
QVERIFY(serverPointer);
QScopedPointer<Touch> touch(m_seat->createTouch());
QVERIFY(!touch.isNull());
QVERIFY(touchCreatedSpy.wait());
auto serverTouch = touchCreatedSpy.first().first().value<TouchInterface*>();
QVERIFY(serverTouch);
// setup destroys
QSignalSpy keyboardDestroyedSpy(serverKeyboard, &QObject::destroyed);
QVERIFY(keyboardDestroyedSpy.isValid());
QSignalSpy pointerDestroyedSpy(serverPointer, &QObject::destroyed);
QVERIFY(pointerDestroyedSpy.isValid());
QSignalSpy touchDestroyedSpy(serverTouch, &QObject::destroyed);
QVERIFY(touchDestroyedSpy.isValid());
QSignalSpy clientDisconnectedSpy(serverKeyboard->client(), &ClientConnection::disconnected);
QVERIFY(clientDisconnectedSpy.isValid());
if (m_connection) {
m_connection->deleteLater();
m_connection = nullptr;
}
QVERIFY(clientDisconnectedSpy.wait());
QCOMPARE(clientDisconnectedSpy.count(), 1);
QCOMPARE(keyboardDestroyedSpy.count(), 0);
QCOMPARE(pointerDestroyedSpy.count(), 0);
QCOMPARE(touchDestroyedSpy.count(), 0);
QVERIFY(keyboardDestroyedSpy.wait());
QCOMPARE(keyboardDestroyedSpy.count(), 1);
QCOMPARE(pointerDestroyedSpy.count(), 1);
QCOMPARE(touchDestroyedSpy.count(), 1);
keyboard->destroy();
pointer->destroy();
touch->destroy();
Fix heap-use-after-free in TestWaylandSeat::testDisconnect
2016-10-11 06:37:55 +00:00
m_relativePointerManager->destroy();
Implementation of PointerGestures protocol Summary: Pointer gestures are created for a pointer and there are two types of gestures: swipe and pinch. At a given time there can only be one active gesture. The implementation in SeatInterface ensures that there can only be one active gesture. Each gesture consists of a start event, 0 to multiple update events and an end event. The end can also be a cancel. To better support this the implementation doesn't follow the protocol and splits end and cancel into dedicated methods in the server side and into dedicated signals in the client side. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D3169
2016-10-26 08:27:14 +00:00
m_pointerGestures->destroy();
[server] Improve the handling when clients disconnect Summary: So far the server component performed manual cleanup in some cases when a client disconnects. But this is not needed: the Wayland library calls the static unbind methods which do cleanup. If we cleanup ourselves this can result in double deletes in the worst case, so let's only use the Wayland functionality. Adjusted: * RegionInterface * SurfaceInterface * ShellSurfaceInterface (doesn't take a parent anymore) * DpmsInterface * QtSurfaceExtensionInterface * KeyboardInterface * PointerInterface * TouchInterface * DataOfferInterface * PlasmaShellSurfaceInterface For each adjusted case a test case is added to verify that the cleanup works. Exceptions are DpmsInterface as the actual Resource is not exposed at all in the Server component and DataOfferInterface as that is server side created. Reviewers: #plasma Subscribers: plasma-devel Tags: #plasma Differential Revision: https://phabricator.kde.org/D1640
2016-05-19 13:17:07 +00:00
m_compositor->destroy();
m_seat->destroy();
m_shm->destroy();
m_subCompositor->destroy();
m_queue->destroy();
}
[src/server] Verify that surface has a resource before sending pointer enter Summary: If we try to send a pointer enter on a null resource of a Surface (e.g. after unbound) we hit a marshalling error: error marshalling arguments for enter (signature uoff): null value passed for arg 1 The added test case hits this error without the change and passes cleanly with the change. Reviewers: #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D2159
2016-07-14 09:45:38 +00:00
void TestWaylandSeat::testPointerEnterOnUnboundSurface()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
// create the things we need
m_seatInterface->setHasKeyboard(true);
m_seatInterface->setHasPointer(true);
m_seatInterface->setHasTouch(true);
QSignalSpy pointerChangedSpy(m_seat, &Seat::hasPointerChanged);
QVERIFY(pointerChangedSpy.isValid());
QVERIFY(pointerChangedSpy.wait());
// create pointer and Surface
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(!pointer.isNull());
// create the surface
QSignalSpy surfaceCreatedSpy(m_compositorInterface, &CompositorInterface::surfaceCreated);
QVERIFY(surfaceCreatedSpy.isValid());
QScopedPointer<Surface> s(m_compositor->createSurface());
QVERIFY(surfaceCreatedSpy.wait());
SurfaceInterface *serverSurface = surfaceCreatedSpy.first().first().value<KWayland::Server::SurfaceInterface*>();
QVERIFY(serverSurface);
// unbind the surface again
QSignalSpy surfaceUnboundSpy(serverSurface, &SurfaceInterface::unbound);
QVERIFY(surfaceUnboundSpy.isValid());
s.reset();
QVERIFY(surfaceUnboundSpy.wait());
QSignalSpy clientErrorSpy(m_connection, &ConnectionThread::errorOccurred);
QVERIFY(clientErrorSpy.isValid());
m_seatInterface->setFocusedPointerSurface(serverSurface);
QVERIFY(!clientErrorSpy.wait(100));
}
Pass a dedicated fd to each keyboard for the xkb keymap Summary: To better isolate the clients from each other eachh KeyboardInterface creates it's own dedicated temporary file and sends the fd for this temporary file to the client. This means the memory for the keymap is no longer shared between all clients, every client has an own copy. To support this the existing API to set the keymap is deprecated and replaced by a new method setKeymapData which takes the content of the keymap as a byte array. The now deprecated method which takes a file descriptor is changed to use the new setKeymapData method. For that it reads the content of the file. The implementation in KeyboardInterface to create the file descriptor is based on the implementation of KWin. As I implemented the change in KWin (see 3b4c508ee36ac74c37e77fcaa14d106397ad2994) it is not a problem from GPL vs LGPL perspective. The change includes test cases to verify that the content of the keymap is properly passed to the client and that the memory is no longer shared. BUG: 381674 Reviewers: #kwin, #frameworks, davidedmundson, zzag Reviewed By: #kwin, zzag Subscribers: plasma-devel, kde-frameworks-devel Tags: #frameworks Differential Revision: https://phabricator.kde.org/D14910
2020-03-19 13:58:52 +00:00
void TestWaylandSeat::testKeymap()
{
using namespace KWayland::Client;
using namespace KWayland::Server;
m_seatInterface->setHasKeyboard(true);
QSignalSpy keyboardChangedSpy(m_seat, &Seat::hasKeyboardChanged);
QVERIFY(keyboardChangedSpy.isValid());
QVERIFY(keyboardChangedSpy.wait());
QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
QSignalSpy keymapChangedSpy(keyboard.data(), &Keyboard::keymapChanged);
QVERIFY(keymapChangedSpy.isValid());
m_seatInterface->setKeymapData(QByteArrayLiteral("foo"));
QVERIFY(keymapChangedSpy.wait());
int fd = keymapChangedSpy.first().first().toInt();
QVERIFY(fd != -1);
QCOMPARE(keymapChangedSpy.first().last().value<quint32>(), 3u);
QFile file;
QVERIFY(file.open(fd, QIODevice::ReadOnly));
const char *address = reinterpret_cast<char*>(file.map(0, keymapChangedSpy.first().last().value<quint32>()));
QVERIFY(address);
QCOMPARE(qstrcmp(address, "foo"), 0);
file.close();
// change the keymap
keymapChangedSpy.clear();
m_seatInterface->setKeymapData(QByteArrayLiteral("bar"));
QVERIFY(keymapChangedSpy.wait());
fd = keymapChangedSpy.first().first().toInt();
QVERIFY(fd != -1);
QCOMPARE(keymapChangedSpy.first().last().value<quint32>(), 3u);
QVERIFY(file.open(fd, QIODevice::ReadWrite));address = reinterpret_cast<char*>(file.map(0, keymapChangedSpy.first().last().value<quint32>()));
QVERIFY(address);
QCOMPARE(qstrcmp(address, "bar"), 0);
}
void TestWaylandSeat::testKeymapThroughFd()
{
#if KWAYLANDSERVER_BUILD_DEPRECATED_SINCE(5, 69)
using namespace KWayland::Client;
using namespace KWayland::Server;
m_seatInterface->setHasKeyboard(true);
QSignalSpy keyboardChangedSpy(m_seat, &Seat::hasKeyboardChanged);
QVERIFY(keyboardChangedSpy.isValid());
QVERIFY(keyboardChangedSpy.wait());
QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
QSignalSpy keymapChangedSpy(keyboard.data(), &Keyboard::keymapChanged);
QVERIFY(keymapChangedSpy.isValid());
QTemporaryFile serverFile;
QVERIFY(serverFile.open());
QByteArray data = QByteArrayLiteral("foobar");
QVERIFY(serverFile.resize(data.size() + 1));
uchar *serverAddress = serverFile.map(0, data.size() + 1);
QVERIFY(serverAddress);
QVERIFY(qstrncpy(reinterpret_cast<char *>(serverAddress), data.constData(), data.size() + 1));
m_seatInterface->setKeymap(serverFile.handle(), data.size());
QVERIFY(keymapChangedSpy.wait());
int fd = keymapChangedSpy.first().first().toInt();
QVERIFY(fd != -1);
QCOMPARE(keymapChangedSpy.first().last().value<quint32>(), 6u);
QFile file;
QVERIFY(file.open(fd, QIODevice::ReadOnly));
const char *address = reinterpret_cast<char*>(file.map(0, keymapChangedSpy.first().last().value<quint32>()));
QVERIFY(address);
QCOMPARE(qstrcmp(address, "foobar"), 0);
QScopedPointer<Keyboard> keyboard2(m_seat->createKeyboard());
QSignalSpy keymapChangedSpy2(keyboard2.data(), &Keyboard::keymapChanged);
QVERIFY(keymapChangedSpy2.isValid());
QVERIFY(keymapChangedSpy2.wait());
int fd2 = keymapChangedSpy2.first().first().toInt();
QVERIFY(fd2 != -1);
QCOMPARE(keymapChangedSpy2.first().last().value<quint32>(), 6u);
QFile file2;
QVERIFY(file2.open(fd2, QIODevice::ReadWrite));
char *address2 = reinterpret_cast<char*>(file2.map(0, keymapChangedSpy2.first().last().value<quint32>()));
QVERIFY(address2);
QCOMPARE(qstrcmp(address2, "foobar"), 0);
address2[0] = 'g';
QCOMPARE(qstrcmp(address2, "goobar"), 0);
QCOMPARE(qstrcmp(address, "foobar"), 0);
#endif
}
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(TestWaylandSeat)
[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_wayland_seat.moc"
Reference in a new issue Copy permalink