/src/compositor/compositor_api/qwaylandquickhardwarelayer.cpp

/****************************************************************************
**
** Copyright (C) 2018 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the plugins of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qwaylandquickhardwarelayer_p.h"

#include <QtWaylandCompositor/private/qwlhardwarelayerintegration_p.h>
#include <QtWaylandCompositor/private/qwlhardwarelayerintegrationfactory_p.h>

#include <QtCore/private/qobject_p.h>
#include <QMatrix4x4>

QT_BEGIN_NAMESPACE

class QWaylandQuickHardwareLayerPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QWaylandQuickHardwareLayer)
public:
    QtWayland::HardwareLayerIntegration *layerIntegration();
    QWaylandQuickItem *m_waylandItem = nullptr;
    int m_stackingLevel = 0;
    QMatrix4x4 m_matrixFromRenderThread;
    static QtWayland::HardwareLayerIntegration *s_hardwareLayerIntegration;
};

QtWayland::HardwareLayerIntegration *QWaylandQuickHardwareLayerPrivate::s_hardwareLayerIntegration = nullptr;

QtWayland::HardwareLayerIntegration *QWaylandQuickHardwareLayerPrivate::layerIntegration()
{
    if (!s_hardwareLayerIntegration) {
        QStringList keys = QtWayland::HardwareLayerIntegrationFactory::keys();

        QString environmentKey = QString::fromLocal8Bit(qgetenv("QT_WAYLAND_HARDWARE_LAYER_INTEGRATION").constData());
        if (!environmentKey.isEmpty()) {
            if (keys.contains(environmentKey)) {
                s_hardwareLayerIntegration = QtWayland::HardwareLayerIntegrationFactory::create(environmentKey, QStringList());
            } else {
                qWarning() << "Unknown hardware layer integration:" << environmentKey
                           << "Valid layer integrations are" << keys;
            }
        } else if (!keys.isEmpty()) {
            s_hardwareLayerIntegration = QtWayland::HardwareLayerIntegrationFactory::create(keys.first(), QStringList());
        } else {
            qWarning() << "No wayland hardware layer integrations found";
        }
    }

    return s_hardwareLayerIntegration;
}

/*!
 * \qmltype WaylandHardwareLayer
 * \inqmlmodule QtWayland.Compositor
 * \preliminary
 * \brief Makes a parent WaylandQuickItem use hardware layers for rendering.
 *
 * This item needs to be a descendant of a WaylandQuickItem or a derivative,
 * (i.e. ShellSurfaceItem or similar)
 *
 * The Surface of the parent WaylandQuickItem will be drawn in a hardware specific way instead
 * of the regular way using the QtQuick scene graph. On some platforms, the WaylandQuickItem's
 * current buffer and the scene graph can be blended in a separate step. This makes it possible for
 * clients to update continuously without triggering a full redraw of the compositor scene graph for
 * each frame.
 *
 * The preferred hardware layer integration may be overridden by setting the
 * QT_WAYLAND_HARDWARE_LAYER_INTEGRATION environment variable.
 */

QWaylandQuickHardwareLayer::QWaylandQuickHardwareLayer(QObject *parent)
    : QObject(*new QWaylandQuickHardwareLayerPrivate(), parent)
{
}

QWaylandQuickHardwareLayer::~QWaylandQuickHardwareLayer()
{
    Q_D(QWaylandQuickHardwareLayer);
    if (d->layerIntegration())
        d->layerIntegration()->remove(this);
}

/*!
 * \qmlproperty int QtWaylandCompositor::WaylandHardwareLayer::stackingLevel
 *
 * This property holds the stacking level of this hardware layer relative to other hardware layers,
 * and can be used to sort hardware layers. I.e. a layer with a higher level is rendered on top of
 * one with a lower level.
 *
 * Layers with level 0 will be drawn in an implementation defined order on top of the compositor
 * scene graph.
 *
 * Layers with a level below 0 are drawn beneath the compositor scene graph, if supported by the
 * hardware layer integration.
 */
int QWaylandQuickHardwareLayer::stackingLevel() const
{
    Q_D(const QWaylandQuickHardwareLayer);
    return d->m_stackingLevel;
}

void QWaylandQuickHardwareLayer::setStackingLevel(int level)
{
    Q_D(QWaylandQuickHardwareLayer);
    if (level == d->m_stackingLevel)
        return;

    d->m_stackingLevel = level;
    emit stackingLevelChanged();
}

QWaylandQuickItem *QWaylandQuickHardwareLayer::waylandItem() const
{
    Q_D(const QWaylandQuickHardwareLayer);
    return d->m_waylandItem;
}

void QWaylandQuickHardwareLayer::classBegin()
{
    Q_D(QWaylandQuickHardwareLayer);
    for (QObject *p = parent(); p != nullptr; p = p->parent()) {
        if (auto *waylandItem = qobject_cast<QWaylandQuickItem *>(p)) {
            d->m_waylandItem = waylandItem;
            break;
        }
    }
}

void QWaylandQuickHardwareLayer::componentComplete()
{
    Q_D(QWaylandQuickHardwareLayer);
    Q_ASSERT(d->m_waylandItem);
    if (auto integration = d->layerIntegration())
        integration->add(this);
    else
        qWarning() << "No hardware layer integration. WaylandHarwareLayer has no effect.";
}

void QWaylandQuickHardwareLayer::setSceneGraphPainting(bool enable)
{
    waylandItem()->setPaintEnabled(enable);
}

// This should be called if QWaylandQuickHardwareLayer used as a native instance, not a qml component.
void QWaylandQuickHardwareLayer::initialize()
{
    classBegin();
    componentComplete();
}

QT_END_NAMESPACE