From ed264e2c5539266bfecc69553a82bfa53f2c0d80 Mon Sep 17 00:00:00 2001 From: Adrien Faveraux Date: Fri, 24 Jul 2020 19:19:19 +0200 Subject: [PATCH] migrate idle interface to the new approach --- src/wayland/CMakeLists.txt | 2 +- src/wayland/autotests/client/test_idle.cpp | 1 - src/wayland/idle_interface.cpp | 257 +++++++-------------- src/wayland/idle_interface.h | 29 +-- src/wayland/idle_interface_p.h | 60 +++++ 5 files changed, 151 insertions(+), 198 deletions(-) create mode 100644 src/wayland/idle_interface_p.h diff --git a/src/wayland/CMakeLists.txt b/src/wayland/CMakeLists.txt index ae9dd0c5c3..5ffec5fa18 100644 --- a/src/wayland/CMakeLists.txt +++ b/src/wayland/CMakeLists.txt @@ -113,7 +113,7 @@ ecm_add_wayland_server_protocol(SERVER_LIB_SRCS BASENAME qt-surface-extension ) -ecm_add_wayland_server_protocol(SERVER_LIB_SRCS +ecm_add_qtwayland_server_protocol(SERVER_LIB_SRCS PROTOCOL ${PLASMA_WAYLAND_PROTOCOLS_DIR}/idle.xml BASENAME idle ) diff --git a/src/wayland/autotests/client/test_idle.cpp b/src/wayland/autotests/client/test_idle.cpp index 8530800e98..cff91f8c73 100644 --- a/src/wayland/autotests/client/test_idle.cpp +++ b/src/wayland/autotests/client/test_idle.cpp @@ -57,7 +57,6 @@ void IdleTest::init() m_seatInterface->setName(QStringLiteral("seat0")); m_seatInterface->create(); m_idleInterface = m_display->createIdle(); - m_idleInterface->create(); // setup connection m_connection = new KWayland::Client::ConnectionThread; diff --git a/src/wayland/idle_interface.cpp b/src/wayland/idle_interface.cpp index 4077e442e4..5d6f8889ed 100644 --- a/src/wayland/idle_interface.cpp +++ b/src/wayland/idle_interface.cpp @@ -3,115 +3,44 @@ SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL */ -#include "idle_interface.h" +#include "idle_interface_p.h" #include "display.h" -#include "global_p.h" -#include "resource_p.h" #include "seat_interface.h" -#include - -#include -#include -#include - namespace KWaylandServer { -class IdleInterface::Private : public Global::Private -{ -public: - Private(IdleInterface *q, Display *d); +const quint32 IdleInterfacePrivate::s_version = 1; - int inhibitCount = 0; - QVector idleTimeouts; - -private: - void bind(wl_client *client, uint32_t version, uint32_t id) override; - static void getIdleTimeoutCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *seat, uint32_t timeout); - - static void unbind(wl_resource *resource); - static Private *cast(wl_resource *r) { - return reinterpret_cast(wl_resource_get_user_data(r)); - } - - IdleInterface *q; - static const struct org_kde_kwin_idle_interface s_interface; - static const quint32 s_version; -}; - -class IdleTimeoutInterface::Private : public Resource::Private -{ -public: - Private(SeatInterface *seat, IdleTimeoutInterface *q, IdleInterface *manager, wl_resource *parentResource); - ~Private(); - void setup(quint32 timeout); - - void simulateUserActivity(); - - SeatInterface *seat; - QTimer *timer = nullptr; - -private: - static void simulateUserActivityCallback(wl_client *client, wl_resource *resource); - IdleTimeoutInterface *q_func() { - return reinterpret_cast(q); - } - static const struct org_kde_kwin_idle_timeout_interface s_interface; -}; - -const quint32 IdleInterface::Private::s_version = 1; - -#ifndef K_DOXYGEN -const struct org_kde_kwin_idle_interface IdleInterface::Private::s_interface = { - getIdleTimeoutCallback -}; -#endif - -IdleInterface::Private::Private(IdleInterface *q, Display *d) - : Global::Private(d, &org_kde_kwin_idle_interface, s_version) - , q(q) +IdleInterfacePrivate::IdleInterfacePrivate(IdleInterface *_q, Display *display) + : QtWaylandServer::org_kde_kwin_idle(*display, s_version) + , q(_q) { } -void IdleInterface::Private::getIdleTimeoutCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *seat, uint32_t timeout) +void IdleInterfacePrivate::org_kde_kwin_idle_get_idle_timeout(Resource *resource, uint32_t id, wl_resource *seat, uint32_t timeout) { - Private *p = cast(resource); SeatInterface *s = SeatInterface::get(seat); Q_ASSERT(s); - IdleTimeoutInterface *idleTimeout = new IdleTimeoutInterface(s, p->q, resource); - idleTimeout->create(p->display->getConnection(client), wl_resource_get_version(resource), id); - if (!idleTimeout->resource()) { - wl_resource_post_no_memory(resource); - delete idleTimeout; + + wl_resource *idleTimoutResource = wl_resource_create(resource->client(), &org_kde_kwin_idle_timeout_interface, resource->version(), id); + if (!idleTimoutResource) { + wl_client_post_no_memory(resource->client()); return; } - p->idleTimeouts << idleTimeout; - QObject::connect(idleTimeout, &IdleTimeoutInterface::aboutToBeUnbound, p->q, [p, idleTimeout]() { - p->idleTimeouts.removeOne(idleTimeout); + + IdleTimeoutInterface *idleTimeout = new IdleTimeoutInterface(s, q, idleTimoutResource); + idleTimeouts << idleTimeout; + + QObject::connect(idleTimeout, &IdleTimeoutInterface::destroyed, q, [this, idleTimeout]() { + idleTimeouts.removeOne(idleTimeout); }); - idleTimeout->d_func()->setup(timeout); -} - -void IdleInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id) -{ - auto c = display->getConnection(client); - wl_resource *resource = c->createResource(&org_kde_kwin_idle_interface, qMin(version, s_version), id); - if (!resource) { - wl_client_post_no_memory(client); - return; - } - wl_resource_set_implementation(resource, &s_interface, this, unbind); - // TODO: should we track? -} - -void IdleInterface::Private::unbind(wl_resource *resource) -{ - Q_UNUSED(resource) + idleTimeout->setup(timeout); } IdleInterface::IdleInterface(Display *display, QObject *parent) - : Global(new Private(this, display), parent) + : QObject(parent) + , d(new IdleInterfacePrivate(this, display)) { } @@ -119,7 +48,6 @@ IdleInterface::~IdleInterface() = default; void IdleInterface::inhibit() { - Q_D(); d->inhibitCount++; if (d->inhibitCount == 1) { emit inhibitedChanged(); @@ -128,7 +56,6 @@ void IdleInterface::inhibit() void IdleInterface::uninhibit() { - Q_D(); d->inhibitCount--; if (d->inhibitCount == 0) { emit inhibitedChanged(); @@ -137,107 +64,40 @@ void IdleInterface::uninhibit() bool IdleInterface::isInhibited() const { - Q_D(); return d->inhibitCount > 0; } void IdleInterface::simulateUserActivity() { - Q_D(); for (auto i : qAsConst(d->idleTimeouts)) { - i->d_func()->simulateUserActivity(); + i->simulateUserActivity(); } } -IdleInterface::Private *IdleInterface::d_func() const -{ - return reinterpret_cast(d.data()); -} - -#ifndef K_DOXYGEN -const struct org_kde_kwin_idle_timeout_interface IdleTimeoutInterface::Private::s_interface = { - resourceDestroyedCallback, - simulateUserActivityCallback -}; -#endif - -IdleTimeoutInterface::Private::Private(SeatInterface *seat, IdleTimeoutInterface *q, IdleInterface *manager, wl_resource *parentResource) - : Resource::Private(q, manager, parentResource, &org_kde_kwin_idle_timeout_interface, &s_interface) +IdleTimeoutInterface::IdleTimeoutInterface(SeatInterface *seat, IdleInterface *manager, wl_resource *resource) + : QObject() + , QtWaylandServer::org_kde_kwin_idle_timeout(resource) , seat(seat) -{ -} - -IdleTimeoutInterface::Private::~Private() = default; - -void IdleTimeoutInterface::Private::simulateUserActivityCallback(wl_client *client, wl_resource *resource) -{ - Q_UNUSED(client); - Private *p = reinterpret_cast(wl_resource_get_user_data(resource)); - p->simulateUserActivity(); -} - -void IdleTimeoutInterface::Private::simulateUserActivity() -{ - if (!timer) { - // not yet configured - return; - } - if (qobject_cast(global)->isInhibited()) { - // ignored while inhibited - return; - } - if (!timer->isActive() && resource) { - org_kde_kwin_idle_timeout_send_resumed(resource); - } - timer->start(); -} - -void IdleTimeoutInterface::Private::setup(quint32 timeout) -{ - if (timer) { - return; - } - timer = new QTimer(q); - timer->setSingleShot(true); - // less than 5 sec is not idle by definition - timer->setInterval(qMax(timeout, 5000u)); - QObject::connect(timer, &QTimer::timeout, q, - [this] { - if (resource) { - org_kde_kwin_idle_timeout_send_idle(resource); - } - } - ); - if (qobject_cast(global)->isInhibited()) { - // don't start if inhibited - return; - } - timer->start(); -} - -IdleTimeoutInterface::IdleTimeoutInterface(SeatInterface *seat, IdleInterface *parent, wl_resource *parentResource) - : Resource(new Private(seat, this, parent, parentResource)) + , manager(manager) { connect(seat, &SeatInterface::timestampChanged, this, [this] { - Q_D(); - d->simulateUserActivity(); + simulateUserActivity(); } ); - connect(parent, &IdleInterface::inhibitedChanged, this, - [this] { - Q_D(); - if (!d->timer) { + connect(manager, &IdleInterface::inhibitedChanged, this, + [this, manager] { + if (!timer) { // not yet configured return; } - if (qobject_cast(d->global)->isInhibited()) { - if (!d->timer->isActive() && d->resource) { - org_kde_kwin_idle_timeout_send_resumed(d->resource); + if (manager->isInhibited()) { + if (!timer->isActive()) { + send_resumed(); } - d->timer->stop(); + timer->stop(); } else { - d->timer->start(); + timer->start(); } } ); @@ -245,9 +105,56 @@ IdleTimeoutInterface::IdleTimeoutInterface(SeatInterface *seat, IdleInterface *p IdleTimeoutInterface::~IdleTimeoutInterface() = default; -IdleTimeoutInterface::Private *IdleTimeoutInterface::d_func() const +void IdleTimeoutInterface::org_kde_kwin_idle_timeout_release(Resource *resource) { - return reinterpret_cast(d.data()); + wl_resource_destroy(resource->handle); } +void IdleTimeoutInterface::org_kde_kwin_idle_timeout_destroy_resource(Resource *resource) +{ + Q_UNUSED(resource) + delete this; +} + +void IdleTimeoutInterface::org_kde_kwin_idle_timeout_simulate_user_activity(Resource *resource) +{ + Q_UNUSED(resource) + simulateUserActivity(); +} +void IdleTimeoutInterface::simulateUserActivity() +{ + if (!timer) { + // not yet configured + return; + } + if (manager->isInhibited()) { + // ignored while inhibited + return; + } + if (!timer->isActive()) { + send_resumed(); + } + timer->start(); +} + +void IdleTimeoutInterface::setup(quint32 timeout) +{ + if (timer) { + return; + } + timer = new QTimer(this); + timer->setSingleShot(true); + // less than 5 sec is not idle by definition + timer->setInterval(qMax(timeout, 5000u)); + QObject::connect(timer, &QTimer::timeout, this, + [this] { + send_idle(); + } + ); + if (manager->isInhibited()) { + // don't start if inhibited + return; + } + timer->start(); +} } diff --git a/src/wayland/idle_interface.h b/src/wayland/idle_interface.h index a498d1df05..346c5b8d38 100644 --- a/src/wayland/idle_interface.h +++ b/src/wayland/idle_interface.h @@ -6,15 +6,17 @@ #ifndef KWAYLAND_SERVER_IDLE_INTERFACE_H #define KWAYLAND_SERVER_IDLE_INTERFACE_H +#include + #include -#include "global.h" -#include "resource.h" + +struct wl_resource; namespace KWaylandServer { class Display; -class SeatInterface; +class IdleInterfacePrivate; /** * @brief Global representing the org_kde_kwin_idle interface. @@ -36,11 +38,11 @@ class SeatInterface; * * @since 5.4 **/ -class KWAYLANDSERVER_EXPORT IdleInterface : public Global +class KWAYLANDSERVER_EXPORT IdleInterface : public QObject { Q_OBJECT public: - virtual ~IdleInterface(); + ~IdleInterface() override; /** * Inhibits the IdleInterface. While inhibited no IdleTimeoutInterface interface gets @@ -100,22 +102,7 @@ Q_SIGNALS: private: explicit IdleInterface(Display *display, QObject *parent = nullptr); friend class Display; - class Private; - Private *d_func() const; -}; - -// TODO: KF6 make private class -class KWAYLANDSERVER_EXPORT IdleTimeoutInterface : public Resource -{ - Q_OBJECT -public: - virtual ~IdleTimeoutInterface(); - -private: - explicit IdleTimeoutInterface(SeatInterface *seat, IdleInterface *parent, wl_resource *parentResource); - friend class IdleInterface; - class Private; - Private *d_func() const; + QScopedPointer d; }; } diff --git a/src/wayland/idle_interface_p.h b/src/wayland/idle_interface_p.h new file mode 100644 index 0000000000..48ef781d5e --- /dev/null +++ b/src/wayland/idle_interface_p.h @@ -0,0 +1,60 @@ +/* + SPDX-FileCopyrightText: 2015 Martin Gräßlin + + SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL +*/ +#ifndef KWAYLAND_SERVER_IDLE_INTERFACE_P_H +#define KWAYLAND_SERVER_IDLE_INTERFACE_P_H + +#include "idle_interface.h" + +#include + +#include + + +namespace KWaylandServer +{ + +class Display; +class SeatInterface; +class IdleTimeoutInterface; +class IdleTimeoutInterface; + +class IdleInterfacePrivate : public QtWaylandServer::org_kde_kwin_idle +{ +public: + IdleInterfacePrivate(IdleInterface *_q, Display *display); + + int inhibitCount = 0; + QVector idleTimeouts; + IdleInterface *q; + static const quint32 s_version; + +protected: + void org_kde_kwin_idle_get_idle_timeout(Resource *resource, uint32_t id, wl_resource *seat, uint32_t timeout) override; +}; + +class IdleTimeoutInterface : public QObject, QtWaylandServer::org_kde_kwin_idle_timeout +{ + Q_OBJECT +public: + explicit IdleTimeoutInterface(SeatInterface *seat, IdleInterface *parent, wl_resource *resource); + ~IdleTimeoutInterface() override; + void setup(quint32 timeout); + void simulateUserActivity(); + +private: + SeatInterface *seat; + IdleInterface *manager; + QTimer *timer = nullptr; + +protected: + void org_kde_kwin_idle_timeout_destroy_resource(Resource *resource) override; + void org_kde_kwin_idle_timeout_release(Resource *resource) override; + void org_kde_kwin_idle_timeout_simulate_user_activity(Resource *resource) override; +}; + +} + +#endif