qquickpath_p.h

Go to the documentation of this file.

// 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 QQUICKPATH_H
#define QQUICKPATH_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 <private/qtquickglobal_p.h>
 
QT_REQUIRE_CONFIG(quick_path);
 
#include <qqml.h>
 
#include <private/qqmlnullablevalue_p.h>
#include <private/qlazilyallocated_p.h>
#include <private/qbezier_p.h>
#include <private/qtquickglobal_p.h>
 
#include <QtCore/QObject>
#include <QtCore/QDebug>
#include <QtCore/QHash>
#include <QtGui/QPainterPath>
#include <QtGui/QFont>
 
QT_BEGIN_NAMESPACE
 
class QQuickCurve;
class QQuickCurvePrivate;
 
struct QQuickPathData
{
    int index;
    QPointF endPoint;
    QList<QQuickCurve*> curves;
};
 
class Q_QUICK_EXPORT QQuickPathElement : public QObject
{
    Q_OBJECT
    QML_ANONYMOUS
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathElement(QObject *parent=nullptr) : QObject(parent) {}
Q_SIGNALS:
    void changed();
};
 
class Q_QUICK_EXPORT QQuickPathAttribute : public QQuickPathElement
{
    Q_OBJECT
 
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
    Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY valueChanged)
    QML_NAMED_ELEMENT(PathAttribute)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathAttribute(QObject *parent=nullptr) : QQuickPathElement(parent) {}
 
 
    QString name() const;
    void setName(const QString &name);
 
    qreal value() const;
    void setValue(qreal value);
 
Q_SIGNALS:
    void nameChanged();
    void valueChanged();
 
private:
    QString _name;
    qreal _value = 0;
};
 
class Q_QUICK_EXPORT QQuickCurve : public QQuickPathElement
{
    Q_OBJECT
 
    Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
    Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
    Q_PROPERTY(qreal relativeX READ relativeX WRITE setRelativeX NOTIFY relativeXChanged)
    Q_PROPERTY(qreal relativeY READ relativeY WRITE setRelativeY NOTIFY relativeYChanged)
    QML_ANONYMOUS
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickCurve(QObject *parent=nullptr) : QQuickPathElement(parent) {}
 
    qreal x() const;
    void setX(qreal x);
    bool hasX();
 
    qreal y() const;
    void setY(qreal y);
    bool hasY();
 
    qreal relativeX() const;
    void setRelativeX(qreal x);
    bool hasRelativeX();
 
    qreal relativeY() const;
    void setRelativeY(qreal y);
    bool hasRelativeY();
 
    virtual void addToPath(QPainterPath &, const QQuickPathData &) {}
 
Q_SIGNALS:
    void xChanged();
    void yChanged();
    void relativeXChanged();
    void relativeYChanged();
 
private:
#ifndef QT_NO_DEBUG_STREAM
    friend Q_QUICK_EXPORT QDebug operator<<(QDebug debug, const QQuickCurve *curve);
#endif
 
    QQmlNullableValue<qreal> _x;
    QQmlNullableValue<qreal> _y;
    QQmlNullableValue<qreal> _relativeX;
    QQmlNullableValue<qreal> _relativeY;
};
 
class Q_QUICK_EXPORT QQuickPathLine : public QQuickCurve
{
    Q_OBJECT
    QML_NAMED_ELEMENT(PathLine)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathLine(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
};
 
class Q_QUICK_EXPORT QQuickPathMove : public QQuickCurve
{
    Q_OBJECT
    QML_NAMED_ELEMENT(PathMove)
    QML_ADDED_IN_VERSION(2, 9)
public:
    QQuickPathMove(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
};
 
class Q_QUICK_EXPORT QQuickPathQuad : public QQuickCurve
{
    Q_OBJECT
 
    Q_PROPERTY(qreal controlX READ controlX WRITE setControlX NOTIFY controlXChanged)
    Q_PROPERTY(qreal controlY READ controlY WRITE setControlY NOTIFY controlYChanged)
    Q_PROPERTY(qreal relativeControlX READ relativeControlX WRITE setRelativeControlX NOTIFY relativeControlXChanged)
    Q_PROPERTY(qreal relativeControlY READ relativeControlY WRITE setRelativeControlY NOTIFY relativeControlYChanged)
 
