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

411 lines
17 KiB
C++
Raw Normal View History

Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +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"
#include "cursor.h"
#include "keyboard_input.h"
#include "platform.h"
#include "pointer_input.h"
Rename ShellClient to XdgShellClient Summary: Rename ShellClient to XdgShellClient in order to reflect that it represents only xdg-shell clients. Test Plan: Compiles, tests still pass. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23589
2019-08-30 21:36:58 +00:00
#include "xdgshellclient.h"
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
#include "screens.h"
#include "wayland_server.h"
#include "workspace.h"
#include <KWayland/Client/compositor.h>
#include <KWayland/Client/keyboard.h>
#include <KWayland/Client/pointer.h>
#include <KWayland/Client/pointerconstraints.h>
#include <KWayland/Client/region.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
#include <KWayland/Server/seat_interface.h>
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
#include <KWayland/Server/surface_interface.h>
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
#include <linux/input.h>
#include <functional>
using namespace KWin;
using namespace KWayland::Client;
typedef std::function<QPoint(const QRect&)> PointerFunc;
Q_DECLARE_METATYPE(PointerFunc)
static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_constraints-0");
class TestPointerConstraints : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testConfinedPointer_data();
void testConfinedPointer();
void testLockedPointer_data();
void testLockedPointer();
[autotests] Extend pointer constraints test for closing window of locked pointer
2017-06-24 18:31:50 +00:00
void testCloseWindowWithLockedPointer_data();
void testCloseWindowWithLockedPointer();
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
};
void TestPointerConstraints::initTestCase()
{
qRegisterMetaType<PointerFunc>();
Rename ShellClient to XdgShellClient Summary: Rename ShellClient to XdgShellClient in order to reflect that it represents only xdg-shell clients. Test Plan: Compiles, tests still pass. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23589
2019-08-30 21:36:58 +00:00
qRegisterMetaType<KWin::XdgShellClient *>();
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
[platforms/virtual] Create output devices Summary: Create output devices in virtual backend. For that the setVirtualOutputs call can only come after the Wayland server has been initiliazied such that the display exists to create the output and output device interfaces. Tests have been adjusted for that. Test Plan: ``` 98% tests passed, 3 tests failed out of 148 Total Test time (real) = 362.97 sec The following tests FAILED: 33 - kwin-testInternalWindow (Failed) 39 - kwin-testPointerInput (Failed) 101 - kwin-testMoveResize (Failed) ``` Failing of these tests looks unrelated to the change. Reviewers: #kwin Subscribers: kwin Tags: #kwin Maniphest Tasks: T11459 Differential Revision: https://phabricator.kde.org/D23477
2019-08-26 21:16:53 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
[autotests] Disable OnScreenNotification in PointerConstraintsTest Using QtQuick in test environment fails due to no OpenGL.
2016-12-22 18:05:47 +00:00
// set custom config which disables the OnScreenNotification
KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
KConfigGroup group = config->group("OnScreenNotification");
group.writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
group.sync();
kwinApp()->setConfig(config);
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +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));
waylandServer()->initWorkspace();
}
void TestPointerConstraints::init()
{
[autotests/integration] Use socketpair for Wayland connection Summary: This is a preparation step for no longer creating a socket in the tests and slightly simplifies the init test code. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3575
2016-12-03 13:31:14 +00:00
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::PointerConstraints));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QVERIFY(Test::waitForWaylandPointer());
screens()->setCurrent(0);
KWin::Cursor::setPos(QPoint(1280, 512));
}
void TestPointerConstraints::cleanup()
{
Test::destroyWaylandConnection();
}
void TestPointerConstraints::testConfinedPointer_data()
{
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::addColumn<Test::XdgShellSurfaceType>("type");
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QTest::addColumn<PointerFunc>("positionFunction");
QTest::addColumn<int>("xOffset");
QTest::addColumn<int>("yOffset");
PointerFunc bottomLeft = &QRect::bottomLeft;
PointerFunc bottomRight = &QRect::bottomRight;
PointerFunc topRight = &QRect::topRight;
PointerFunc topLeft = &QRect::topLeft;
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::newRow("XdgShellV6 - bottomLeft") << Test::XdgShellSurfaceType::XdgShellV6 << bottomLeft << -1 << 1;
QTest::newRow("XdgShellV6 - bottomRight") << Test::XdgShellSurfaceType::XdgShellV6 << bottomRight << 1 << 1;
QTest::newRow("XdgShellV6 - topLeft") << Test::XdgShellSurfaceType::XdgShellV6 << topLeft << -1 << -1;
QTest::newRow("XdgShellV6 - topRight") << Test::XdgShellSurfaceType::XdgShellV6 << topRight << 1 << -1;
QTest::newRow("XdgWmBase - bottomLeft") << Test::XdgShellSurfaceType::XdgShellStable << bottomLeft << -1 << 1;
QTest::newRow("XdgWmBase - bottomRight") << Test::XdgShellSurfaceType::XdgShellStable << bottomRight << 1 << 1;
QTest::newRow("XdgWmBase - topLeft") << Test::XdgShellSurfaceType::XdgShellStable << topLeft << -1 << -1;
QTest::newRow("XdgWmBase - topRight") << Test::XdgShellSurfaceType::XdgShellStable << topRight << 1 << -1;
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
}
void TestPointerConstraints::testConfinedPointer()
{
// this test sets up a Surface with a confined pointer
// simple interaction test to verify that the pointer gets confined
QScopedPointer<Surface> surface(Test::createSurface());
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QFETCH(Test::XdgShellSurfaceType, type);
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
QScopedPointer<ConfinedPointer> confinedPointer(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
QSignalSpy confinedSpy(confinedPointer.data(), &ConfinedPointer::confined);
QVERIFY(confinedSpy.isValid());
QSignalSpy unconfinedSpy(confinedPointer.data(), &ConfinedPointer::unconfined);
QVERIFY(unconfinedSpy.isValid());
// now map the window
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
QVERIFY(c);
if (c->geometry().topLeft() == QPoint(0, 0)) {
c->move(QPoint(1, 1));
}
QVERIFY(!c->geometry().contains(KWin::Cursor::pos()));
// now let's confine
QCOMPARE(input()->pointer()->isConstrained(), false);
KWin::Cursor::setPos(c->geometry().center());
QCOMPARE(input()->pointer()->isConstrained(), true);
QVERIFY(confinedSpy.wait());
// picking a position outside the window geometry should not move pointer
QSignalSpy pointerPositionChangedSpy(input(), &InputRedirection::globalPointerChanged);
QVERIFY(pointerPositionChangedSpy.isValid());
KWin::Cursor::setPos(QPoint(1280, 512));
QVERIFY(pointerPositionChangedSpy.isEmpty());
QCOMPARE(KWin::Cursor::pos(), c->geometry().center());
// TODO: test relative motion
QFETCH(PointerFunc, positionFunction);
const QPoint position = positionFunction(c->geometry());
KWin::Cursor::setPos(position);
QCOMPARE(pointerPositionChangedSpy.count(), 1);
QCOMPARE(KWin::Cursor::pos(), position);
// moving one to right should not be possible
QFETCH(int, xOffset);
KWin::Cursor::setPos(position + QPoint(xOffset, 0));
QCOMPARE(pointerPositionChangedSpy.count(), 1);
QCOMPARE(KWin::Cursor::pos(), position);
// moving one to bottom should not be possible
QFETCH(int, yOffset);
KWin::Cursor::setPos(position + QPoint(0, yOffset));
QCOMPARE(pointerPositionChangedSpy.count(), 1);
QCOMPARE(KWin::Cursor::pos(), position);
Ignore modifier mouse actions when the pointer is constrained Summary: If the pointer is constrained all mouse events should go to the window. Also our Alt+click. To use Alt+click nevertheless one can just unconfine the window. CCBUG: 399375 Test Plan: Run the adjusted autotest before and after change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15982
2018-10-06 16:03:19 +00:00
// modifier + click should be ignored
// first ensure the settings are ok
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandAllKey", QStringLiteral("Alt"));
group.writeEntry("CommandAll1", "Move");
group.writeEntry("CommandAll2", "Move");
group.writeEntry("CommandAll3", "Move");
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
group.writeEntry("CommandAllWheel", "change opacity");
Ignore modifier mouse actions when the pointer is constrained Summary: If the pointer is constrained all mouse events should go to the window. Also our Alt+click. To use Alt+click nevertheless one can just unconfine the window. CCBUG: 399375 Test Plan: Run the adjusted autotest before and after change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15982
2018-10-06 16:03:19 +00:00
group.sync();
workspace()->slotReconfigure();
QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
quint32 timestamp = 1;
kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
QVERIFY(!c->isMove());
kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
// set the opacity to 0.5
c->setOpacity(0.5);
QCOMPARE(c->opacity(), 0.5);
// pointer is confined so shortcut should not work
kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
QCOMPARE(c->opacity(), 0.5);
kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
QCOMPARE(c->opacity(), 0.5);
Ignore modifier mouse actions when the pointer is constrained Summary: If the pointer is constrained all mouse events should go to the window. Also our Alt+click. To use Alt+click nevertheless one can just unconfine the window. CCBUG: 399375 Test Plan: Run the adjusted autotest before and after change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15982
2018-10-06 16:03:19 +00:00
kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
// deactivate the client, this should unconfine
workspace()->activateClient(nullptr);
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QVERIFY(unconfinedSpy.wait());
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
QCOMPARE(input()->pointer()->isConstrained(), false);
// reconfine pointer (this time with persistent life time)
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
QSignalSpy confinedSpy2(confinedPointer.data(), &ConfinedPointer::confined);
QVERIFY(confinedSpy2.isValid());
QSignalSpy unconfinedSpy2(confinedPointer.data(), &ConfinedPointer::unconfined);
QVERIFY(unconfinedSpy2.isValid());
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
// activate it again, this confines again
Rework InputDeviceHandler focus tracking Summary: This patch aims at improving the Toplevel, internal window and decoration focus tracking. In detail the goals are: * Clean tracking of beneath and focus Toplevel as well as decoration and internal windows. Splitting this up in well defined sub routines. * Minimal find Toplevel operations on window stack. * Reduce code duplication in pointer and touch child classes. * Reuse tracking in drag operations. * Allow direct usage of Wayland input interfaces for decoration and internal windows in the future. * Update touch focus on external events like VD switches correctly. Test Plan: Manually and existing autotests. Reviewers: #kwin Subscribers: kwin, zzag Tags: #kwin Differential Revision: https://phabricator.kde.org/D15595
2018-09-15 00:00:24 +00:00
workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QVERIFY(confinedSpy2.wait());
QCOMPARE(input()->pointer()->isConstrained(), true);
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
// deactivate the client one more time with the persistent life time constraint, this should unconfine
Make keyboard focus a pointer constraints necessity Summary: This patch changes KWin's pointer constraining behavior by only allowing constraints if the surface has keyboard focus. In case the client activation state changes, it rechecks it. Test Plan: Manually with the pointer constraints test application and opening the launcher by pressing meta. Also amended autotest. Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, davidedmundson, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13492
2018-06-18 18:14:04 +00:00
workspace()->activateClient(nullptr);
QVERIFY(unconfinedSpy2.wait());
QCOMPARE(input()->pointer()->isConstrained(), false);
// activate it again, this confines again
Rework InputDeviceHandler focus tracking Summary: This patch aims at improving the Toplevel, internal window and decoration focus tracking. In detail the goals are: * Clean tracking of beneath and focus Toplevel as well as decoration and internal windows. Splitting this up in well defined sub routines. * Minimal find Toplevel operations on window stack. * Reduce code duplication in pointer and touch child classes. * Reuse tracking in drag operations. * Allow direct usage of Wayland input interfaces for decoration and internal windows in the future. * Update touch focus on external events like VD switches correctly. Test Plan: Manually and existing autotests. Reviewers: #kwin Subscribers: kwin, zzag Tags: #kwin Differential Revision: https://phabricator.kde.org/D15595
2018-09-15 00:00:24 +00:00
workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
Make keyboard focus a pointer constraints necessity Summary: This patch changes KWin's pointer constraining behavior by only allowing constraints if the surface has keyboard focus. In case the client activation state changes, it rechecks it. Test Plan: Manually with the pointer constraints test application and opening the launcher by pressing meta. Also amended autotest. Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, davidedmundson, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13492
2018-06-18 18:14:04 +00:00
QVERIFY(confinedSpy2.wait());
QCOMPARE(input()->pointer()->isConstrained(), true);
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
// create a second window and move it above our constrained window
QScopedPointer<Surface> surface2(Test::createSurface());
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellSurface(type, surface2.data()));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(1280, 1024), Qt::blue);
QVERIFY(c2);
QVERIFY(unconfinedSpy2.wait());
// and unmapping the second window should confine again
shellSurface2.reset();
surface2.reset();
QVERIFY(confinedSpy2.wait());
// let's set a region which results in unconfined
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
auto r = Test::waylandCompositor()->createRegion(QRegion(2, 2, 3, 3));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
confinedPointer->setRegion(r.get());
surface->commit(Surface::CommitFlag::None);
QVERIFY(unconfinedSpy2.wait());
QCOMPARE(input()->pointer()->isConstrained(), false);
// and set a full region again, that should confine
confinedPointer->setRegion(nullptr);
surface->commit(Surface::CommitFlag::None);
QVERIFY(confinedSpy2.wait());
QCOMPARE(input()->pointer()->isConstrained(), true);
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
// delete pointer confine
confinedPointer.reset(nullptr);
Test::flushWaylandConnection();
Rework InputDeviceHandler focus tracking Summary: This patch aims at improving the Toplevel, internal window and decoration focus tracking. In detail the goals are: * Clean tracking of beneath and focus Toplevel as well as decoration and internal windows. Splitting this up in well defined sub routines. * Minimal find Toplevel operations on window stack. * Reduce code duplication in pointer and touch child classes. * Reuse tracking in drag operations. * Allow direct usage of Wayland input interfaces for decoration and internal windows in the future. * Update touch focus on external events like VD switches correctly. Test Plan: Manually and existing autotests. Reviewers: #kwin Subscribers: kwin, zzag Tags: #kwin Differential Revision: https://phabricator.kde.org/D15595
2018-09-15 00:00:24 +00:00
QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
QVERIFY(constraintsChangedSpy.isValid());
QVERIFY(constraintsChangedSpy.wait());
// should be unconfined
QCOMPARE(input()->pointer()->isConstrained(), false);
// confine again
confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
QSignalSpy confinedSpy3(confinedPointer.data(), &ConfinedPointer::confined);
QVERIFY(confinedSpy3.isValid());
QVERIFY(confinedSpy3.wait());
QCOMPARE(input()->pointer()->isConstrained(), true);
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
// and now unmap
shellSurface.reset();
surface.reset();
QVERIFY(Test::waitForWindowDestroyed(c));
QCOMPARE(input()->pointer()->isConstrained(), false);
}
void TestPointerConstraints::testLockedPointer_data()
{
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::addColumn<Test::XdgShellSurfaceType>("type");
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
}
void TestPointerConstraints::testLockedPointer()
{
// this test sets up a Surface with a locked pointer
// simple interaction test to verify that the pointer gets locked
// the various ways to unlock are not tested as that's already verified by testConfinedPointer
QScopedPointer<Surface> surface(Test::createSurface());
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QFETCH(Test::XdgShellSurfaceType, type);
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
QVERIFY(lockedSpy.isValid());
QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
QVERIFY(unlockedSpy.isValid());
// now map the window
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
QVERIFY(c);
QVERIFY(!c->geometry().contains(KWin::Cursor::pos()));
// now let's lock
QCOMPARE(input()->pointer()->isConstrained(), false);
KWin::Cursor::setPos(c->geometry().center());
QCOMPARE(KWin::Cursor::pos(), c->geometry().center());
QCOMPARE(input()->pointer()->isConstrained(), true);
QVERIFY(lockedSpy.wait());
// try to move the pointer
// TODO: add relative pointer
KWin::Cursor::setPos(c->geometry().center() + QPoint(1, 1));
QCOMPARE(KWin::Cursor::pos(), c->geometry().center());
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
// deactivate the client, this should unlock
workspace()->activateClient(nullptr);
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
QCOMPARE(input()->pointer()->isConstrained(), false);
QVERIFY(unlockedSpy.wait());
// moving cursor should be allowed again
KWin::Cursor::setPos(c->geometry().center() + QPoint(1, 1));
QCOMPARE(KWin::Cursor::pos(), c->geometry().center() + QPoint(1, 1));
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
lockedPointer.reset(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
QSignalSpy lockedSpy2(lockedPointer.data(), &LockedPointer::locked);
QVERIFY(lockedSpy2.isValid());
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
// activate the client again, this should lock again
Rework InputDeviceHandler focus tracking Summary: This patch aims at improving the Toplevel, internal window and decoration focus tracking. In detail the goals are: * Clean tracking of beneath and focus Toplevel as well as decoration and internal windows. Splitting this up in well defined sub routines. * Minimal find Toplevel operations on window stack. * Reduce code duplication in pointer and touch child classes. * Reuse tracking in drag operations. * Allow direct usage of Wayland input interfaces for decoration and internal windows in the future. * Update touch focus on external events like VD switches correctly. Test Plan: Manually and existing autotests. Reviewers: #kwin Subscribers: kwin, zzag Tags: #kwin Differential Revision: https://phabricator.kde.org/D15595
2018-09-15 00:00:24 +00:00
workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
QVERIFY(lockedSpy2.wait());
Remove breaking pointer constraints functionality Summary: With 2694839099c3, 0bd5eff8623d and f0ba436c724e it is now possible to unconstrain a pointer by killing the client or deactivating the window, for example by switching the window via the TabBox. A user should always be able to do it therefore without needing to explicitly break the pointer constrain as in the past with the Esc key. Therefore remove the functionality and also remove the OSD announcing it, which was often shown at the wrong time. Test Plan: Manually and auto test adapted. Reviewers: #kwin, #vdg, hein Reviewed By: hein Subscribers: ngraham, hein, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D15234
2018-09-02 23:00:29 +00:00
QCOMPARE(input()->pointer()->isConstrained(), true);
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
// try to move the pointer
QCOMPARE(input()->pointer()->isConstrained(), true);
KWin::Cursor::setPos(c->geometry().center());
QCOMPARE(KWin::Cursor::pos(), c->geometry().center() + QPoint(1, 1));
// delete pointer lock
lockedPointer.reset(nullptr);
Test::flushWaylandConnection();
Rework InputDeviceHandler focus tracking Summary: This patch aims at improving the Toplevel, internal window and decoration focus tracking. In detail the goals are: * Clean tracking of beneath and focus Toplevel as well as decoration and internal windows. Splitting this up in well defined sub routines. * Minimal find Toplevel operations on window stack. * Reduce code duplication in pointer and touch child classes. * Reuse tracking in drag operations. * Allow direct usage of Wayland input interfaces for decoration and internal windows in the future. * Update touch focus on external events like VD switches correctly. Test Plan: Manually and existing autotests. Reviewers: #kwin Subscribers: kwin, zzag Tags: #kwin Differential Revision: https://phabricator.kde.org/D15595
2018-09-15 00:00:24 +00:00
QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
Remove pointer constraint on resource unbind Summary: A client might delete its pointer lock/confinement object. This is supposed to directly remove the pointer lock/confinement in KWin, but did not explicitly until now. BUG: 388885 Test Plan: Tested manually with Neverball, Nexuiz and the new pointer constraints test application. The pointer constraints autotest is also appended. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, graesslin, kwin Tags: #kwin Maniphest Tasks: T8923 Differential Revision: https://phabricator.kde.org/D13466
2018-06-11 20:45:09 +00:00
QVERIFY(constraintsChangedSpy.isValid());
QVERIFY(constraintsChangedSpy.wait());
// moving cursor should be allowed again
QCOMPARE(input()->pointer()->isConstrained(), false);
KWin::Cursor::setPos(c->geometry().center());
QCOMPARE(KWin::Cursor::pos(), c->geometry().center());
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
}
[autotests] Extend pointer constraints test for closing window of locked pointer
2017-06-24 18:31:50 +00:00
void TestPointerConstraints::testCloseWindowWithLockedPointer_data()
{
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::addColumn<Test::XdgShellSurfaceType>("type");
[autotests] Extend pointer constraints test for closing window of locked pointer
2017-06-24 18:31:50 +00:00
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QTest::newRow("XdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
QTest::newRow("XdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
[autotests] Extend pointer constraints test for closing window of locked pointer
2017-06-24 18:31:50 +00:00
}
void TestPointerConstraints::testCloseWindowWithLockedPointer()
{
// test case which verifies that the pointer gets unlocked when the window for it gets closed
QScopedPointer<Surface> surface(Test::createSurface());
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
QFETCH(Test::XdgShellSurfaceType, type);
QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
[autotests] Extend pointer constraints test for closing window of locked pointer
2017-06-24 18:31:50 +00:00
QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
QVERIFY(lockedSpy.isValid());
QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
QVERIFY(unlockedSpy.isValid());
// now map the window
auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
QVERIFY(c);
QVERIFY(!c->geometry().contains(KWin::Cursor::pos()));
// now let's lock
QCOMPARE(input()->pointer()->isConstrained(), false);
KWin::Cursor::setPos(c->geometry().center());
QCOMPARE(KWin::Cursor::pos(), c->geometry().center());
QCOMPARE(input()->pointer()->isConstrained(), true);
QVERIFY(lockedSpy.wait());
// close the window
shellSurface.reset();
surface.reset();
// this should result in unlocked
QVERIFY(unlockedSpy.wait());
QCOMPARE(input()->pointer()->isConstrained(), false);
}
Implement support for pointer constraints Summary: There are two types of constraints supported: 1. Pointer confinement 2. Pointer locking In the case of confinement the pointer is confined to a given region of the surface. This is comparable to general operation where the pointer is confined to the screen region. In the second case the pointer gets locked. That means it cannot move at all. No further position updates are provided, only relative motion events can go to the application. There is a hint about cursor position update on unlock which is not yet implemented in KWayland::Server, thus also not in this change. The implementation in KWin grants the requests for pointer constraints when the pointer enters the constrained region, either by pointer movement or by e.g. stacking order changes. There is no confirmation from user required to enter that mode. But we want to show an OSD when the pointer gets constrained, this is not yet implemented, though. Breaking an active constraint is relatively easy. E.g. changing the stacking order will break the constraint if another surface is under the cursor. Also (in case of confinement) moving the pointer to an overlapping window breaks the confinement. But as soon as one moves the pointer back to the window a constraint might get honoured again. To properly break there is a dedicated event filter. It listens for a long press of the Escape key. If hold for 3sec the pointer constraint is broken and not activated again till the pointer got moved out of the window. Afterward when moving in the pointer might activate again. The escape filter ensures that the key press is forwarded to the application if it's a short press or if another key gets pressed during the three seconds. If the three seconds way fires, the later escape release is not sent to the application. This basic interaction is also ensured through an added auto test. This change implements T4605. Test Plan: Added auto test and nested KWin Wayland with D3488 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3506
2016-11-25 06:17:43 +00:00
WAYLANDTEST_MAIN(TestPointerConstraints)
#include "pointer_constraints_test.moc"
Reference in a new issue Copy permalink