qquickshapecurverenderer_p.h

Go to the documentation of this file.

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#ifndef QQUICKSHAPECURVERENDERER_P_H
#define QQUICKSHAPECURVERENDERER_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists for the convenience
// of a number of Qt sources files.  This header file may change from
// version to version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtQuickShapes/private/qquickshapesglobal_p.h>
#include <QtQuickShapes/private/qquickshape_p_p.h>
#include <QtQuick/private/qquadpath_p.h>
#include <QtQuick/private/qsgcurveabstractnode_p.h>
#include <QtQuick/private/qsggradientcache_p.h>
#include <qsgnode.h>
#include <qsggeometry.h>
#include <qsgmaterial.h>
#include <qsgrendererinterface.h>
#include <qsgtexture.h>
#include <QtCore/qrunnable.h>
#include <QRunnable>
 
#include <QtGui/private/qtriangulator_p.h>
#include <QtQuick/private/qsgcurvefillnode_p.h>
 
QT_BEGIN_NAMESPACE
 
class QQuickShapeCurveRunnable;
 
class Q_QUICKSHAPES_EXPORT QQuickShapeCurveRenderer : public QQuickAbstractPathRenderer
{
public:
    QQuickShapeCurveRenderer(QQuickItem *item)
        : m_item(item)
    { }
    ~QQuickShapeCurveRenderer() override;
 
    void beginSync(int totalCount, bool *countChanged) override;
    void setPath(int index, const QPainterPath &path, QQuickShapePath::PathHints pathHints = {}) override;
    void setStrokeColor(int index, const QColor &color) override;
    void setStrokeWidth(int index, qreal w) override;
    void setCosmeticStroke(int index, bool c) override;
    void setFillColor(int index, const QColor &color) override;
    void setFillRule(int index, QQuickShapePath::FillRule fillRule) override;
    void setJoinStyle(int index, QQuickShapePath::JoinStyle joinStyle, int miterLimit) override;
    void setCapStyle(int index, QQuickShapePath::CapStyle capStyle) override;
    void setStrokeStyle(int index, QQuickShapePath::StrokeStyle strokeStyle,
                        qreal dashOffset, const QList<qreal> &dashPattern) override;
    void setFillGradient(int index, QQuickShapeGradient *gradient) override;
    void setStrokeGradient(int index, QQuickShapeGradient *gradient) override;
    void setFillTextureProvider(int index, QQuickItem *textureProviderItem) override;
    void setFillTransform(int index, const QSGTransform &transform) override;
    void setVisible(int index, bool visible) override;
    void endSync(bool async) override;
    void setAsyncCallback(void (*)(void *), void *) override;
    Flags flags() const override { return SupportsAsync; }
    void handleSceneChange(QQuickWindow *window) override;
 
    void updateNode() override;
 
    void setRootNode(QSGNode *node);
    void clearNodeReferences();
 
    using NodeList = QList<QSGCurveAbstractNode *>;
 
    enum DirtyFlag
    {
        PathDirty = 0x01,
        FillDirty = 0x02,
        StrokeDirty = 0x04,
        UniformsDirty = 0x08
    };
 
    enum DebugVisualizationOption {
        NoDebug = 0,
        DebugCurves = 0x01,
        DebugWireframe = 0x02
    };
 
    static int debugVisualization();
    static void setDebugVisualization(int options);
 
private:
    struct PathData {
 
        bool isFillVisible() const
        {
            return visible
                    && (gradientType != QGradient::NoGradient
                        || fillTextureProviderItem != nullptr
                        || fillColor.alpha() > 0);
        }
 
        bool isStrokeVisible() const
        {
            return visible && validPenWidth && pen.style() != Qt::NoPen
                   && (pen.color().alpha() > 0 || strokeGradientType != QGradient::NoGradient);
        }
 
        QGradient::Type gradientType = QGradient::NoGradient;
        QSGGradientCache::GradientDesc gradient;
 
        QGradient::Type strokeGradientType = QGradient::NoGradient;
        QSGGradientCache::GradientDesc strokeGradient;
 
        QSGTransform fillTransform;
        QColor fillColor;
        Qt::FillRule fillRule = Qt::OddEvenFill;
        QPen pen;
        bool validPenWidth = true;
        bool visible = true;
        int m_dirty = 0;
        QQuickShapePath::PathHints pathHints;
 
        QPainterPath originalPath;
        QQuadPath path;
        QQuadPath fillPath;
 
        NodeList fillNodes;
        NodeList strokeNodes;
 
        QQuickShapeCurveRunnable *currentRunner = nullptr;
        QQuickItem *fillTextureProviderItem = nullptr;
    };
 
    void setUpRunner(PathData *pathData);
    void maybeUpdateAsyncItem();
 
    static void processPath(PathData *pathData);
    static NodeList addFillNodes(const QQuadPath &path);
    static NodeList addTriangulatingStrokerNodes(const QQuadPath &path, const QPen &pen);
    static NodeList addCurveStrokeNodes(const QQuadPath &path, const QPen &pen);
 
    QQuickItem *m_item;
    QSGNode *m_rootNode = nullptr;
    QList<PathData> m_paths;
    QList<PathData> m_removedPaths;
    void (*m_asyncCallback)(void *) = nullptr;
    void *m_asyncCallbackData = nullptr;
    static int debugVisualizationFlags;
 
    friend class QQuickShapeCurveRunnable;
};
 
class QQuickShapeCurveRunnable : public QObject, public QRunnable
{
    Q_OBJECT
 
public:
    ~QQuickShapeCurveRunnable() override;
    void run() override;
 
    bool isInitialized = false;
    bool isAsync = false;
    bool isDone = false;
    bool orphaned = false;
 
    // input / output
    QQuickShapeCurveRenderer::PathData pathData;
 
Q_SIGNALS:
    void done(QQuickShapeCurveRunnable *self);
};
 
QT_END_NAMESPACE
 
#endif // QQUICKSHAPECURVERENDERER_P_H