    QML_NAMED_ELEMENT(PathQuad)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathQuad(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    qreal controlX() const;
    void setControlX(qreal x);
 
    qreal controlY() const;
    void setControlY(qreal y);
 
    qreal relativeControlX() const;
    void setRelativeControlX(qreal x);
    bool hasRelativeControlX();
 
    qreal relativeControlY() const;
    void setRelativeControlY(qreal y);
    bool hasRelativeControlY();
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void controlXChanged();
    void controlYChanged();
    void relativeControlXChanged();
    void relativeControlYChanged();
 
private:
    qreal _controlX = 0;
    qreal _controlY = 0;
    QQmlNullableValue<qreal> _relativeControlX;
    QQmlNullableValue<qreal> _relativeControlY;
};
 
class Q_QUICK_EXPORT QQuickPathCubic : public QQuickCurve
{
    Q_OBJECT
 
    Q_PROPERTY(qreal control1X READ control1X WRITE setControl1X NOTIFY control1XChanged)
    Q_PROPERTY(qreal control1Y READ control1Y WRITE setControl1Y NOTIFY control1YChanged)
    Q_PROPERTY(qreal control2X READ control2X WRITE setControl2X NOTIFY control2XChanged)
    Q_PROPERTY(qreal control2Y READ control2Y WRITE setControl2Y NOTIFY control2YChanged)
    Q_PROPERTY(qreal relativeControl1X READ relativeControl1X WRITE setRelativeControl1X NOTIFY relativeControl1XChanged)
    Q_PROPERTY(qreal relativeControl1Y READ relativeControl1Y WRITE setRelativeControl1Y NOTIFY relativeControl1YChanged)
    Q_PROPERTY(qreal relativeControl2X READ relativeControl2X WRITE setRelativeControl2X NOTIFY relativeControl2XChanged)
    Q_PROPERTY(qreal relativeControl2Y READ relativeControl2Y WRITE setRelativeControl2Y NOTIFY relativeControl2YChanged)
    QML_NAMED_ELEMENT(PathCubic)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathCubic(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    qreal control1X() const;
    void setControl1X(qreal x);
 
    qreal control1Y() const;
    void setControl1Y(qreal y);
 
    qreal control2X() const;
    void setControl2X(qreal x);
 
    qreal control2Y() const;
    void setControl2Y(qreal y);
 
    qreal relativeControl1X() const;
    void setRelativeControl1X(qreal x);
    bool hasRelativeControl1X();
 
    qreal relativeControl1Y() const;
    void setRelativeControl1Y(qreal y);
    bool hasRelativeControl1Y();
 
    qreal relativeControl2X() const;
    void setRelativeControl2X(qreal x);
    bool hasRelativeControl2X();
 
    qreal relativeControl2Y() const;
    void setRelativeControl2Y(qreal y);
    bool hasRelativeControl2Y();
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void control1XChanged();
    void control1YChanged();
    void control2XChanged();
    void control2YChanged();
    void relativeControl1XChanged();
    void relativeControl1YChanged();
    void relativeControl2XChanged();
    void relativeControl2YChanged();
 
private:
    qreal _control1X = 0;
    qreal _control1Y = 0;
    qreal _control2X = 0;
    qreal _control2Y = 0;
    QQmlNullableValue<qreal> _relativeControl1X;
    QQmlNullableValue<qreal> _relativeControl1Y;
    QQmlNullableValue<qreal> _relativeControl2X;
    QQmlNullableValue<qreal> _relativeControl2Y;
};
 
class Q_QUICK_EXPORT QQuickPathCatmullRomCurve : public QQuickCurve
{
    Q_OBJECT
    QML_NAMED_ELEMENT(PathCurve)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathCatmullRomCurve(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
};
 
class Q_QUICK_EXPORT QQuickPathArc : public QQuickCurve
{
    Q_OBJECT
    Q_PROPERTY(qreal radiusX READ radiusX WRITE setRadiusX NOTIFY radiusXChanged)
    Q_PROPERTY(qreal radiusY READ radiusY WRITE setRadiusY NOTIFY radiusYChanged)
    Q_PROPERTY(bool useLargeArc READ useLargeArc WRITE setUseLargeArc NOTIFY useLargeArcChanged)
    Q_PROPERTY(ArcDirection direction READ direction WRITE setDirection NOTIFY directionChanged)
    Q_PROPERTY(qreal xAxisRotation READ xAxisRotation WRITE setXAxisRotation NOTIFY xAxisRotationChanged REVISION(2, 9))
    QML_NAMED_ELEMENT(PathArc)
    QML_ADDED_IN_VERSION(2, 0)
 
public:
    QQuickPathArc(QObject *parent=nullptr)
        : QQuickCurve(parent) {}
 
