qwaylandview.cpp

Go to the documentation of this file.

// Copyright (C) 2017 Jolla Ltd, author: <giulio.camuffo@jollamobile.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qwaylandview.h"
#include "qwaylandview_p.h"
#include "qwaylandsurface.h"
#include <QtWaylandCompositor/QWaylandSeat>
#include <QtWaylandCompositor/QWaylandCompositor>
 
#include <QtWaylandCompositor/private/qwaylandsurface_p.h>
#include <QtWaylandCompositor/private/qwaylandoutput_p.h>
 
#include <QtCore/QMutex>
 
QT_BEGIN_NAMESPACE
 
void QWaylandViewPrivate::markSurfaceAsDestroyed(QWaylandSurface *surface)
{
    Q_Q(QWaylandView);
    Q_ASSERT(surface == this->surface);
 
    setSurface(nullptr);
    QPointer<QWaylandView> deleteGuard(q);
    emit q->surfaceDestroyed();
    if (!deleteGuard.isNull())
        clearFrontBuffer();
}
 
QWaylandView::QWaylandView(QObject *renderObject, QObject *parent)
    : QObject(*new QWaylandViewPrivate(),parent)
{
    d_func()->renderObject = renderObject;
}
 
QWaylandView::~QWaylandView()
{
    Q_D(QWaylandView);
    if (d->surface) {
        if (d->output)
            QWaylandOutputPrivate::get(d->output)->removeView(this, d->surface);
 
        QWaylandSurfacePrivate::get(d->surface)->derefView(this);
    }
 
}
 
QObject *QWaylandView::renderObject() const
{
    Q_D(const QWaylandView);
    return d->renderObject;
}
 
QWaylandSurface *QWaylandView::surface() const
{
    Q_D(const QWaylandView);
    return d->surface;
}
 
 
void QWaylandViewPrivate::setSurface(QWaylandSurface *newSurface)
{
    Q_Q(QWaylandView);
    if (surface) {
        QWaylandSurfacePrivate::get(surface)->derefView(q);
        if (output)
            QWaylandOutputPrivate::get(output)->removeView(q, surface);
    }
 
    surface = newSurface;
 
    nextBuffer = QWaylandBufferRef();
    nextBufferCommitted = false;
    nextDamage = QRegion();
 
    if (surface) {
        QWaylandSurfacePrivate::get(surface)->refView(q);
        if (output)
            QWaylandOutputPrivate::get(output)->addView(q, surface);
    }
}
 
void QWaylandViewPrivate::clearFrontBuffer()
{
    if (!bufferLocked) {
        currentBuffer = QWaylandBufferRef();
        currentDamage = QRegion();
    }
}
 
void QWaylandView::setSurface(QWaylandSurface *newSurface)
{
    Q_D(QWaylandView);
    if (d->surface == newSurface)
        return;
 
    d->setSurface(newSurface);
    d->clearFrontBuffer();
    emit surfaceChanged();
}
 
QWaylandOutput *QWaylandView::output() const
{
    Q_D(const QWaylandView);
    return d->output;
}
 
void QWaylandView::setOutput(QWaylandOutput *newOutput)
{
    Q_D(QWaylandView);
    if (d->output == newOutput)
        return;
 
    if (d->output && d->surface)
        QWaylandOutputPrivate::get(d->output)->removeView(this, d->surface);
 
    d->output = newOutput;
 
    if (d->output && d->surface)
        QWaylandOutputPrivate::get(d->output)->addView(this, d->surface);
 
    emit outputChanged();
}
 
void QWaylandView::bufferCommitted(const QWaylandBufferRef &buffer, const QRegion &damage)
{
    Q_D(QWaylandView);
    QMutexLocker locker(&d->bufferMutex);
    d->nextBuffer = buffer;
    d->nextDamage = damage;
    d->nextBufferCommitted = true;
}
 
bool QWaylandView::advance()
{
    Q_D(QWaylandView);
 
    if (!d->nextBufferCommitted && !d->forceAdvanceSucceed)
        return false;
 
    if (d->bufferLocked)
        return false;
 
    if (d->surface && d->surface->primaryView() == this) {
        const auto views = d->surface->views();
        for (QWaylandView *view : views) {
            if (view != this && view->allowDiscardFrontBuffer() && view->d_func()->currentBuffer == d->currentBuffer)
                view->discardCurrentBuffer();
        }
    }
 
    QMutexLocker locker(&d->bufferMutex);
    d->forceAdvanceSucceed = false;
    d->nextBufferCommitted = false;
    d->currentBuffer = d->nextBuffer;
    d->currentDamage = d->nextDamage;
    return true;
}
 
void QWaylandView::discardCurrentBuffer()
{
    Q_D(QWaylandView);
    QMutexLocker locker(&d->bufferMutex);
    d->currentBuffer = QWaylandBufferRef();
    d->forceAdvanceSucceed = true;
}
 
QWaylandBufferRef QWaylandView::currentBuffer()
{
    Q_D(QWaylandView);
    QMutexLocker locker(&d->bufferMutex);
    return d->currentBuffer;
}
 
QRegion QWaylandView::currentDamage()
{
    Q_D(QWaylandView);
    QMutexLocker locker(&d->bufferMutex);
    return d->currentDamage;
}
 
bool QWaylandView::isBufferLocked() const
{
    Q_D(const QWaylandView);
    return d->bufferLocked;
}
 
void QWaylandView::setBufferLocked(bool locked)
{
    Q_D(QWaylandView);
    if (d->bufferLocked == locked)
        return;
    d->bufferLocked = locked;
    emit bufferLockedChanged();
}
bool QWaylandView::allowDiscardFrontBuffer() const
{
    Q_D(const QWaylandView);
    return d->allowDiscardFrontBuffer;
}
 
void QWaylandView::setAllowDiscardFrontBuffer(bool discard)
{
    Q_D(QWaylandView);
    if (d->allowDiscardFrontBuffer == discard)
        return;
    d->allowDiscardFrontBuffer = discard;
    emit allowDiscardFrontBufferChanged();
}
 
void QWaylandView::setPrimary()
{
    Q_D(QWaylandView);
    if (d->surface)
        d->surface->setPrimaryView(this);
    else
        qWarning("Calling setPrimary() on a QWaylandView without a surface has no effect.");
}
 
bool QWaylandView::isPrimary() const
{
    Q_D(const QWaylandView);
    return d->surface && d->surface->primaryView() == this;
}
 
struct wl_resource *QWaylandView::surfaceResource() const
{
    Q_D(const QWaylandView);
    if (!d->surface)
        return nullptr;
    return d->surface->resource();
}
 
QT_END_NAMESPACE
 
#include "moc_qwaylandview.cpp"