Differential D13439 Diff 35862 tests/pointerconstraintstest.cpp

Changeset View

Standalone View

View Options

tests/pointerconstraintstest.cpp

  • This file was added.
1​/********************************************************************
2​Copyright 2018 Roman Gilg <subdiff@gmail.com>
3​
4​This library is free software; you can redistribute it and/or
5​modify it under the terms of the GNU Lesser General Public
6​License as published by the Free Software Foundation; either
7​version 2.1 of the License, or (at your option) version 3, or any
8​later version accepted by the membership of KDE e.V. (or its
9​successor approved by the membership of KDE e.V.), which shall
10​act as a proxy defined in Section 6 of version 3 of the license.
11​
12​This library is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​Lesser General Public License for more details.
16​
17​You should have received a copy of the GNU Lesser General Public
18​License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​#include "pointerconstraintstest.h"
21​
22​#include <KWayland/Client/compositor.h>
23​#include <KWayland/Client/connection_thread.h>
24​#include <KWayland/Client/registry.h>
25​#include <KWayland/Client/surface.h>
26​#include <KWayland/Client/region.h>
27​#include <KWayland/Client/seat.h>
28​#include <KWayland/Client/pointer.h>
29​#include <KWayland/Client/pointerconstraints.h>
30​
31​#include <QGuiApplication>
32​#include <QQmlContext>
33​#include <QQmlEngine>
34​#include <QCursor>
35​
36​#include <QDebug>
37​#include <QScopedPointer>
38​
39​#include <xcb/xproto.h>
40​
41​using namespace KWayland::Client;
42​
43​WaylandBackend::WaylandBackend(QObject *parent)
44​ : Backend(parent)
45​ , m_connectionThreadObject(ConnectionThread::fromApplication(this))
46​{
47​ setMode(Mode::Wayland);
48​}
49​
50​void WaylandBackend::init(QQuickView *view)
51​{
52​ Backend::init(view);
53​
54​ Registry *registry = new Registry(this);
55​ setupRegistry(registry);
56​}
57​
58​void WaylandBackend::setupRegistry(Registry *registry)
59​{
60​ connect(registry, &Registry::compositorAnnounced, this,
61​ [this, registry](quint32 name, quint32 version) {
62​ m_compositor = registry->createCompositor(name, version, this);
63​ }
64​ );
65​ connect(registry, &Registry::seatAnnounced, this,
66​ [this, registry](quint32 name, quint32 version) {
67​ m_seat = registry->createSeat(name, version, this);
68​ if (m_seat->hasPointer()) {
69​ m_pointer = m_seat->createPointer(this);
70​ }
71​ connect(m_seat, &Seat::hasPointerChanged, this,
72​ [this]() {
73​ delete m_pointer;
74​ m_pointer = m_seat->createPointer(this);
75​ }
76​ );
77​ }
78​ );
79​ connect(registry, &Registry::pointerConstraintsUnstableV1Announced, this,
80​ [this, registry](quint32 name, quint32 version) {
81​ m_pointerConstraints = registry->createPointerConstraints(name, version, this);
82​ }
83​ );
84​ connect(registry, &Registry::interfacesAnnounced, this,
85​ [this] {
86​ Q_ASSERT(m_compositor);
87​ Q_ASSERT(m_seat);
88​ Q_ASSERT(m_pointerConstraints);
89​ }
90​ );
91​ registry->create(m_connectionThreadObject);
92​ registry->setup();
93​}
94​
95​bool WaylandBackend::isLocked()
96​{
97​ return m_lockedPointer && m_lockedPointer->isValid();
98​}
99​
100​bool WaylandBackend::isConfined()
101​{
102​ return m_confinedPointer && m_confinedPointer->isValid();
103​}
104​
105​static PointerConstraints::LifeTime lifeTime(bool persistent)
106​{
107​ return persistent ? PointerConstraints::LifeTime::Persistent :
108​ PointerConstraints::LifeTime::OneShot;
109​}
110​
111​void WaylandBackend::lockRequest(bool persistent, QRect region)
112​{
113​ if (isLocked()) {
114​ if (!errorsAllowed()) {
115​ qDebug() << "Abort locking because already locked. Allow errors to test relocking (and crashing).";
116​ return;
117​ }
118​ qDebug() << "Trying to lock although already locked. Crash expected.";
119​ }
120​ if (isConfined()) {
121​ if (!errorsAllowed()) {
122​ qDebug() << "Abort locking because already confined. Allow errors to test locking while being confined (and crashing).";
123​ return;
124​ }
125​ qDebug() << "Trying to lock although already confined. Crash expected.";
126​ }
127​ qDebug() << "------ Lock requested ------";
128​ qDebug() << "Persistent:" << persistent << "| Region:" << region;
129​ QScopedPointer<Surface> winSurface(Surface::fromWindow(view()));
130​ QScopedPointer<Region> wlRegion(m_compositor->createRegion(this));
131​ wlRegion->add(region);
132​
133​ auto *lockedPointer = m_pointerConstraints->lockPointer(winSurface.data(),
134​ m_pointer,
135​ wlRegion.data(),
136​ lifeTime(persistent),
137​ this);
138​
139​ if (!lockedPointer) {
140​ qDebug() << "ERROR when receiving locked pointer!";
141​ return;
142​ }
143​ m_lockedPointer = lockedPointer;
144​ m_lockedPointerPersistent = persistent;
145​ connect(lockedPointer, &LockedPointer::locked, this, [this]() {
146​ qDebug() << "------ LOCKED! ------";
147​ Q_EMIT lockChanged(true);
148​ });
149​ connect(lockedPointer, &LockedPointer::unlocked, this, [this]() {
150​ qDebug() << "------ UNLOCKED! ------";
151​ if (!m_lockedPointerPersistent) {
152​ cleanupLock();
153​ }
154​ Q_EMIT lockChanged(false);
155​ });
156​}
157​
158​void WaylandBackend::unlockRequest()
159​{
160​ if (!m_lockedPointer) {
161​ qDebug() << "Unlock requested, but there is no lock. Abort.";
162​ return;
163​ }
164​ qDebug() << "------ Unlock requested ------";
165​ cleanupLock();
166​ Q_EMIT lockChanged(false);
167​}
168​void WaylandBackend::cleanupLock()
169​{
170​ if (!m_lockedPointer) {
171​ return;
172​ }
173​ m_lockedPointer->release();
174​ m_lockedPointer->deleteLater();
175​ m_lockedPointer = nullptr;
176​}
177​
178​void WaylandBackend::confineRequest(bool persistent, QRect region)
179​{
180​ if (isConfined()) {
181​ if (!errorsAllowed()) {
182​ qDebug() << "Abort confining because already confined. Allow errors to test reconfining (and crashing).";
183​ return;
184​ }
185​ qDebug() << "Trying to lock although already locked. Crash expected.";
186​ }
187​ if (isLocked()) {
188​ if (!errorsAllowed()) {
189​ qDebug() << "Abort confining because already locked. Allow errors to test confining while being locked (and crashing).";
190​ return;
191​ }
192​ qDebug() << "Trying to confine although already locked. Crash expected.";
193​ }
194​ qDebug() << "------ Confine requested ------";
195​ qDebug() << "Persistent:" << persistent << "| Region:" << region;
196​ QScopedPointer<Surface> winSurface(Surface::fromWindow(view()));
197​ QScopedPointer<Region> wlRegion(m_compositor->createRegion(this));
198​ wlRegion->add(region);
199​
200​ auto *confinedPointer = m_pointerConstraints->confinePointer(winSurface.data(),
201​ m_pointer,
202​ wlRegion.data(),
203​ lifeTime(persistent),
204​ this);
205​
206​ if (!confinedPointer) {
207​ qDebug() << "ERROR when receiving confined pointer!";
208​ return;
209​ }
210​ m_confinedPointer = confinedPointer;
211​ m_confinedPointerPersistent = persistent;
212​ connect(confinedPointer, &ConfinedPointer::confined, this, [this]() {
213​ qDebug() << "------ CONFINED! ------";
214​ Q_EMIT confineChanged(true);
215​ });
216​ connect(confinedPointer, &ConfinedPointer::unconfined, this, [this]() {
217​ qDebug() << "------ UNCONFINED! ------";
218​ if (!m_confinedPointerPersistent) {
219​ cleanupConfine();
220​ }
221​ Q_EMIT confineChanged(false);
222​ });
223​}
224​void WaylandBackend::unconfineRequest()
225​{
226​ if (!m_confinedPointer) {
227​ qDebug() << "Unconfine requested, but there is no confine. Abort.";
228​ return;
229​ }
230​ qDebug() << "------ Unconfine requested ------";
231​ cleanupConfine();
232​ Q_EMIT confineChanged(false);
233​}
234​void WaylandBackend::cleanupConfine()
235​{
236​ if (!m_confinedPointer) {
237​ return;
238​ }
239​ m_confinedPointer->release();
240​ m_confinedPointer->deleteLater();
241​ m_confinedPointer = nullptr;
242​}
243​
244​XBackend::XBackend(QObject *parent)
245​ : Backend(parent)
246​{
247​ setMode(Mode::X);
248​ if (m_xcbConn) {
249​ xcb_disconnect(m_xcbConn);
250​ free(m_xcbConn);
251​ }
252​}
253​
254​void XBackend::init(QQuickView *view)
255​{
256​ Backend::init(view);
257​ m_xcbConn = xcb_connect(NULL, NULL);
zzagUnsubmitted
Not Done

Why NULL?

zzag: Why `NULL`?
romanggAuthorUnsubmitted
Not Done

Means it connects to the Xserver sepcified through DISPLAY env var and uses the first screen (only one on Xwayland anyways).

Writing NULL, because it's a C API.

romangg: Means it connects to the Xserver sepcified through DISPLAY env var and uses the first screen…
258​ if (!m_xcbConn) {
259​ qDebug() << "Could not open XCB connection.";
260​ }
261​}
262​
263​void XBackend::lockRequest(bool persistent, QRect region)
264​{
265​ Q_UNUSED(persistent);
266​ Q_UNUSED(region);
267​
268​ auto winId = view()->winId();
269​
270​ /* Cursor needs to be hidden such that Xwayland emulates warps. */
271​ QGuiApplication::setOverrideCursor(QCursor(Qt::BlankCursor));
272​
273​ auto cookie = xcb_warp_pointer_checked(m_xcbConn, /* connection */
274​ XCB_NONE, /* src_w */
275​ winId, /* dest_w */
276​ 0, /* src_x */
277​ 0, /* src_y */
278​ 0, /* src_width */
279​ 0, /* src_height */
280​ 20, /* dest_x */
281​ 20 /* dest_y */
282​ );
283​ xcb_flush(m_xcbConn);
284​
285​ xcb_generic_error_t *error = xcb_request_check(m_xcbConn, cookie);
286​ if (error) {
287​ qDebug() << "Lock (warp) failed with XCB error:" << error->error_code;
288​ free(error);
289​ return;
290​ }
291​ qDebug() << "LOCK (warp)";
292​ Q_EMIT lockChanged(true);
293​}
294​
295​void XBackend::unlockRequest()
296​{
297​ /* Xwayland unlocks the pointer, when the cursor is shown again. */
298​ QGuiApplication::restoreOverrideCursor();
299​ qDebug() << "------ Unlock requested ------";
300​ Q_EMIT lockChanged(false);
301​}
302​
303​void XBackend::confineRequest(bool persistent, QRect region)
304​{
305​ Q_UNUSED(persistent);
306​ Q_UNUSED(region);
307​
308​ int error;
309​ if (!tryConfine(error)) {
310​ qDebug() << "Confine (grab) failed with XCB error:" << error;
311​ return;
312​ }
313​ qDebug() << "CONFINE (grab)";
314​ Q_EMIT confineChanged(true);
315​}
316​
317​void XBackend::unconfineRequest()
318​{
319​ auto cookie = xcb_ungrab_pointer_checked(m_xcbConn, XCB_CURRENT_TIME);
320​ xcb_flush(m_xcbConn);
321​
322​ xcb_generic_error_t *error = xcb_request_check(m_xcbConn, cookie);
323​ if (error) {
324​ qDebug() << "Unconfine failed with XCB error:" << error->error_code;
325​ free(error);
326​ return;
327​ }
328​ qDebug() << "UNCONFINE (ungrab)";
329​ Q_EMIT confineChanged(false);
330​}
331​
332​void XBackend::hideAndConfineRequest(bool confineBeforeHide)
333​{
334​ if (!confineBeforeHide) {
335​ QGuiApplication::setOverrideCursor(QCursor(Qt::BlankCursor));
336​ }
337​
338​ int error;
339​ if (!tryConfine(error)) {
340​ qDebug() << "Confine failed with XCB error:" << error;
341​ if (!confineBeforeHide) {
342​ QGuiApplication::restoreOverrideCursor();
343​ }
344​ return;
345​ }
346​ if (confineBeforeHide) {
347​ QGuiApplication::setOverrideCursor(QCursor(Qt::BlankCursor));
348​ }
349​ qDebug() << "HIDE AND CONFINE (lock)";
350​ Q_EMIT confineChanged(true);
351​
352​}
353​
354​void XBackend::undoHideRequest()
355​{
356​ QGuiApplication::restoreOverrideCursor();
357​ qDebug() << "UNDO HIDE AND CONFINE (unlock)";
358​}
359​
360​bool XBackend::tryConfine(int &error)
361​{
362​ auto winId = view()->winId();
363​
364​ auto cookie = xcb_grab_pointer(m_xcbConn, /* display */
365​ 1, /* owner_events */
366​ winId, /* grab_window */
367​ 0, /* event_mask */
368​ XCB_GRAB_MODE_ASYNC, /* pointer_mode */
369​ XCB_GRAB_MODE_ASYNC, /* keyboard_mode */
370​ winId, /* confine_to */
371​ XCB_NONE, /* cursor */
372​ XCB_CURRENT_TIME /* time */
373​ );
374​ xcb_flush(m_xcbConn);
375​
376​ xcb_generic_error_t *e = nullptr;
377​ auto *reply = xcb_grab_pointer_reply(m_xcbConn, cookie, &e);
378​ if (!reply) {
379​ error = e->error_code;
380​ free(e);
381​ return false;
382​ }
383​ free(reply);
384​ return true;
385​}
386​
387​int main(int argc, char **argv)
388​{
389​ QGuiApplication app(argc, argv);
390​
391​ Backend *backend;
392​ if (app.platformName() == QStringLiteral("wayland")) {
393​ qDebug() << "Starting up: Wayland native mode";
394​ backend = new WaylandBackend(&app);
395​ } else {
396​ qDebug() << "Starting up: Xserver/Xwayland legacy mode";
397​ backend = new XBackend(&app);
398​ }
399​
400​ QQuickView view;
401​
402​ QQmlContext* context = view.engine()->rootContext();
403​ context->setContextProperty(QStringLiteral("org_kde_kwin_tests_pointerconstraints_backend"), backend);
404​
405​ view.setSource(QUrl::fromLocalFile(QStringLiteral(DIR) +QStringLiteral("/pointerconstraintstest.qml")));
406​ view.show();
407​
408​ backend->init(&view);
409​
410​ return app.exec();
411​}