    enum ArcDirection { Clockwise, Counterclockwise };
    Q_ENUM(ArcDirection)
 
    qreal radiusX() const;
    void setRadiusX(qreal);
 
    qreal radiusY() const;
    void setRadiusY(qreal);
 
    bool useLargeArc() const;
    void setUseLargeArc(bool);
 
    ArcDirection direction() const;
    void setDirection(ArcDirection direction);
 
    qreal xAxisRotation() const;
    void setXAxisRotation(qreal rotation);
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void radiusXChanged();
    void radiusYChanged();
    void useLargeArcChanged();
    void directionChanged();
    Q_REVISION(2, 9) void xAxisRotationChanged();
 
private:
    qreal _radiusX = 0;
    qreal _radiusY = 0;
    bool _useLargeArc = false;
    ArcDirection _direction = Clockwise;
    qreal _xAxisRotation = 0;
};
 
class Q_QUICK_EXPORT QQuickPathAngleArc : public QQuickCurve
{
    Q_OBJECT
    Q_PROPERTY(qreal centerX READ centerX WRITE setCenterX NOTIFY centerXChanged)
    Q_PROPERTY(qreal centerY READ centerY WRITE setCenterY NOTIFY centerYChanged)
    Q_PROPERTY(qreal radiusX READ radiusX WRITE setRadiusX NOTIFY radiusXChanged)
    Q_PROPERTY(qreal radiusY READ radiusY WRITE setRadiusY NOTIFY radiusYChanged)
    Q_PROPERTY(qreal startAngle READ startAngle WRITE setStartAngle NOTIFY startAngleChanged)
    Q_PROPERTY(qreal sweepAngle READ sweepAngle WRITE setSweepAngle NOTIFY sweepAngleChanged)
    Q_PROPERTY(bool moveToStart READ moveToStart WRITE setMoveToStart NOTIFY moveToStartChanged)
 
    QML_NAMED_ELEMENT(PathAngleArc)
    QML_ADDED_IN_VERSION(2, 11)
 
public:
    QQuickPathAngleArc(QObject *parent=nullptr)
        : QQuickCurve(parent) {}
 
    qreal centerX() const;
    void setCenterX(qreal);
 
    qreal centerY() const;
    void setCenterY(qreal);
 
    qreal radiusX() const;
    void setRadiusX(qreal);
 
    qreal radiusY() const;
    void setRadiusY(qreal);
 
    qreal startAngle() const;
    void setStartAngle(qreal);
 
    qreal sweepAngle() const;
    void setSweepAngle(qreal);
 
    bool moveToStart() const;
    void setMoveToStart(bool);
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void centerXChanged();
    void centerYChanged();
    void radiusXChanged();
    void radiusYChanged();
    void startAngleChanged();
    void sweepAngleChanged();
    void moveToStartChanged();
 
private:
    qreal _centerX = 0;
    qreal _centerY = 0;
    qreal _radiusX = 0;
    qreal _radiusY = 0;
    qreal _startAngle = 0;
    qreal _sweepAngle = 0;
    bool _moveToStart = true;
};
 
class Q_QUICK_EXPORT QQuickPathSvg : public QQuickCurve
{
    Q_OBJECT
    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
    QML_NAMED_ELEMENT(PathSvg)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathSvg(QObject *parent=nullptr) : QQuickCurve(parent) {}
 
