yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/pointer_input.cpp

890 lines
33 KiB
C++
Raw Normal View History

[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "kwin_wayland_test.h"
Rename abstract_backend.(h|cpp) to platform.(h|cpp) Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1340
2016-04-07 07:24:17 +00:00
#include "platform.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "abstract_client.h"
#include "cursor.h"
#include "deleted.h"
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
#include "pointer_input.h"
[autotest] Validate set options in PointerInputTest::testModifierClickUnrestrictedMove Just to be sure, the code did what we wanted it to do.
2016-04-06 15:25:24 +00:00
#include "options.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "screenedge.h"
#include "screens.h"
#include "wayland_server.h"
#include "workspace.h"
#include "shell_client.h"
#include <kwineffects.h>
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/compositor.h>
#include <KWayland/Client/pointer.h>
#include <KWayland/Client/shell.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
#include <KWayland/Server/seat_interface.h>
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
#include <linux/input.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
namespace KWin
{
static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_input-0");
class PointerInputTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testWarpingUpdatesFocus();
void testWarpingGeneratesPointerMotion();
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void testUpdateFocusAfterScreenChange();
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
void testModifierClickUnrestrictedMove_data();
void testModifierClickUnrestrictedMove();
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
void testModifierScrollOpacity_data();
void testModifierScrollOpacity();
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
void testScrollAction();
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
void testFocusFollowsMouse();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
void testMouseActionInactiveWindow_data();
void testMouseActionInactiveWindow();
void testMouseActionActiveWindow_data();
void testMouseActionActiveWindow();
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
void testCursorImage();
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
void testEffectOverrideCursorImage();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
private:
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void render(KWayland::Client::Surface *surface, const QSize &size = QSize(100, 50));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
KWayland::Client::Compositor *m_compositor = nullptr;
KWayland::Client::Seat *m_seat = nullptr;
KWayland::Client::Shell *m_shell = nullptr;
};
void PointerInputTest::initTestCase()
{
qRegisterMetaType<KWin::ShellClient*>();
qRegisterMetaType<KWin::AbstractClient*>();
qRegisterMetaType<KWin::Deleted*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QMetaObject::invokeMethod(kwinApp()->platform(), "setOutputCount", Qt::DirectConnection, Q_ARG(int, 2));
Handle situation of no XDG_RUNTIME_DIR gracefully Summary: If KWin fails to start the Wayland server due to XDG_RUNTIME_DIR not being set, kwin_wayland should terminate with an error condition but not crash. This change makes sure that KWin detects that the Wayland server does not work and terminates the startup early and ensures that it doesn't crash while going down. An error message is shown that we could not create the Wayland server. Test Plan: Test case added which verifies that WaylandServer fails to init. Manual testing that kwin_wayland exits with error 1. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2078
2016-07-04 07:09:03 +00:00
QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
[autotests] Specify XCUROSR_THEME and XCURSOR_SIZE in pointer input test Try to fix test on CI system. With neither a config nor the env variables the cursor selection falls back to the default cursor theme, which might not contain the cursors we need.
2016-02-25 12:51:45 +00:00
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());
QCOMPARE(screens()->count(), 2);
QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
setenv("QT_QPA_PLATFORM", "wayland", true);
waylandServer()->initWorkspace();
}
void PointerInputTest::init()
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
QVERIFY(Test::setupWaylandConnection(s_socketName, Test::AdditionalWaylandInterface::Seat));
QVERIFY(Test::waitForWaylandPointer());
m_compositor = Test::waylandCompositor();
m_shell = Test::waylandShell();
m_seat = Test::waylandSeat();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
screens()->setCurrent(0);
Cursor::setPos(QPoint(640, 512));
}
void PointerInputTest::cleanup()
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::destroyWaylandConnection();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void PointerInputTest::render(KWayland::Client::Surface *surface, const QSize &size)
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::render(surface, size, Qt::blue);
Test::flushWaylandConnection();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
void PointerInputTest::testWarpingUpdatesFocus()
{
// this test verifies that warping the pointer creates pointer enter and leave events
using namespace KWayland::Client;
// create pointer and signal spy for enter and leave signals
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// currently there should not be a focused pointer surface
QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
QVERIFY(!pointer->enteredSurface());
// enter
Cursor::setPos(QPoint(25, 25));
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
// window should have focus
QCOMPARE(pointer->enteredSurface(), surface);
// also on the server
QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window->surface());
// and out again
Cursor::setPos(QPoint(250, 250));;
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
// there should not be a focused pointer surface anymore
QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
QVERIFY(!pointer->enteredSurface());
}
void PointerInputTest::testWarpingGeneratesPointerMotion()
{
// this test verifies that warping the pointer creates pointer motion events
using namespace KWayland::Client;
// create pointer and signal spy for enter and motion
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy movedSpy(pointer, &Pointer::motion);
QVERIFY(movedSpy.isValid());
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// enter
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(enteredSpy.wait());
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
// now warp
Cursor::setPos(QPoint(26, 26));
QVERIFY(movedSpy.wait());
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(movedSpy.count(), 1);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QCOMPARE(movedSpy.last().first().toPointF(), QPointF(26, 26));
}
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void PointerInputTest::testUpdateFocusAfterScreenChange()
{
// this test verifies that a pointer enter event is generated when the cursor changes to another
// screen due to removal of screen
using namespace KWayland::Client;
// ensure cursor is on second screen
Cursor::setPos(1500, 300);
// create pointer and signal spy for enter and motion
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(shellSurface);
render(surface, QSize(1280, 1024));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
QVERIFY(!window->geometry().contains(Cursor::pos()));
QSignalSpy screensChangedSpy(screens(), &Screens::changed);
QVERIFY(screensChangedSpy.isValid());
// now let's remove the screen containing the cursor
[autotests/integration] Fix PointerInputTest::testUpdateFocusAfterScreenChange Change the way how a screen is removed. This ensures that Xwayland doesn't die.
2016-07-20 12:42:22 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "outputGeometriesChanged",
Qt::DirectConnection,
Q_ARG(QVector<QRect>, QVector<QRect>{QRect(0, 0, 1280, 1024)}));
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(screensChangedSpy.wait());
QCOMPARE(screens()->count(), 1);
// this should have warped the cursor
QCOMPARE(Cursor::pos(), QPoint(639, 511));
QVERIFY(window->geometry().contains(Cursor::pos()));
// and we should get an enter event
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
}
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
void PointerInputTest::testModifierClickUnrestrictedMove_data()
{
QTest::addColumn<int>("modifierKey");
QTest::addColumn<int>("mouseButton");
QTest::addColumn<QString>("modKey");
const QString alt = QStringLiteral("Alt");
const QString meta = QStringLiteral("Meta");
QTest::newRow("Left Alt + Left Click") << KEY_LEFTALT << BTN_LEFT << alt;
QTest::newRow("Left Alt + Right Click") << KEY_LEFTALT << BTN_RIGHT << alt;
QTest::newRow("Left Alt + Middle Click") << KEY_LEFTALT << BTN_MIDDLE << alt;
QTest::newRow("Right Alt + Left Click") << KEY_RIGHTALT << BTN_LEFT << alt;
QTest::newRow("Right Alt + Right Click") << KEY_RIGHTALT << BTN_RIGHT << alt;
QTest::newRow("Right Alt + Middle Click") << KEY_RIGHTALT << BTN_MIDDLE << alt;
// now everything with meta
QTest::newRow("Left Meta + Left Click") << KEY_LEFTMETA << BTN_LEFT << meta;
QTest::newRow("Left Meta + Right Click") << KEY_LEFTMETA << BTN_RIGHT << meta;
QTest::newRow("Left Meta + Middle Click") << KEY_LEFTMETA << BTN_MIDDLE << meta;
QTest::newRow("Right Meta + Left Click") << KEY_RIGHTMETA << BTN_LEFT << meta;
QTest::newRow("Right Meta + Right Click") << KEY_RIGHTMETA << BTN_RIGHT << meta;
QTest::newRow("Right Meta + Middle Click") << KEY_RIGHTMETA << BTN_MIDDLE << meta;
}
void PointerInputTest::testModifierClickUnrestrictedMove()
{
// this test ensures that Alt+mouse button press triggers unrestricted move
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
// first modify the config for this run
QFETCH(QString, modKey);
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandAllKey", modKey);
group.writeEntry("CommandAll1", "Move");
group.writeEntry("CommandAll2", "Move");
group.writeEntry("CommandAll3", "Move");
group.sync();
workspace()->slotReconfigure();
[autotest] Validate set options in PointerInputTest::testModifierClickUnrestrictedMove Just to be sure, the code did what we wanted it to do.
2016-04-06 15:25:24 +00:00
QCOMPARE(options->commandAllModifier(), modKey == QStringLiteral("Alt") ? Qt::AltModifier : Qt::MetaModifier);
QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// move cursor on window
Cursor::setPos(window->geometry().center());
// simulate modifier+click
quint32 timestamp = 1;
QFETCH(int, modifierKey);
QFETCH(int, mouseButton);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(!window->isMove());
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonPressed(mouseButton, timestamp++);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(window->isMove());
// release modifier should not change it
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(window->isMove());
// but releasing the key should end move/resize
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonReleased(mouseButton, timestamp++);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(!window->isMove());
// all of that should not have triggered button events on the surface
QCOMPARE(buttonSpy.count(), 0);
// also waiting shouldn't give us the event
QVERIFY(!buttonSpy.wait(100));
}
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
void PointerInputTest::testModifierScrollOpacity_data()
{
QTest::addColumn<int>("modifierKey");
QTest::addColumn<QString>("modKey");
const QString alt = QStringLiteral("Alt");
const QString meta = QStringLiteral("Meta");
QTest::newRow("Left Alt") << KEY_LEFTALT << alt;
QTest::newRow("Right Alt") << KEY_RIGHTALT << alt;
QTest::newRow("Left Meta") << KEY_LEFTMETA << meta;
QTest::newRow("Right Meta") << KEY_RIGHTMETA << meta;
}
void PointerInputTest::testModifierScrollOpacity()
{
// this test verifies that mod+wheel performs a window operation and does not
// pass the wheel to the window
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
// first modify the config for this run
QFETCH(QString, modKey);
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandAllKey", modKey);
group.writeEntry("CommandAllWheel", "change opacity");
group.sync();
workspace()->slotReconfigure();
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// set the opacity to 0.5
window->setOpacity(0.5);
QCOMPARE(window->opacity(), 0.5);
// move cursor on window
Cursor::setPos(window->geometry().center());
// simulate modifier+wheel
quint32 timestamp = 1;
QFETCH(int, modifierKey);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
Fix scroll direction on window wheel command Experimental testing in real world showed it's just a signing issue in this specific case. The events passed to wayland clients scroll in correct direction.
2016-02-18 09:11:20 +00:00
QCOMPARE(window->opacity(), 0.6);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QCOMPARE(window->opacity(), 0.5);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
// axis should have been filtered out
QCOMPARE(axisSpy.count(), 0);
QVERIFY(!axisSpy.wait(100));
}
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
void PointerInputTest::testScrollAction()
{
// this test verifies that scroll on inactive window performs a mouse action
using namespace KWayland::Client;
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandWindowWheel", "activate and scroll");
group.sync();
workspace()->slotReconfigure();
// create two windows
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface1 = Test::createSurface(m_compositor);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(surface1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface1 = Test::createShellSurface(surface1, surface1);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(shellSurface1);
render(surface1);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window1 = workspace()->activeClient();
QVERIFY(window1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface2 = Test::createSurface(m_compositor);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(surface2);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface2 = Test::createShellSurface(surface2, surface2);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(shellSurface2);
render(surface2);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window2 = workspace()->activeClient();
QVERIFY(window2);
QVERIFY(window1 != window2);
// move cursor to the inactive window
Cursor::setPos(window1->geometry().center());
quint32 timestamp = 1;
QVERIFY(!window1->isActive());
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(window1->isActive());
// but also the wheel event should be passed to the window
QVERIFY(axisSpy.wait());
// we need to wait a little bit, otherwise the test crashes in effectshandler, needs fixing
QTest::qWait(100);
}
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
void PointerInputTest::testFocusFollowsMouse()
{
using namespace KWayland::Client;
// need to create a pointer, otherwise it doesn't accept focus
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
// move cursor out of the way of first window to be created
Cursor::setPos(900, 900);
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("AutoRaise", true);
group.writeEntry("AutoRaiseInterval", 20);
group.writeEntry("DelayFocusInterval", 200);
group.writeEntry("FocusPolicy", "FocusFollowsMouse");
group.sync();
workspace()->slotReconfigure();
// verify the settings
QCOMPARE(options->focusPolicy(), Options::FocusFollowsMouse);
QVERIFY(options->isAutoRaise());
QCOMPARE(options->autoRaiseInterval(), 20);
QCOMPARE(options->delayFocusInterval(), 200);
// create two windows
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface1 = Test::createSurface(m_compositor);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(surface1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface1 = Test::createShellSurface(surface1, surface1);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window1 = workspace()->activeClient();
QVERIFY(window1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface2 = Test::createSurface(m_compositor);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(surface2);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface2 = Test::createShellSurface(surface2, surface2);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window2 = workspace()->activeClient();
QVERIFY(window2);
QVERIFY(window1 != window2);
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
// geometry of the two windows should be overlapping
QVERIFY(window1->geometry().intersects(window2->geometry()));
// signal spies for active window changed and stacking order changed
QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
QVERIFY(activeWindowChangedSpy.isValid());
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
QVERIFY(!window1->isActive());
QVERIFY(window2->isActive());
// move on top of first window
QVERIFY(window1->geometry().contains(10, 10));
QVERIFY(!window2->geometry().contains(10, 10));
Cursor::setPos(10, 10);
QVERIFY(stackingOrderChangedSpy.wait());
QCOMPARE(stackingOrderChangedSpy.count(), 1);
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
QTRY_VERIFY(window1->isActive());
// move on second window, but move away before active window change delay hits
Cursor::setPos(810, 810);
QVERIFY(stackingOrderChangedSpy.wait());
QCOMPARE(stackingOrderChangedSpy.count(), 2);
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
Cursor::setPos(10, 10);
QVERIFY(!activeWindowChangedSpy.wait(250));
QVERIFY(window1->isActive());
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
// as we moved back on window 1 that should been raised in the mean time
QCOMPARE(stackingOrderChangedSpy.count(), 3);
// quickly move on window 2 and back on window 1 should not raise window 2
Cursor::setPos(810, 810);
Cursor::setPos(10, 10);
QVERIFY(!stackingOrderChangedSpy.wait(250));
}
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
void PointerInputTest::testMouseActionInactiveWindow_data()
{
QTest::addColumn<quint32>("button");
QTest::newRow("Left") << quint32(BTN_LEFT);
QTest::newRow("Middle") << quint32(BTN_MIDDLE);
QTest::newRow("Right") << quint32(BTN_RIGHT);
}
void PointerInputTest::testMouseActionInactiveWindow()
{
// this test performs the mouse button window action on an inactive window
// it should activate the window and raise it
using namespace KWayland::Client;
// first modify the config for this run - disable FocusFollowsMouse
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("FocusPolicy", "ClickToFocus");
group.sync();
group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandWindow1", "Activate, raise and pass click");
group.writeEntry("CommandWindow2", "Activate, raise and pass click");
group.writeEntry("CommandWindow3", "Activate, raise and pass click");
group.sync();
workspace()->slotReconfigure();
// create two windows
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface1 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface1 = Test::createShellSurface(surface1, surface1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window1 = workspace()->activeClient();
QVERIFY(window1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface2 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface2);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface2 = Test::createShellSurface(surface2, surface2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window2 = workspace()->activeClient();
QVERIFY(window2);
QVERIFY(window1 != window2);
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
// geometry of the two windows should be overlapping
QVERIFY(window1->geometry().intersects(window2->geometry()));
// signal spies for active window changed and stacking order changed
QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
QVERIFY(activeWindowChangedSpy.isValid());
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
QVERIFY(!window1->isActive());
QVERIFY(window2->isActive());
// move on top of first window
QVERIFY(window1->geometry().contains(10, 10));
QVERIFY(!window2->geometry().contains(10, 10));
Cursor::setPos(10, 10);
// no focus follows mouse
QVERIFY(!stackingOrderChangedSpy.wait(200));
QVERIFY(stackingOrderChangedSpy.isEmpty());
QVERIFY(activeWindowChangedSpy.isEmpty());
QVERIFY(window2->isActive());
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// should raise window1 and activate it
QCOMPARE(stackingOrderChangedSpy.count(), 1);
QVERIFY(!activeWindowChangedSpy.isEmpty());
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
QVERIFY(window1->isActive());
QVERIFY(!window2->isActive());
// release again
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
void PointerInputTest::testMouseActionActiveWindow_data()
{
QTest::addColumn<bool>("clickRaise");
QTest::addColumn<quint32>("button");
for (quint32 i=BTN_LEFT; i < BTN_JOYSTICK; i++) {
QByteArray number = QByteArray::number(i, 16);
QTest::newRow(QByteArrayLiteral("click raise/").append(number).constData()) << true << i;
QTest::newRow(QByteArrayLiteral("no click raise/").append(number).constData()) << false << i;
}
}
void PointerInputTest::testMouseActionActiveWindow()
{
// this test verifies the mouse action performed on an active window
// for all buttons it should trigger a window raise depending on the
// click raise option
using namespace KWayland::Client;
// create a button spy - all clicks should be passed through
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
// adjust config for this run
QFETCH(bool, clickRaise);
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("ClickRaise", clickRaise);
group.sync();
workspace()->slotReconfigure();
QCOMPARE(options->isClickRaise(), clickRaise);
// create two windows
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface1 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface1);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface1 = Test::createShellSurface(surface1, surface1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window1 = workspace()->activeClient();
QVERIFY(window1);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
QSignalSpy window1DestroyedSpy(window1, &QObject::destroyed);
QVERIFY(window1DestroyedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface2 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface2);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface2 = Test::createShellSurface(surface2, surface2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
AbstractClient *window2 = workspace()->activeClient();
QVERIFY(window2);
QVERIFY(window1 != window2);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
QSignalSpy window2DestroyedSpy(window2, &QObject::destroyed);
QVERIFY(window2DestroyedSpy.isValid());
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
// geometry of the two windows should be overlapping
QVERIFY(window1->geometry().intersects(window2->geometry()));
// lower the currently active window
workspace()->lowerClient(window2);
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
// signal spy for stacking order spy
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
// move on top of second window
QVERIFY(!window1->geometry().contains(900, 900));
QVERIFY(window2->geometry().contains(900, 900));
Cursor::setPos(900, 900);
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(buttonSpy.wait());
if (clickRaise) {
QCOMPARE(stackingOrderChangedSpy.count(), 1);
QTRY_COMPARE_WITH_TIMEOUT(workspace()->topClientOnDesktop(1, -1), window2, 200);
} else {
QCOMPARE(stackingOrderChangedSpy.count(), 0);
QVERIFY(!stackingOrderChangedSpy.wait(100));
QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
}
// release again
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
delete surface1;
QVERIFY(window1DestroyedSpy.wait());
delete surface2;
QVERIFY(window2DestroyedSpy.wait());
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
void PointerInputTest::testCursorImage()
{
// this test verifies that the pointer image gets updated correctly from the client provided data
using namespace KWayland::Client;
// we need a pointer to get the enter event
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
// move cursor somewhere the new window won't open
Cursor::setPos(800, 800);
auto p = input()->pointer();
// at the moment it should be the fallback cursor
QVERIFY(!p->cursorImage().isNull());
// create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// move cursor to center of window, this should first set a null pointer
Cursor::setPos(window->geometry().center());
QCOMPARE(p->window().data(), window);
QVERIFY(p->cursorImage().isNull());
QVERIFY(enteredSpy.wait());
// create a cursor on the pointer
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *cursorSurface = Test::createSurface(m_compositor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(cursorSurface);
QSignalSpy cursorRenderedSpy(cursorSurface, &Surface::frameRendered);
QVERIFY(cursorRenderedSpy.isValid());
QImage red = QImage(QSize(10, 10), QImage::Format_ARGB32);
red.fill(Qt::red);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(red));
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit();
pointer->setCursor(cursorSurface, QPoint(5, 5));
QVERIFY(cursorRenderedSpy.wait());
QCOMPARE(p->cursorImage(), red);
QCOMPARE(p->cursorHotSpot(), QPoint(5, 5));
// change hotspot
pointer->setCursor(cursorSurface, QPoint(6, 6));
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::flushWaylandConnection();
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QTRY_COMPARE(p->cursorHotSpot(), QPoint(6, 6));
QCOMPARE(p->cursorImage(), red);
// change the buffer
QImage blue = QImage(QSize(10, 10), QImage::Format_ARGB32);
blue.fill(Qt::blue);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
auto b = Test::waylandShmPool()->createBuffer(blue);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
cursorSurface->attachBuffer(b);
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit();
QVERIFY(cursorRenderedSpy.wait());
QTRY_COMPARE(p->cursorImage(), blue);
QCOMPARE(p->cursorHotSpot(), QPoint(6, 6));
// hide the cursor
pointer->setCursor(nullptr);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::flushWaylandConnection();
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QTRY_VERIFY(p->cursorImage().isNull());
// move cursor somewhere else, should reset to fallback cursor
Cursor::setPos(window->geometry().bottomLeft() + QPoint(20, 20));
QVERIFY(p->window().isNull());
QVERIFY(!p->cursorImage().isNull());
}
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
class HelperEffect : public Effect
{
Q_OBJECT
public:
HelperEffect() {}
~HelperEffect() {}
};
void PointerInputTest::testEffectOverrideCursorImage()
{
// this test verifies the effect cursor override handling
using namespace KWayland::Client;
// we need a pointer to get the enter event and set a cursor
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
// move cursor somewhere the new window won't open
Cursor::setPos(800, 800);
auto p = input()->pointer();
// here we should have the fallback cursor
const QImage fallback = p->cursorImage();
QVERIFY(!fallback.isNull());
// now let's create a window
QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(clientAddedSpy.isValid());
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Surface *surface = Test::createSurface(m_compositor);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(surface);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
ShellSurface *shellSurface = Test::createShellSurface(surface, surface);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
AbstractClient *window = workspace()->activeClient();
QVERIFY(window);
// and move cursor to the window
QVERIFY(!window->geometry().contains(QPoint(800, 800)));
Cursor::setPos(window->geometry().center());
QVERIFY(enteredSpy.wait());
// cursor image should be null
QVERIFY(p->cursorImage().isNull());
// now create an effect and set an override cursor
QScopedPointer<HelperEffect> effect(new HelperEffect);
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
const QImage sizeAll = p->cursorImage();
QVERIFY(!sizeAll.isNull());
QVERIFY(sizeAll != fallback);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(leftSpy.wait());
// let's change to arrow cursor, this should be our fallback
effects->defineCursor(Qt::ArrowCursor);
QCOMPARE(p->cursorImage(), fallback);
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
// back to size all
effects->defineCursor(Qt::SizeAllCursor);
QCOMPARE(p->cursorImage(), sizeAll);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// move cursor outside the window area
Cursor::setPos(800, 800);
// and end the override, which should switch to fallback
effects->stopMouseInterception(effect.data());
QCOMPARE(p->cursorImage(), fallback);
// start mouse interception again
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
QCOMPARE(p->cursorImage(), sizeAll);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// move cursor to area of window
Cursor::setPos(window->geometry().center());
// this should not result in an enter event
QVERIFY(!enteredSpy.wait(100));
// after ending the interception we should get an enter event
effects->stopMouseInterception(effect.data());
QVERIFY(enteredSpy.wait());
QVERIFY(p->cursorImage().isNull());
}
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
WAYLANDTEST_MAIN(KWin::PointerInputTest)
#include "pointer_input.moc"
Reference in a new issue Copy permalink