relativepointer.cpp

/*
    SPDX-FileCopyrightText: 2016 Martin Gräßlin <[email protected]>

    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#include "relativepointer.h"
#include "event_queue.h"
#include "pointer.h"
#include "wayland_pointer_p.h"
#include <QSizeF>
#include <wayland-relativepointer-unstable-v1-client-protocol.h>

namespace KWayland
{
namespace Client
{
class Q_DECL_HIDDEN RelativePointerManager::Private
{
public:
    Private() = default;

    WaylandPointer<zwp_relative_pointer_manager_v1, zwp_relative_pointer_manager_v1_destroy> relativepointermanagerunstablev1;
    EventQueue *queue = nullptr;
};

RelativePointerManager::RelativePointerManager(QObject *parent)
    : QObject(parent)
    , d(new Private)
{
}

RelativePointerManager::~RelativePointerManager()
{
    release();
}

void RelativePointerManager::setup(zwp_relative_pointer_manager_v1 *relativepointermanagerunstablev1)
{
    Q_ASSERT(relativepointermanagerunstablev1);
    Q_ASSERT(!d->relativepointermanagerunstablev1);
    d->relativepointermanagerunstablev1.setup(relativepointermanagerunstablev1);
}

void RelativePointerManager::release()
{
    d->relativepointermanagerunstablev1.release();
}

void RelativePointerManager::destroy()
{
    d->relativepointermanagerunstablev1.destroy();
}

void RelativePointerManager::setEventQueue(EventQueue *queue)
{
    d->queue = queue;
}

EventQueue *RelativePointerManager::eventQueue()
{
    return d->queue;
}

RelativePointerManager::operator zwp_relative_pointer_manager_v1 *()
{
    return d->relativepointermanagerunstablev1;
}

RelativePointerManager::operator zwp_relative_pointer_manager_v1 *() const
{
    return d->relativepointermanagerunstablev1;
}

bool RelativePointerManager::isValid() const
{
    return d->relativepointermanagerunstablev1.isValid();
}

RelativePointer *RelativePointerManager::createRelativePointer(Pointer *pointer, QObject *parent)
{
    Q_ASSERT(isValid());
    RelativePointer *p = new RelativePointer(parent);
    auto w = zwp_relative_pointer_manager_v1_get_relative_pointer(d->relativepointermanagerunstablev1, *pointer);
    if (d->queue) {
        d->queue->addProxy(w);
    }
    p->setup(w);
    return p;
}

class Q_DECL_HIDDEN RelativePointer::Private
{
public:
    Private(RelativePointer *q);

    void setup(zwp_relative_pointer_v1 *relativepointerunstablev1);

    WaylandPointer<zwp_relative_pointer_v1, zwp_relative_pointer_v1_destroy> relativepointerunstablev1;

private:
    static void relativeMotionCallback(void *data,
                                       zwp_relative_pointer_v1 *zwp_relative_pointer_v1,
                                       uint32_t utime_hi,
                                       uint32_t utime_lo,
                                       wl_fixed_t dx,
                                       wl_fixed_t dy,
                                       wl_fixed_t dx_unaccel,
                                       wl_fixed_t dy_unaccel);

    RelativePointer *q;

    static const zwp_relative_pointer_v1_listener s_listener;
};

RelativePointer::Private::Private(RelativePointer *q)
    : q(q)
{
}

const zwp_relative_pointer_v1_listener RelativePointer::Private::s_listener = {relativeMotionCallback};

void RelativePointer::Private::relativeMotionCallback(void *data,
                                                      zwp_relative_pointer_v1 *zwp_relative_pointer_v1,
                                                      uint32_t utime_hi,
                                                      uint32_t utime_lo,
                                                      wl_fixed_t dx,
                                                      wl_fixed_t dy,
                                                      wl_fixed_t dx_unaccel,
                                                      wl_fixed_t dy_unaccel)
{
    auto p = reinterpret_cast<RelativePointer::Private *>(data);
    Q_ASSERT(p->relativepointerunstablev1 == zwp_relative_pointer_v1);
    const QSizeF delta(wl_fixed_to_double(dx), wl_fixed_to_double(dy));
    const QSizeF deltaNonAccel(wl_fixed_to_double(dx_unaccel), wl_fixed_to_double(dy_unaccel));
    const quint64 timestamp = quint64(utime_lo) | (quint64(utime_hi) << 32);
    Q_EMIT p->q->relativeMotion(delta, deltaNonAccel, timestamp);
}

void RelativePointer::Private::setup(zwp_relative_pointer_v1 *v1)
{
    Q_ASSERT(v1);
    Q_ASSERT(!relativepointerunstablev1);
    relativepointerunstablev1.setup(v1);
    zwp_relative_pointer_v1_add_listener(relativepointerunstablev1, &s_listener, this);
}

RelativePointer::RelativePointer(QObject *parent)
    : QObject(parent)
    , d(new Private(this))
{
}

RelativePointer::~RelativePointer()
{
    release();
}

void RelativePointer::setup(zwp_relative_pointer_v1 *relativepointerunstablev1)
{
    d->setup(relativepointerunstablev1);
}

void RelativePointer::release()
{
    d->relativepointerunstablev1.release();
}

void RelativePointer::destroy()
{
    d->relativepointerunstablev1.destroy();
}

RelativePointer::operator zwp_relative_pointer_v1 *()
{
    return d->relativepointerunstablev1;
}

RelativePointer::operator zwp_relative_pointer_v1 *() const
{
    return d->relativepointerunstablev1;
}

bool RelativePointer::isValid() const
{
    return d->relativepointerunstablev1.isValid();
}

}
}