    QString path() const;
    void setPath(const QString &path);
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void pathChanged();
 
private:
    QString _path;
};
 
class Q_QUICK_EXPORT QQuickPathRectangle : public QQuickCurve
{
    Q_OBJECT
 
    Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged FINAL)
    Q_PROPERTY(qreal height READ height WRITE setHeight NOTIFY heightChanged FINAL)
    Q_PROPERTY(qreal strokeAdjustment READ strokeAdjustment WRITE setStrokeAdjustment NOTIFY strokeAdjustmentChanged FINAL)
    Q_PROPERTY(qreal radius READ radius WRITE setRadius NOTIFY radiusChanged FINAL)
    Q_PROPERTY(qreal topLeftRadius READ topLeftRadius WRITE setTopLeftRadius RESET resetTopLeftRadius NOTIFY topLeftRadiusChanged FINAL)
    Q_PROPERTY(qreal topRightRadius READ topRightRadius WRITE setTopRightRadius NOTIFY topRightRadiusChanged RESET resetTopRightRadius FINAL)
    Q_PROPERTY(qreal bottomLeftRadius READ bottomLeftRadius WRITE setBottomLeftRadius NOTIFY bottomLeftRadiusChanged RESET resetBottomLeftRadius FINAL)
    Q_PROPERTY(qreal bottomRightRadius READ bottomRightRadius WRITE setBottomRightRadius NOTIFY bottomRightRadiusChanged RESET resetBottomRightRadius FINAL)
    Q_PROPERTY(bool bevel READ hasBevel WRITE setBevel NOTIFY bevelChanged FINAL REVISION(6, 10))
    Q_PROPERTY(bool topLeftBevel READ hasTopLeftBevel WRITE setTopLeftBevel NOTIFY topLeftBevelChanged RESET resetTopLeftBevel FINAL REVISION(6, 10))
    Q_PROPERTY(bool topRightBevel READ hasTopRightBevel WRITE setTopRightBevel NOTIFY topRightBevelChanged RESET resetTopRightBevel FINAL REVISION(6, 10))
    Q_PROPERTY(bool bottomLeftBevel READ hasBottomLeftBevel WRITE setBottomLeftBevel NOTIFY bottomLeftBevelChanged RESET resetBottomLeftBevel FINAL REVISION(6, 10))
    Q_PROPERTY(bool bottomRightBevel READ hasBottomRightBevel WRITE setBottomRightBevel NOTIFY bottomRightBevelChanged RESET resetBottomRightBevel FINAL REVISION(6, 10))
    Q_PROPERTY(CornerShape cornerShape READ cornerShape WRITE setCornerShape NOTIFY
                       cornerShapeChanged REVISION(6, 13))
    Q_PROPERTY(CornerShape topLeftCornerShape READ topLeftCornerShape WRITE setTopLeftCornerShape
                       RESET resetTopLeftCornerShape NOTIFY topLeftCornerShapeChanged REVISION(6,
                                                                                               13))
    Q_PROPERTY(CornerShape topRightCornerShape READ topRightCornerShape WRITE setTopRightCornerShape
                       RESET resetTopRightCornerShape NOTIFY topRightCornerShapeChanged
                               REVISION(6, 13))
    Q_PROPERTY(CornerShape bottomLeftCornerShape READ bottomLeftCornerShape WRITE
                       setBottomLeftCornerShape RESET resetBottomLeftCornerShape NOTIFY
                               bottomLeftCornerShapeChanged REVISION(6, 13))
    Q_PROPERTY(CornerShape bottomRightCornerShape READ bottomRightCornerShape WRITE
                       setBottomRightCornerShape RESET resetBottomRightCornerShape NOTIFY
                               bottomRightCornerShapeChanged REVISION(6, 13))
 
    QML_NAMED_ELEMENT(PathRectangle)
    QML_ADDED_IN_VERSION(6, 8)
public:
    enum CornerShape { Rounded, Bevel, Squircle };
    Q_ENUM(CornerShape)
 
    QQuickPathRectangle(QObject *parent = nullptr) : QQuickCurve(parent) {}
 
    qreal width() const;
    void setWidth(qreal width);
 
    qreal height() const;
    void setHeight(qreal height);
 
    qreal strokeAdjustment() const;
    void setStrokeAdjustment(qreal newStrokeAdjustment);
 
    qreal radius() const;
    void setRadius(qreal newRadius);
 
    qreal topLeftRadius() const { return cornerRadius(Qt::TopLeftCorner); }
    void setTopLeftRadius(qreal radius) { setCornerRadius(Qt::TopLeftCorner, radius); }
    void resetTopLeftRadius() { resetCornerRadius(Qt::TopLeftCorner); }
 
