qquickshape_p_p.h - mozsearch

Enable keyboard shortcuts

// Copyright (C) 2016 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 QQUICKSHAPE_P_P_H

#define QQUICKSHAPE_P_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  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.h>

#include <private/qquickitem_p.h>

#include <private/qsgtransform_p.h>

#include <QPainterPath>

#include <QColor>

#include <QBrush>

#include <QElapsedTimer>

#if QT_CONFIG(opengl)

# include <private/qopenglcontext_p.h>

#endif

QT_BEGIN_NAMESPACE

class QSGPlainTexture;

class QRhi;

class QQuickAbstractPathRenderer

public:

    enum Flag {

        SupportsAsync = 0x01

};

    Q_DECLARE_FLAGS(Flags, Flag)

    enum FillGradientType { NoGradient = 0, LinearGradient, RadialGradient, ConicalGradient };

    virtual ~QQuickAbstractPathRenderer() { }

    // Gui thread

    virtual void beginSync(int totalCount, bool *countChanged) = 0;

    virtual void endSync(bool async) = 0;

    virtual void setAsyncCallback(void (*)(void *), void *) { }

    virtual Flags flags() const { return {}; }

    virtual void setPath(int index, const QQuickPath *path);

    virtual void setPath(int index, const QPainterPath &path, QQuickShapePath::PathHints pathHints = {}) = 0;

    virtual void setStrokeColor(int index, const QColor &color) = 0;

    virtual void setStrokeWidth(int index, qreal w) = 0;

    virtual void setCosmeticStroke(int index, bool c) = 0;

    virtual void setJoinStyle(int index, QQuickShapePath::JoinStyle joinStyle, int miterLimit) = 0;

    virtual void setCapStyle(int index, QQuickShapePath::CapStyle capStyle) = 0;

    virtual void setStrokeStyle(int index, QQuickShapePath::StrokeStyle strokeStyle,

                                qreal dashOffset, const QList<qreal> &dashPattern) = 0;

    virtual void setFillColor(int index, const QColor &color) = 0;

    virtual void setFillRule(int index, QQuickShapePath::FillRule fillRule) = 0;

    virtual void setFillGradient(int index, QQuickShapeGradient *gradient) = 0;

    virtual void setStrokeGradient(int index, QQuickShapeGradient *gradient) = 0;

    virtual void setFillTextureProvider(int index, QQuickItem *textureProviderItem) = 0;

    virtual void setFillTransform(int index, const QSGTransform &transform) = 0;

    virtual void setTriangulationScale(int, qreal) { }

    virtual void setVisible(int index, bool visible) = 0;

    virtual void handleSceneChange(QQuickWindow *window) = 0;

    // Render thread, with gui blocked

    virtual void updateNode() = 0;

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickAbstractPathRenderer::Flags)

inline void QQuickAbstractPathRenderer::setPath(int index, const QQuickPath *path)

    QQuickShapePath::PathHints hints;

    QPainterPath newPath = path ? path->path() : QPainterPath();

    if (const auto *shapePath = qobject_cast<const QQuickShapePath *>(path)) {

        hints = shapePath->pathHints();

        if (shapePath->hasTrim()) {

            const QQuickShapeTrim *trim = const_cast<QQuickShapePath *>(shapePath)->trim();

            newPath = path->path().trimmed(trim->start(), trim->end(), trim->offset());

    setPath(index, newPath, hints);

struct QQuickShapeStrokeFillParams

    QQuickShapeStrokeFillParams();

    QColor strokeColor;

    qreal strokeWidth;

    QColor fillColor;

    QQuickShapePath::FillRule fillRule;

    QQuickShapePath::JoinStyle joinStyle;

    int miterLimit;

    QQuickShapePath::CapStyle capStyle;

    QQuickShapePath::StrokeStyle strokeStyle;

    bool cosmeticStroke = false;

    qreal dashOffset;

    QList<qreal> dashPattern;

    QQuickShapeGradient *fillGradient;

    QQuickShapeGradient *strokeGradient;

    QSGTransform fillTransform;

    QQuickItem *fillItem;

    QQuickShapeTrim *trim;

    bool visible = true;

};

class Q_QUICKSHAPES_EXPORT QQuickShapePathPrivate : public QQuickPathPrivate

    Q_DECLARE_PUBLIC(QQuickShapePath)

public:

    enum Dirty {

        DirtyPath = 0x01,

        DirtyStrokeColor = 0x02,

        DirtyStrokeWidth = 0x04,

        DirtyFillColor = 0x08,

        DirtyFillRule = 0x10,

        DirtyStyle = 0x20,

        DirtyDash = 0x40,

        DirtyFillGradient = 0x80,

        DirtyFillTransform = 0x100,

        DirtyFillItem = 0x200,

        DirtyTrim = 0x400,

        DirtyStrokeGradient = 0x800,

        DirtyVisible = 0x1000,

        DirtyAll = 0x1FFF

};

    QQuickShapePathPrivate();

    void _q_pathChanged();

    void _q_fillGradientChanged();

    void _q_strokeGradientChanged();

    void _q_fillItemDestroyed();

    void handleSceneChange();

    void writeToDebugStream(QDebug &debug) const override;

    static QQuickShapePathPrivate *get(QQuickShapePath *p) { return p->d_func(); }

    int dirty;

    QQuickShapeStrokeFillParams sfp;

    QQuickShapePath::PathHints pathHints;

};

class Q_QUICKSHAPES_EXPORT QQuickShapePrivate : public QQuickItemPrivate

    Q_DECLARE_PUBLIC(QQuickShape)

public:

    QQuickShapePrivate();

    ~QQuickShapePrivate();

    void init();

    QQuickShape::RendererType selectRendererType();

    void createRenderer();

    QSGNode *createNode();

    void sync();

    void _q_shapePathChanged();

    void setStatus(QQuickShape::Status newStatus);

    void handleSceneChange(QQuickWindow *w);

    static QQuickShapePrivate *get(QQuickShape *item) { return item->d_func(); }

    static void asyncShapeReady(void *data);

    qreal getImplicitWidth() const override;

    qreal getImplicitHeight() const override;

    int effectRefCount;

    QList<QQuickShapePath *> sp;

    QElapsedTimer syncTimer;

    QQuickAbstractPathRenderer *renderer = nullptr;

    int syncTimingTotalDirty = 0;

    int syncTimeCounter = 0;

    QQuickShape::Status status = QQuickShape::Null;

    QQuickShape::RendererType rendererType = QQuickShape::UnknownRenderer;

    QQuickShape::RendererType preferredType = QQuickShape::UnknownRenderer;

    QQuickShape::ContainsMode containsMode = QQuickShape::BoundingRectContains;

    QQuickShape::FillMode fillMode = QQuickShape::NoResize;

    QQuickShape::HAlignment horizontalAlignment = QQuickShape::AlignLeft;

    QQuickShape::VAlignment verticalAlignment = QQuickShape::AlignTop;

    bool spChanged = false;

    bool rendererChanged = false;

    bool async = false;

    bool enableVendorExts = false;

    bool syncTimingActive = false;

    qreal triangulationScale = 1.0;

};

QT_END_NAMESPACE

#endif