File indexing completed on 2024-12-22 05:09:20

 /*
     SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 #include "dpms.h"
 #include "event_queue.h"
 #include "output.h"
 #include "wayland_pointer_p.h"
 
 #include <wayland-client-protocol.h>
 #include <wayland-dpms-client-protocol.h>
 
 namespace KWayland
 {
 namespace Client
 {
 class Q_DECL_HIDDEN DpmsManager::Private
 {
 public:
     WaylandPointer<org_kde_kwin_dpms_manager, org_kde_kwin_dpms_manager_destroy> manager;
     EventQueue *queue = nullptr;
 };
 
 DpmsManager::DpmsManager(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
 }
 
 DpmsManager::~DpmsManager()
 {
     release();
 }
 
 void DpmsManager::release()
 {
     d->manager.release();
 }
 
 void DpmsManager::destroy()
 {
     d->manager.destroy();
 }
 
 bool DpmsManager::isValid() const
 {
     return d->manager.isValid();
 }
 
 void DpmsManager::setup(org_kde_kwin_dpms_manager *manager)
 {
     Q_ASSERT(manager);
     Q_ASSERT(!d->manager.isValid());
     d->manager.setup(manager);
 }
 
 EventQueue *DpmsManager::eventQueue()
 {
     return d->queue;
 }
 
 void DpmsManager::setEventQueue(EventQueue *queue)
 {
     d->queue = queue;
 }
 
 Dpms *DpmsManager::getDpms(Output *output, QObject *parent)
 {
     Q_ASSERT(isValid());
     Q_ASSERT(output);
     Dpms *dpms = new Dpms(output, parent);
     auto w = org_kde_kwin_dpms_manager_get(d->manager, *output);
     if (d->queue) {
         d->queue->addProxy(w);
     }
     dpms->setup(w);
     return dpms;
 }
 
 DpmsManager::operator org_kde_kwin_dpms_manager *() const
 {
     return d->manager;
 }
 
 DpmsManager::operator org_kde_kwin_dpms_manager *()
 {
     return d->manager;
 }
 
 class Q_DECL_HIDDEN Dpms::Private
 {
 public:
     explicit Private(const QPointer<Output> &output, Dpms *q);
     void setup(org_kde_kwin_dpms *d);
 
     WaylandPointer<org_kde_kwin_dpms, org_kde_kwin_dpms_release> dpms;
     struct Data {
         bool supported = false;
         Mode mode = Mode::On;
         bool supportedChanged = false;
         bool modeChanged = false;
     };
     Data current;
     Data pending;
     QPointer<Output> output;
 
 private:
     static void supportedCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms, uint32_t supported);
     static void modeCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms, uint32_t mode);
     static void doneCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms);
     static const struct org_kde_kwin_dpms_listener s_listener;
 
     Dpms *q;
 };
 
 #ifndef K_DOXYGEN
 const org_kde_kwin_dpms_listener Dpms::Private::s_listener = {supportedCallback, modeCallback, doneCallback};
 #endif
 
 void Dpms::Private::supportedCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms, uint32_t supported)
 {
     Q_UNUSED(org_kde_kwin_dpms)
     Private *p = reinterpret_cast<Private *>(data);
     p->pending.supported = supported == 0 ? false : true;
     p->pending.supportedChanged = true;
 }
 
 void Dpms::Private::modeCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms, uint32_t mode)
 {
     Q_UNUSED(org_kde_kwin_dpms)
     Mode m;
     switch (mode) {
     case ORG_KDE_KWIN_DPMS_MODE_ON:
         m = Mode::On;
         break;
     case ORG_KDE_KWIN_DPMS_MODE_STANDBY:
         m = Mode::Standby;
         break;
     case ORG_KDE_KWIN_DPMS_MODE_SUSPEND:
         m = Mode::Suspend;
         break;
     case ORG_KDE_KWIN_DPMS_MODE_OFF:
         m = Mode::Off;
         break;
     default:
         return;
     }
     Private *p = reinterpret_cast<Private *>(data);
     p->pending.mode = m;
     p->pending.modeChanged = true;
 }
 
 void Dpms::Private::doneCallback(void *data, org_kde_kwin_dpms *org_kde_kwin_dpms)
 {
     Q_UNUSED(org_kde_kwin_dpms)
     Private *p = reinterpret_cast<Private *>(data);
     const bool supportedChanged = p->pending.supportedChanged && p->pending.supported != p->current.supported;
     const bool modeChanged = p->pending.modeChanged && p->pending.mode != p->current.mode;
     if (supportedChanged) {
         p->current.supported = p->pending.supported;
         Q_EMIT p->q->supportedChanged();
     }
     if (modeChanged) {
         p->current.mode = p->pending.mode;
         Q_EMIT p->q->modeChanged();
     }
     p->pending = Data();
 }
 
 Dpms::Private::Private(const QPointer<Output> &output, Dpms *q)
     : output(output)
     , q(q)
 {
 }
 
 void Dpms::Private::setup(org_kde_kwin_dpms *d)
 {
     Q_ASSERT(d);
     Q_ASSERT(!dpms.isValid());
     dpms.setup(d);
     org_kde_kwin_dpms_add_listener(dpms, &s_listener, this);
 }
 
 Dpms::Dpms(const QPointer<Output> &o, QObject *parent)
     : QObject(parent)
     , d(new Private(o, this))
 {
 }
 
 Dpms::~Dpms()
 {
     release();
 }
 
 void Dpms::destroy()
 {
     d->dpms.destroy();
 }
 
 void Dpms::release()
 {
     d->dpms.release();
 }
 
 bool Dpms::isValid() const
 {
     return d->dpms.isValid();
 }
 
 void Dpms::setup(org_kde_kwin_dpms *dpms)
 {
     d->setup(dpms);
 }
 
 bool Dpms::isSupported() const
 {
     return d->current.supported;
 }
 
 Dpms::Mode Dpms::mode() const
 {
     return d->current.mode;
 }
 
 void Dpms::requestMode(Dpms::Mode mode)
 {
     uint32_t wlMode;
     switch (mode) {
     case Mode::On:
         wlMode = ORG_KDE_KWIN_DPMS_MODE_ON;
         break;
     case Mode::Standby:
         wlMode = ORG_KDE_KWIN_DPMS_MODE_STANDBY;
         break;
     case Mode::Suspend:
         wlMode = ORG_KDE_KWIN_DPMS_MODE_SUSPEND;
         break;
     case Mode::Off:
         wlMode = ORG_KDE_KWIN_DPMS_MODE_OFF;
         break;
     default:
         Q_UNREACHABLE();
     }
     org_kde_kwin_dpms_set(d->dpms, wlMode);
 }
 
 QPointer<Output> Dpms::output() const
 {
     return d->output;
 }
 
 Dpms::operator org_kde_kwin_dpms *()
 {
     return d->dpms;
 }
 
 Dpms::operator org_kde_kwin_dpms *() const
 {
     return d->dpms;
 }
 
 }
 }
 
 #include "moc_dpms.cpp"