    qreal topRightRadius() const { return cornerRadius(Qt::TopRightCorner); }
    void setTopRightRadius(qreal radius) { setCornerRadius(Qt::TopRightCorner, radius); }
    void resetTopRightRadius() { resetCornerRadius(Qt::TopRightCorner); }
 
    qreal bottomLeftRadius() const { return cornerRadius(Qt::BottomLeftCorner); }
    void setBottomLeftRadius(qreal radius) { setCornerRadius(Qt::BottomLeftCorner, radius); }
    void resetBottomLeftRadius() { resetCornerRadius(Qt::BottomLeftCorner); }
 
    qreal bottomRightRadius() const { return cornerRadius(Qt::BottomRightCorner); }
    void setBottomRightRadius(qreal radius) { setCornerRadius(Qt::BottomRightCorner, radius); }
    void resetBottomRightRadius() { resetCornerRadius(Qt::BottomRightCorner); }
 
    qreal cornerRadius(Qt::Corner corner) const;
    void setCornerRadius(Qt::Corner corner, qreal newCornerRadius);
    void resetCornerRadius(Qt::Corner corner);
 
    bool hasBevel() const;
    void setBevel(bool bevel);
 
    bool hasTopLeftBevel() const { return cornerBevel(Qt::TopLeftCorner); }
    void setTopLeftBevel(bool bevel) { setCornerBevel(Qt::TopLeftCorner, bevel); }
    void resetTopLeftBevel() { resetCornerBevel(Qt::TopLeftCorner); }
 
    bool hasTopRightBevel() const { return cornerBevel(Qt::TopRightCorner); }
    void setTopRightBevel(bool bevel) { setCornerBevel(Qt::TopRightCorner, bevel); }
    void resetTopRightBevel() { resetCornerBevel(Qt::TopRightCorner); }
 
    bool hasBottomLeftBevel() const { return cornerBevel(Qt::BottomLeftCorner); }
    void setBottomLeftBevel(bool bevel) { setCornerBevel(Qt::BottomLeftCorner, bevel); }
    void resetBottomLeftBevel() { resetCornerBevel(Qt::BottomLeftCorner); }
 
    bool hasBottomRightBevel() const { return cornerBevel(Qt::BottomRightCorner); }
    void setBottomRightBevel(bool bevel) { setCornerBevel(Qt::BottomRightCorner, bevel); }
    void resetBottomRightBevel() { resetCornerBevel(Qt::BottomRightCorner); }
 
    bool cornerBevel(Qt::Corner corner) const;
    void setCornerBevel(Qt::Corner corner, bool newCornerBevel);
    void resetCornerBevel(Qt::Corner corner);
 
    CornerShape cornerShape() const;
    void setCornerShape(CornerShape shape);
 
    CornerShape topLeftCornerShape() const { return cornerShape(Qt::TopLeftCorner); }
    void setTopLeftCornerShape(CornerShape shape) { setCornerShape(Qt::TopLeftCorner, shape); }
    void resetTopLeftCornerShape() { resetCornerShape(Qt::TopLeftCorner); }
 
    CornerShape topRightCornerShape() const { return cornerShape(Qt::TopRightCorner); }
    void setTopRightCornerShape(CornerShape shape) { setCornerShape(Qt::TopRightCorner, shape); }
    void resetTopRightCornerShape() { resetCornerShape(Qt::TopRightCorner); }
 
    CornerShape bottomLeftCornerShape() const { return cornerShape(Qt::BottomLeftCorner); }
    void setBottomLeftCornerShape(CornerShape shape)
    {
        setCornerShape(Qt::BottomLeftCorner, shape);
    }
    void resetBottomLeftCornerShape() { resetCornerShape(Qt::BottomLeftCorner); }
 
    CornerShape bottomRightCornerShape() const { return cornerShape(Qt::BottomRightCorner); }
    void setBottomRightCornerShape(CornerShape shape)
    {
        setCornerShape(Qt::BottomRightCorner, shape);
    }
    void resetBottomRightCornerShape() { resetCornerShape(Qt::BottomRightCorner); }
 
