qwaylandxdgoutputv1.cpp

Go to the documentation of this file.

// Copyright (C) 2019 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include <QWaylandCompositor>
 
#include "qwaylandxdgoutputv1_p.h"
#include "qwaylandoutput_p.h"
 
#include <wayland-server.h>
 
QT_BEGIN_NAMESPACE
 
QWaylandXdgOutputManagerV1::QWaylandXdgOutputManagerV1()
    : QWaylandCompositorExtensionTemplate<QWaylandXdgOutputManagerV1>(*new QWaylandXdgOutputManagerV1Private())
{
}
 
QWaylandXdgOutputManagerV1::QWaylandXdgOutputManagerV1(QWaylandCompositor *compositor)
    : QWaylandCompositorExtensionTemplate<QWaylandXdgOutputManagerV1>(compositor, *new QWaylandXdgOutputManagerV1Private())
{
}
 
// QWaylandXdgOutputManagerV1Private
 
void QWaylandXdgOutputManagerV1::initialize()
{
    Q_D(QWaylandXdgOutputManagerV1);
 
    QWaylandCompositorExtensionTemplate::initialize();
    QWaylandCompositor *compositor = static_cast<QWaylandCompositor *>(extensionContainer());
    if (!compositor) {
        qCWarning(qLcWaylandCompositor) << "Failed to find QWaylandCompositor when initializing QWaylandXdgOutputManagerV1";
        return;
    }
    d->init(compositor->display(), d->interfaceVersion());
}
 
const wl_interface *QWaylandXdgOutputManagerV1::interface()
{
    return QWaylandXdgOutputManagerV1Private::interface();
}
 
// QWaylandXdgOutputManagerV1Private
 
void QWaylandXdgOutputManagerV1Private::registerXdgOutput(QWaylandOutput *output, QWaylandXdgOutputV1 *xdgOutput)
{
    if (!xdgOutputs.contains(output)) {
        xdgOutputs[output] = xdgOutput;
        QWaylandOutputPrivate::get(output)->xdgOutput = xdgOutput;
    }
}
 
void QWaylandXdgOutputManagerV1Private::unregisterXdgOutput(QWaylandOutput *output)
{
    xdgOutputs.remove(output);
}
 
void QWaylandXdgOutputManagerV1Private::zxdg_output_manager_v1_get_xdg_output(Resource *resource,
                                                                              uint32_t id,
                                                                              wl_resource *outputResource)
{
    Q_Q(QWaylandXdgOutputManagerV1);
 
    // Verify if the associated output exist
    auto *output = QWaylandOutput::fromResource(outputResource);
    if (!output) {
        qCWarning(qLcWaylandCompositor,
                  "The client is requesting a QWaylandXdgOutputV1 for a "
                  "QWaylandOutput that doesn't exist");
        wl_resource_post_error(resource->handle, WL_DISPLAY_ERROR_INVALID_OBJECT, "output not found");
        return;
    }
 
    // Do we have a QWaylandXdgOutputV1 for this output?
    if (!xdgOutputs.contains(output)) {
        qCWarning(qLcWaylandCompositor,
                  "The client is requesting a QWaylandXdgOutputV1 that the compositor "
                  "didn't create before");
        wl_resource_post_error(resource->handle, WL_DISPLAY_ERROR_INVALID_OBJECT,
                               "compositor didn't create a QWaylandXdgOutputV1 for this zxdg_output_v1 object");
        return;
    }
 
    // Bind QWaylandXdgOutputV1 and initialize
    auto *xdgOutput = xdgOutputs[output];
    auto *xdgOutputPrivate = QWaylandXdgOutputV1Private::get(xdgOutput);
    Q_ASSERT(xdgOutputPrivate);
    xdgOutputPrivate->setManager(q);
    xdgOutputPrivate->setOutput(output);
    xdgOutputPrivate->add(resource->client(), id, qMin(resource->version(), QWaylandXdgOutputV1Private::interfaceVersion()));
}
 
// QWaylandXdgOutputV1
 
QWaylandXdgOutputV1::QWaylandXdgOutputV1()
    : QObject(*new QWaylandXdgOutputV1Private)
{
}
 
QWaylandXdgOutputV1::QWaylandXdgOutputV1(QWaylandOutput *output, QWaylandXdgOutputManagerV1 *manager)
    : QObject(*new QWaylandXdgOutputV1Private)
{
    Q_D(QWaylandXdgOutputV1);
 
    // Set members before emitting changed signals so that handlers will
    // see both already set and not nullptr, avoiding potential crashes
    d->manager = manager;
    d->output = output;
 
    QWaylandXdgOutputManagerV1Private::get(d->manager)->registerXdgOutput(output, this);
 
    emit managerChanged();
    emit outputChanged();
}
 
QWaylandXdgOutputV1::~QWaylandXdgOutputV1()
{
    Q_D(QWaylandXdgOutputV1);
 
    if (d->manager)
        QWaylandXdgOutputManagerV1Private::get(d->manager)->unregisterXdgOutput(d->output);
}
 
QWaylandXdgOutputManagerV1 *QWaylandXdgOutputV1::manager() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->manager;
}
 
QWaylandOutput *QWaylandXdgOutputV1::output() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->output;
}
 
QString QWaylandXdgOutputV1::name() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->name;
}
 