    CornerShape cornerShape(Qt::Corner corner) const;
    void setCornerShape(Qt::Corner corner, CornerShape newCornerShape);
    void resetCornerShape(Qt::Corner corner);
 
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void widthChanged();
    void heightChanged();
    void strokeAdjustmentChanged();
    void radiusChanged();
    void topLeftRadiusChanged();
    void topRightRadiusChanged();
    void bottomLeftRadiusChanged();
    void bottomRightRadiusChanged();
    Q_REVISION(6, 10) void bevelChanged();
    Q_REVISION(6, 10) void topLeftBevelChanged();
    Q_REVISION(6, 10) void topRightBevelChanged();
    Q_REVISION(6, 10) void bottomLeftBevelChanged();
    Q_REVISION(6, 10) void bottomRightBevelChanged();
    Q_REVISION(6, 13) void cornerShapeChanged();
    Q_REVISION(6, 13) void topLeftCornerShapeChanged();
    Q_REVISION(6, 13) void topRightCornerShapeChanged();
    Q_REVISION(6, 13) void bottomLeftCornerShapeChanged();
    Q_REVISION(6, 13) void bottomRightCornerShapeChanged();
 
private:
    void emitCornerRadiusChanged(Qt::Corner corner);
    void emitCornerShapeChanged(Qt::Corner corner, bool oldBevel);
 
    qreal _width = 0;
    qreal _height = 0;
    qreal _strokeAdjustment = 0;
    struct ExtraData
    {
        qreal radius = 0;
        CornerShape shape = Rounded;
 
        struct IndividualCornerData
        {
            IndividualCornerData() : shape(Rounded), isRadiusSet(0), isShapeSet(0) { }
            qreal radius = 0;
            unsigned shape : 4;
            unsigned isRadiusSet : 1;
            unsigned isShapeSet : 1;
        };
 
        IndividualCornerData cornerData[4];
        inline bool isRadiusSet(Qt::Corner corner) {
            return cornerData[corner].isRadiusSet;
        };
        inline bool isShapeSet(Qt::Corner corner)
        {
            return cornerData[corner].isShapeSet;
        };
    };
    QLazilyAllocated<ExtraData> _extra;
};
 
class Q_QUICK_EXPORT QQuickPathPercent : public QQuickPathElement
{
    Q_OBJECT
    Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY valueChanged)
    QML_NAMED_ELEMENT(PathPercent)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPathPercent(QObject *parent=nullptr) : QQuickPathElement(parent) {}
 
    qreal value() const;
    void setValue(qreal value);
 
Q_SIGNALS:
    void valueChanged();
 
private:
    qreal _value = 0;
};
 
class Q_QUICK_EXPORT QQuickPathPolyline : public QQuickCurve
{
    Q_OBJECT
    Q_PROPERTY(QPointF start READ start NOTIFY startChanged)
    Q_PROPERTY(QVariant path READ path WRITE setPath NOTIFY pathChanged)
    QML_NAMED_ELEMENT(PathPolyline)
    QML_ADDED_IN_VERSION(2, 14)
public:
    QQuickPathPolyline(QObject *parent=nullptr);
 
    QVariant path() const;
    void setPath(const QVariant &path);
    void setPath(const QList<QPointF> &path);
    QPointF start() const;
    void addToPath(QPainterPath &path, const QQuickPathData &data) override;
 
Q_SIGNALS:
    void pathChanged();
    void startChanged();
 
private:
    QList<QPointF> m_path;
};
 
class Q_QUICK_EXPORT QQuickPathMultiline : public QQuickCurve
{
    Q_OBJECT
    Q_PROPERTY(QPointF start READ start NOTIFY startChanged)
    Q_PROPERTY(QVariant paths READ paths WRITE setPaths NOTIFY pathsChanged)
    QML_NAMED_ELEMENT(PathMultiline)
    QML_ADDED_IN_VERSION(2, 14)
public:
    QQuickPathMultiline(QObject *parent=nullptr);
 
    QVariant paths() const;
    void setPaths(const QVariant &paths);
    void setPaths(const QList<QList<QPointF>> &paths);
    QPointF start() const;
    void addToPath(QPainterPath &path, const QQuickPathData &) override;
 
Q_SIGNALS:
    void pathsChanged();
    void startChanged();
 
private:
    QPointF absolute(const QPointF &relative) const;
 
    QList<QList<QPointF>> m_paths;
};
 
struct QQuickCachedBezier
{
    QQuickCachedBezier() {}
    QBezier bezier;
    int element;
    qreal bezLength;
    qreal currLength;
    qreal p;
    bool isValid = false;
};
 
class QQuickPathPrivate;
class Q_QUICK_EXPORT QQuickPath : public QObject, public QQmlParserStatus
{
    Q_OBJECT
 
    Q_INTERFACES(QQmlParserStatus)
    Q_PROPERTY(QQmlListProperty<QQuickPathElement> pathElements READ pathElements)
    Q_PROPERTY(qreal startX READ startX WRITE setStartX NOTIFY startXChanged)
    Q_PROPERTY(qreal startY READ startY WRITE setStartY NOTIFY startYChanged)
    Q_PROPERTY(bool closed READ isClosed NOTIFY changed)
    Q_PROPERTY(bool simplify READ simplify WRITE setSimplify NOTIFY simplifyChanged REVISION(6, 6) FINAL)
    Q_PROPERTY(QSizeF scale READ scale WRITE setScale NOTIFY scaleChanged VIRTUAL REVISION(2, 14))
    Q_PROPERTY(bool asynchronous READ isAsynchronous WRITE setAsynchronous NOTIFY asynchronousChanged REVISION(6, 9))
    Q_CLASSINFO("DefaultProperty", "pathElements")
    QML_NAMED_ELEMENT(Path)
    QML_ADDED_IN_VERSION(2, 0)
public:
    QQuickPath(QObject *parent=nullptr);
    ~QQuickPath() override;
 
    QQmlListProperty<QQuickPathElement> pathElements();
 
    qreal startX() const;
    void setStartX(qreal x);
    bool hasStartX() const;
 
    qreal startY() const;
    void setStartY(qreal y);
    bool hasStartY() const;
 
    bool isClosed() const;
 
    QPainterPath path() const;
    void setPath(const QPainterPath &path);
 
    QStringList attributes() const;
    qreal attributeAt(const QString &, qreal) const;
    Q_REVISION(2, 14) Q_INVOKABLE QPointF pointAtPercent(qreal t) const;
    QPointF sequentialPointAt(qreal p, qreal *angle = nullptr) const;
    void invalidateSequentialHistory() const;
 
    QSizeF scale() const;
    void setScale(const QSizeF &scale);
 
    bool simplify() const;
    void setSimplify(bool s);
 
    bool isAsynchronous() const;
    void setAsynchronous(bool a);
 
public Q_SLOTS:
    // This is public in order to allow types from DesignHelpers to create and add path
    // elements and process the path once at the end rather than after each element.
    void processPath();
 
Q_SIGNALS:
    void changed();
    void startXChanged();
    void startYChanged();
    Q_REVISION(6, 6) void simplifyChanged();
    Q_REVISION(2, 14) void scaleChanged();
    Q_REVISION(6, 9) void asynchronousChanged();
 
protected:
    QQuickPath(QQuickPathPrivate &dd, QObject *parent = nullptr);
    void componentComplete() override;
    void classBegin() override;
    void disconnectPathElements();
    void connectPathElements();
    void gatherAttributes();
 
    // pathElements property
    static QQuickPathElement *pathElements_at(QQmlListProperty<QQuickPathElement> *, qsizetype);
    static void pathElements_append(QQmlListProperty<QQuickPathElement> *, QQuickPathElement *);
    static qsizetype pathElements_count(QQmlListProperty<QQuickPathElement> *);
    static void pathElements_clear(QQmlListProperty<QQuickPathElement> *);
    static void pathElements_replace(
            QQmlListProperty<QQuickPathElement> *, qsizetype, QQuickPathElement *);
    static void pathElements_removeLast(QQmlListProperty<QQuickPathElement> *);
 
private:
    struct AttributePoint {
        AttributePoint() {}
        AttributePoint(const AttributePoint &other)
            : percent(other.percent), scale(other.scale), origpercent(other.origpercent), values(other.values) {}
        AttributePoint &operator=(const AttributePoint &other) {
            percent = other.percent; scale = other.scale; origpercent = other.origpercent; values = other.values; return *this;
        }
        qreal percent = 0;      //massaged percent along the painter path
        qreal scale = 1;
        qreal origpercent = 0;  //'real' percent along the painter path
        QHash<QString, qreal> values;
    };
 