void QWaylandXdgOutputV1::setName(const QString &name)
{
    Q_D(QWaylandXdgOutputV1);
 
    if (d->name == name)
        return;
 
    // Can't change after clients bound to xdg-output
    if (d->initialized) {
        qCWarning(qLcWaylandCompositor, "QWaylandXdgOutputV1::name cannot be changed after initialization");
        return;
    }
 
    d->name = name;
    emit nameChanged();
}
 
QString QWaylandXdgOutputV1::description() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->description;
}
 
void QWaylandXdgOutputV1::setDescription(const QString &description)
{
    Q_D(QWaylandXdgOutputV1);
 
    if (d->description == description)
        return;
 
    // Can't change after clients bound to xdg-output
    if (d->initialized) {
        qCWarning(qLcWaylandCompositor, "QWaylandXdgOutputV1::description cannot be changed after initialization");
        return;
    }
 
    d->description = description;
    emit descriptionChanged();
}
 
QPoint QWaylandXdgOutputV1::logicalPosition() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->logicalPos;
}
 
void QWaylandXdgOutputV1::setLogicalPosition(const QPoint &position)
{
    Q_D(QWaylandXdgOutputV1);
 
    if (d->logicalPos == position)
        return;
 
    d->logicalPos = position;
    if (d->initialized) {
        d->sendLogicalPosition(position);
        d->sendDone();
    }
    emit logicalPositionChanged();
    emit logicalGeometryChanged();
}
 
QSize QWaylandXdgOutputV1::logicalSize() const
{
    Q_D(const QWaylandXdgOutputV1);
    return d->logicalSize;
}
 
void QWaylandXdgOutputV1::setLogicalSize(const QSize &size)
{
    Q_D(QWaylandXdgOutputV1);
 
    if (d->logicalSize == size)
        return;
 
    d->logicalSize = size;
    if (d->initialized) {
        d->sendLogicalSize(size);
        d->sendDone();
    }
    emit logicalSizeChanged();
    emit logicalGeometryChanged();
}
 
QRect QWaylandXdgOutputV1::logicalGeometry() const
{
    Q_D(const QWaylandXdgOutputV1);
    return QRect(d->logicalPos, d->logicalSize);
}
 
// QWaylandXdgOutputV1Private
 
void QWaylandXdgOutputV1Private::sendLogicalPosition(const QPoint &position)
{
    const auto values = resourceMap().values();
    for (auto *resource : values)
        send_logical_position(resource->handle, position.x(), position.y());
    needToSendDone = true;
}
 
void QWaylandXdgOutputV1Private::sendLogicalSize(const QSize &size)
{
    const auto values = resourceMap().values();
    for (auto *resource : values)
        send_logical_size(resource->handle, size.width(), size.height());
    needToSendDone = true;
}
 
void QWaylandXdgOutputV1Private::sendDone()
{
    if (needToSendDone) {
        const auto values = resourceMap().values();
        for (auto *resource : values) {
            if (resource->version() < 3)
                send_done(resource->handle);
        }
        needToSendDone = false;
    }
}
 
void QWaylandXdgOutputV1Private::setManager(QWaylandXdgOutputManagerV1 *_manager)
{
    Q_Q(QWaylandXdgOutputV1);
 
    if (!_manager) {
        qCWarning(qLcWaylandCompositor,
                  "Cannot associate a null QWaylandXdgOutputManagerV1 to QWaylandXdgOutputV1 %p", this);
        return;
    }
 
    if (manager == _manager)
        return;
 
    if (manager) {
        qCWarning(qLcWaylandCompositor,
                  "Cannot associate a different QWaylandXdgOutputManagerV1 to QWaylandXdgOutputV1 %p "
                  "after initialization", this);
        return;
    }
 
    manager = _manager;
    emit q->managerChanged();
}
 
void QWaylandXdgOutputV1Private::setOutput(QWaylandOutput *_output)
{
    Q_Q(QWaylandXdgOutputV1);
 
    if (!_output) {
        qCWarning(qLcWaylandCompositor,
                  "Cannot associate a null QWaylandOutput to QWaylandXdgOutputV1 %p", this);
        return;
    }
 
    if (output == _output)
        return;
 
    if (output) {
        qCWarning(qLcWaylandCompositor,
                  "Cannot associate a different QWaylandOutput to QWaylandXdgOutputV1 %p "
                  "after initialization", this);
        return;
    }
 
    // Assign output above manager, to make both values valid in handlers
    output = _output;
 
    if (!manager) {
        // Try to find the manager from the output parents
        for (auto *p = output->parent(); p != nullptr; p = p->parent()) {
            if (auto *m = qobject_cast<QWaylandXdgOutputManagerV1 *>(p)) {
                manager = m;
                emit q->managerChanged();
                break;
            }
        }
    }
 
    emit q->outputChanged();
 
    // Register the output
    if (manager)
        QWaylandXdgOutputManagerV1Private::get(manager)->registerXdgOutput(output, q);
}
 
void QWaylandXdgOutputV1Private::zxdg_output_v1_bind_resource(Resource *resource)
{
    send_logical_position(resource->handle, logicalPos.x(), logicalPos.y());
    send_logical_size(resource->handle, logicalSize.width(), logicalSize.height());
    if (resource->version() >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION)
        send_name(resource->handle, name);
    if (resource->version() >= ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION)
        send_description(resource->handle, description);
    send_done(resource->handle);
 
    initialized = true;
}
 
void QWaylandXdgOutputV1Private::zxdg_output_v1_destroy(Resource *resource)
{
    wl_resource_destroy(resource->handle);
}
 
QT_END_NAMESPACE
 
#include "moc_qwaylandxdgoutputv1.cpp"