    void doProcessPath();
    void interpolate(int idx, const QString &name, qreal value);
    void endpoint(const QString &name);
    void createPointCache() const;
 
    static void interpolate(QList<AttributePoint> &points, int idx, const QString &name, qreal value);
    static void endpoint(QList<AttributePoint> &attributePoints, const QString &name);
    static QPointF forwardsPointAt(const QPainterPath &path, const qreal &pathLength, const QList<AttributePoint> &attributePoints, QQuickCachedBezier &prevBez, qreal p, qreal *angle = nullptr);
    static QPointF backwardsPointAt(const QPainterPath &path, const qreal &pathLength, const QList<AttributePoint> &attributePoints, QQuickCachedBezier &prevBez, qreal p, qreal *angle = nullptr);
 
private:
    Q_DISABLE_COPY(QQuickPath)
    Q_DECLARE_PRIVATE(QQuickPath)
    friend class QQuickPathAnimationUpdater;
 
public:
    QPainterPath createPath(const QPointF &startPoint, const QPointF &endPoint, const QStringList &attributes, qreal &pathLength, QList<AttributePoint> &attributePoints, bool *closed = nullptr);
    QPainterPath createShapePath(const QPointF &startPoint, const QPointF &endPoint, qreal &pathLength, bool *closed = nullptr);
    static QPointF sequentialPointAt(const QPainterPath &path, const qreal &pathLength, const QList<AttributePoint> &attributePoints, QQuickCachedBezier &prevBez, qreal p, qreal *angle = nullptr);
};
 
class Q_QUICK_EXPORT QQuickPathText : public QQuickPathElement
{
    Q_OBJECT
    Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
    Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
    Q_PROPERTY(qreal width READ width NOTIFY changed)
    Q_PROPERTY(qreal height READ height NOTIFY changed)
    Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)
    Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontChanged)
    QML_NAMED_ELEMENT(PathText)
    QML_ADDED_IN_VERSION(2, 15)
public:
    QQuickPathText(QObject *parent=nullptr) : QQuickPathElement(parent)
    {
        connect(this, &QQuickPathText::xChanged, this, &QQuickPathElement::changed);
        connect(this, &QQuickPathText::yChanged, this, &QQuickPathElement::changed);
        connect(this, &QQuickPathText::textChanged, this, &QQuickPathElement::changed);
        connect(this, &QQuickPathText::fontChanged, this, &QQuickPathElement::changed);
 
        connect(this, &QQuickPathElement::changed, this, &QQuickPathText::invalidate);
    }
 
    void addToPath(QPainterPath &path);
 
    qreal x() const { return _x; }
    qreal y() const { return _y; }
    QString text() const { return _text; }
    QFont font() const { return _font; }
 
    void setX(qreal x)
    {
        if (qFuzzyCompare(_x, x))
            return;
 
        _x = x;
        Q_EMIT xChanged();
    }
 
    void setY(qreal y)
    {
        if (qFuzzyCompare(_y, y))
            return;
 
        _y = y;
        Q_EMIT yChanged();
    }
 
    void setText(const QString &text)
    {
        if (text == _text)
            return;
 
        _text = text;
        Q_EMIT textChanged();
    }
 
    void setFont(const QFont &font)
    {
        if (font == _font)
            return;
 
        _font = font;
        Q_EMIT fontChanged();
    }
 
    qreal width() const
    {
        updatePath();
        return _path.boundingRect().width();
    }
 
    qreal height() const
    {
        updatePath();
        return _path.boundingRect().height();
    }
 
Q_SIGNALS:
    void xChanged();
    void yChanged();
    void textChanged();
    void fontChanged();
 
private Q_SLOTS:
    void invalidate()
    {
        _path.clear();
    }
 
private:
    void updatePath() const;
 
    QString _text;
    qreal _x = qreal(0.0);
    qreal _y = qreal(0.0);
    QFont _font;
 
    mutable QPainterPath _path;
};
 
QT_END_NAMESPACE
 
#endif // QQUICKPATH_H