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

#include "qquickellipseshape_p.h"
#include "qquickellipseshape_p_p.h"
#include <algorithm>
#include <QtMath>

QT_BEGIN_NAMESPACE

namespace {
inline bool is_equal(qreal a, qreal b, qreal epsilon = DBL_EPSILON)
{
    return std::fabs(a - b) <= epsilon;
}

inline qreal arc_angle(qreal angle)
{
    return angle - 90;
}

inline QVector2D arc_point(QVector2D center, QVector2D radius, qreal angle)
{
    return QVector2D(center.x() + radius.x() * qCos(qDegreesToRadians(angle)),
                     center.y() + radius.y() * qSin(qDegreesToRadians(angle)));
}

// counter-clockwise
inline QVector2D tangent_ccw(QVector2D radius, qreal angle)
{
    return QVector2D(-radius.x() * qSin(qDegreesToRadians(angle)),
                     radius.y() * qCos(qDegreesToRadians(angle)));
}

inline qreal cross(QVector2D a, QVector2D b)
{
    return a.x() * b.y() - a.y() * b.x();
}

// cross product of two vectors defined by points A->B x C->D
inline qreal cross(QVector2D a, QVector2D b, QVector2D c, QVector2D d)
{
    return cross(b - a, d - c);
}

qreal angle_between_vectors(QVector2D a, QVector2D b)
{
    const QVector2D uA = a.normalized();
    const QVector2D uB = b.normalized();
    const qreal angle = qAtan2(cross(uA, uB), QVector2D::dotProduct(uA, uB));
    if (std::fabs(angle) < FLT_EPSILON)
        return 0.0f;
    return angle;
}

// the intersection point can be calculated as C + T * (D - C) or A + S * (B - A)
bool lines_intersect(QVector2D a, QVector2D b, QVector2D c, QVector2D d, qreal *s, qreal *t)
{
    // lines undefined
    if ((a.x() == b.x() && a.y() == b.y()) || (c.x() == d.x() && c.y() == d.y()))
        return false;

    const qreal denom = cross(a, b, c, d);

    // lines are parallel or overlap
    if (denom == 0)
        return false;

    if (s != nullptr)
        *s = cross(c, d, c, a) / denom;
    if (t != nullptr)
        *t = cross(a, b, c, a) / denom;

    return true;
}
} // namespace

QQuickEllipseShapePrivate::QQuickEllipseShapePrivate() = default;

QQuickEllipseShapePrivate::~QQuickEllipseShapePrivate() = default;

void QQuickEllipseShapePrivate::addLine(QVector2D point)
{
    auto line = new QQuickPathLine(path);
    line->setX(point.x());
    line->setY(point.y());
    QQuickPathPrivate::get(path)->appendPathElement(line);
}

void QQuickEllipseShapePrivate::addArc(QVector2D point, QVector2D arcRadius,
                                       QQuickPathArc::ArcDirection dir, bool largeArc)
{
    auto arc = new QQuickPathArc(path);
    arc->setX(point.x());
    arc->setY(point.y());
    arc->setRadiusX(arcRadius.x());
    arc->setRadiusY(arcRadius.y());
    arc->setDirection(dir);
    arc->setUseLargeArc(largeArc);
    QQuickPathPrivate::get(path)->appendPathElement(arc);
}

qreal QQuickEllipseShapePrivate::getBorderOffset() const
{
    if (QQuickEllipseShape::BorderMode::Middle == borderMode)
        return 0;
    else if (QQuickEllipseShape::BorderMode::Outside == borderMode)
        return -path->strokeWidth() * 0.5;
    return path->strokeWidth() * 0.5f; // inside
}

void QQuickEllipseShapePrivate::roundCenter(QVector2D center, QVector2D ellipseRadius)
{
    const qreal endAngle = arc_angle(startAngle + sweepAngle);
    const QVector2D endPoint = arc_point(center, ellipseRadius, endAngle);
    const qreal beginAngle = arc_angle(startAngle);
    const QVector2D beginPoint = arc_point(center, ellipseRadius, beginAngle);

    const QVector2D AB = endPoint - center;
    const QVector2D AC = beginPoint - center;

    const qreal a = angle_between_vectors(AB, AC);
    const qreal halfAngle = std::fabs(a) * 0.5f;

    const qreal maxCornerRadius = (std::min(AB.length(), AC.length()) * 0.5f) * qTan(halfAngle);
    const qreal corner_radius = std::min(cornerRadius, maxCornerRadius);

    // calculate B and C based on the corner radius
    const qreal edgeOffset = corner_radius / qTan(halfAngle);
    const QVector2D B = center + (AB.normalized() * edgeOffset);
    const QVector2D C = center + (AC.normalized() * edgeOffset);

    // update
    auto &rc = roundedCorners[RoundedCornerIndex::Center];
    rc.A = center;
    rc.B = B;
    rc.C = C;
    rc.alpha = a;
    rc.radius = corner_radius;
}

void QQuickEllipseShapePrivate::roundBeginEnd(QVector2D center, QVector2D ellipseRadius)
{
    qreal deg = 0.0f;
    const qreal endAngle = startAngle + sweepAngle;
    bool e_outer = false, b_outer = false, e_inner = false, b_inner = false;
    while (deg < 45.0f) {
        deg += 1.0f;
        if (e_outer && b_outer && e_inner && b_inner)
            break;
        if (!b_outer)
            b_outer = roundOuter(center, ellipseRadius, deg, startAngle, endAngle,
                                 RoundedCornerIndex::OuterBegin);
        if (!e_outer)
            e_outer = roundOuter(center, ellipseRadius, deg, endAngle, startAngle,
                                 RoundedCornerIndex::OuterEnd);
        if (!e_inner)
            e_inner = roundInner(center, ellipseRadius, deg, endAngle, startAngle,
                                 RoundedCornerIndex::InnerEnd);
        if (!b_inner)
            b_inner = roundInner(center, ellipseRadius, deg, startAngle, endAngle,
                                 RoundedCornerIndex::InnerBegin);
    }
}

bool QQuickEllipseShapePrivate::roundOuter(QVector2D center, QVector2D ellipseRadius, qreal deg,
                                           qreal arcAngle1, qreal arcAngle2,
                                           RoundedCornerIndex index)
{
    bool done = false;

    const qreal arcAngle = arc_angle(arcAngle1);
    const QVector2D arcPoint = arc_point(center, ellipseRadius, arcAngle);

    const qreal angle = arcAngle1 > arcAngle2 ? arcAngle - deg : arcAngle + deg;

    const QVector2D B = arc_point(center, ellipseRadius, angle); // point on arc

    // calculate tangent vector
    const QVector2D uV = tangent_ccw(ellipseRadius, angle).normalized();
    const QVector2D b1 = B + uV;

    qreal s = 0, t = 0;
    bool res = lines_intersect(center, arcPoint, B, b1, &s, &t);
    if (res) {
        const QVector2D A = center + s * (arcPoint - center);

        const QVector2D AB = B - A;
        const QVector2D AC = center - A;

        const qreal a = angle_between_vectors(AB, AC);
        const qreal halfAngle = std::fabs(a) * 0.5;
        const qreal edgeOffset = AB.length();

        const qreal corner_radius = edgeOffset * qTan(halfAngle);

        // constrain by sweep
        const qreal sweep = std::fabs(arcAngle2 - arcAngle1) * 0.5;
        const qreal degMax = std::min(sweep, qreal(45.0));

        const QVector2D C = A + AC.normalized() * edgeOffset;

        const qreal ptoc = (arcPoint - C).length();
        qreal edge = 0;
        if (innerArcRatio > 0) {
            const QVector2D ellipseInnerRadius(innerArcRatio * ellipseRadius.x(),
                                               innerArcRatio * ellipseRadius.y());
            const QVector2D innerArcPoint =
                    arc_point(center, ellipseInnerRadius, arcAngle); // point on the inner arc
            edge = (arcPoint - innerArcPoint).length();
        } else {
            edge = (arcPoint - center).length();
        }

        const qreal diff = std::fabs(corner_radius - cornerRadius); // closest to target radius

        auto &rc = roundedCorners[index];

        bool canUpdate = diff < rc.diff && !(corner_radius > cornerRadius) && !(deg > degMax)
                && !(rc.radius > corner_radius) && !(ptoc > edge * 0.5f);

        // 1st loop or if constraints are met
        if (rc.radius == 0 || canUpdate)
            rc.update(diff, A, B, C, a, corner_radius);

        done =
                // corner radius is bigger or equal to the target radius
                corner_radius > cornerRadius
                || is_equal(corner_radius, cornerRadius, 0.01f)
                // angle used to define point B is bigger than available sweep
                || deg > degMax
                || is_equal(deg, degMax, 0.01f)
                // the corner radius starts to decline (from previously calculated)
                || (rc.radius != 0 && rc.radius > corner_radius)
                // point C is beyond the half of the ellipse edge
                // (closer to the ellipse center or inner arc point)
                || (ptoc > edge * 0.5f);
    }

    return done;
}

bool QQuickEllipseShapePrivate::roundInner(QVector2D center, QVector2D ellipseRadius, qreal deg,
                                           qreal arcAngle1, qreal arcAngle2,
                                           RoundedCornerIndex index)
{
    // make rounding corner bigger and produces smoother result
    const qreal smoothFactor = 1.5;

    deg *= smoothFactor;

    bool done = false;

    const QVector2D ellipseInnerRadius(innerArcRatio * ellipseRadius.x(),
                                       innerArcRatio * ellipseRadius.y());

    const qreal arcAngle = arc_angle(arcAngle1);
    const QVector2D innerArcPoint =
            arc_point(center, ellipseInnerRadius, arcAngle); // point on the inner arc

    const qreal angle = arcAngle1 > arcAngle2 ? arcAngle - deg : arcAngle + deg;

    const QVector2D B = arc_point(center, ellipseInnerRadius, angle); // point on arc

    // calculate tangent vector
    const QVector2D uV = tangent_ccw(ellipseInnerRadius, angle).normalized();
    const QVector2D b1 = B + uV;

    qreal s = 0, t = 0;
    bool res = lines_intersect(center, innerArcPoint, B, b1, &s, &t);

    if (res) {
        // hit point
        const QVector2D A = center + s * (innerArcPoint - center); // point on edge

        const auto arcPoint = arc_point(center, ellipseRadius, arcAngle);

        const QVector2D AB = B - A;
        const QVector2D AC = A - innerArcPoint;

        const qreal a = angle_between_vectors(AB, AC);
        const qreal halfAngle = std::fabs(a) * 0.5;
        const qreal edgeOffset = AB.length();

        const qreal corner_radius = edgeOffset * qTan(halfAngle);

        // constrain by sweep
        const qreal sweep = std::fabs(arcAngle2 - arcAngle1) * 0.5;
        const qreal degMax = std::min(sweep, qreal(45.0));

        const QVector2D C = A + AC.normalized() * edgeOffset;

        const qreal ptoc = (innerArcPoint - C).length();
        const qreal edge = (innerArcPoint - arcPoint).length();

        const qreal diff =
                std::fabs(corner_radius - cornerRadius * smoothFactor); // closest to target radius

        auto &rc = roundedCorners[index];

        bool canUpdate = diff < rc.diff && !(corner_radius > cornerRadius * smoothFactor)
                && !(deg > degMax) && !(rc.radius > corner_radius) && !(ptoc > edge * 0.5f);

        // 1st loop or if constraints are met
        if (rc.radius == 0 || canUpdate)
            rc.update(diff, A, B, C, a, corner_radius);

        done =
                // corner radius is bigger or equal to the target radius
                corner_radius > cornerRadius * smoothFactor
                || is_equal(corner_radius, cornerRadius * smoothFactor, 0.01f)
                // angle used to define point B is bigger than available sweep
                || deg > degMax
                || is_equal(deg, degMax, 0.01f)
                // the corner radius starts to decline (from previously calculated)
                || (rc.radius != 0 && rc.radius > corner_radius)
                // point C is beyond the half of the ellipse edge
                // (closer to the inner arc end point)
                || (ptoc > edge * 0.5f);
    }

    return done;
}

void QQuickEllipseShapePrivate::drawCenterCorner()
{
    auto &rc = roundedCorners[RoundedCornerIndex::Center];
    path->setStartX(rc.B.x());
    path->setStartY(rc.B.y());

    addArc(rc.C, QVector2D(rc.radius, rc.radius),
           rc.alpha < 0 ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);
}

void QQuickEllipseShapePrivate::drawInnerEndCorner()
{
    auto &rc = roundedCorners[RoundedCornerIndex::InnerEnd];

    addLine(rc.C);

    addArc(rc.B, QVector2D(rc.radius, rc.radius),
           rc.alpha > 0 ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);
}

void QQuickEllipseShapePrivate::drawInnerBeginCorner()
{
    auto &rc = roundedCorners[RoundedCornerIndex::InnerBegin];
    path->setStartX(rc.B.x());
    path->setStartY(rc.B.y());

    addArc(rc.C, QVector2D(rc.radius, rc.radius),
           rc.alpha < 0 ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);
}

void QQuickEllipseShapePrivate::drawOuterBeginCorner()
{
    auto &rc = roundedCorners[RoundedCornerIndex::OuterBegin];

    addLine(rc.C);

    addArc(rc.B, QVector2D(rc.radius, rc.radius),
           rc.alpha > 0 ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);
}

void QQuickEllipseShapePrivate::drawOuterArcRounded(QVector2D center, QVector2D ellipseRadius)
{
    // split outer arc in two parts to avoid issues of the large arc
    const qreal endAngle = startAngle + sweepAngle;

    const qreal angle = startAngle > endAngle
            ? arc_angle(startAngle - std::fabs(sweepAngle * 0.5f))
            : arc_angle(startAngle + std::fabs(sweepAngle * 0.5f));
    const auto point = arc_point(center, ellipseRadius, angle); // mid point of the arc

    // from begin to mid point
    addArc(point, ellipseRadius,
           sweepAngle > 0.0f ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);

    auto &rc = roundedCorners[RoundedCornerIndex::OuterEnd];

    // from mid point to end rounded corner
    addArc(rc.B, ellipseRadius,
           sweepAngle > 0.0f ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);

    // rounded corner
    addArc(rc.C, QVector2D(rc.radius, rc.radius),
           rc.alpha < 0 ? QQuickPathArc::Clockwise : QQuickPathArc::Counterclockwise);
}

void QQuickEllipseShapePrivate::drawInnerArcRounded(QVector2D center, QVector2D ellipseRadius)
{
    // split inner arc in two parts to avoid issues of the large arc
    const qreal endAngle = startAngle + sweepAngle;

    const QVector2D ellipseInnerRadius(innerArcRatio * ellipseRadius.x(),
                                       innerArcRatio * ellipseRadius.y());

    const qreal angle = endAngle > startAngle ? arc_angle(endAngle - std::fabs(sweepAngle * 0.5f))
                                              : arc_angle(endAngle + std::fabs(sweepAngle * 0.5f));
    const auto point = arc_point(center, ellipseInnerRadius, angle); // mid point of the arc

    // from end to mid point
    addArc(point, ellipseInnerRadius,
           sweepAngle > 0.0f ? QQuickPathArc::Counterclockwise : QQuickPathArc::Clockwise);

    // from mid point to begin rounded corner
    auto &rc = roundedCorners[RoundedCornerIndex::InnerBegin];
    addArc(rc.B, ellipseInnerRadius,
           sweepAngle > 0.0f ? QQuickPathArc::Counterclockwise : QQuickPathArc::Clockwise);
}

void QQuickEllipseShapePrivate::drawOuterArc(QVector2D center, QVector2D ellipseRadius)
{
    const qreal beginAngle = arc_angle(startAngle);
    const qreal endAngle = arc_angle(startAngle + sweepAngle);

    const qreal alpha = std::clamp(std::fabs(sweepAngle), qreal(0.0), qreal(359.9));
    bool isFull = (alpha <= 0.0f || alpha >= 359.0f);

    // QQuickPathArc has some weird behavior when it starts and ends at the same point
    // leave some gap between the start and the end points in order to avoid it
    const auto beginPoint = arc_point(center, ellipseRadius, isFull ? 0 : beginAngle);
    const auto endPoint = arc_point(center, ellipseRadius, isFull ? 359.9 : endAngle);

    path->setStartX(beginPoint.x());
    path->setStartY(beginPoint.y());

    addArc(endPoint, ellipseRadius,
           isFull ? QQuickPathArc::Clockwise
                  : (sweepAngle > 0.0f ? QQuickPathArc::Clockwise
                                       : QQuickPathArc::Counterclockwise),
           isFull ? true : alpha > 180.0f);

    // add reverse arc to hide fill color
    if (qFuzzyCompare(innerArcRatio, 1)) {
        addArc(beginPoint, ellipseRadius,
               isFull ? QQuickPathArc::Counterclockwise
                      : (sweepAngle > 0.0f ? QQuickPathArc::Counterclockwise
                                           : QQuickPathArc::Clockwise),
               isFull ? true : alpha > 180.0f);
    }
}

void QQuickEllipseShapePrivate::drawFullInnerArc(QVector2D center, QVector2D ellipseRadius)
{
    const qreal beginAngle = arc_angle(startAngle);

    auto arc = new QQuickPathAngleArc(path);
    arc->setCenterX(center.x());
    arc->setCenterY(center.y());
    arc->setStartAngle(beginAngle);
    arc->setRadiusX(innerArcRatio * ellipseRadius.x());
    arc->setRadiusY(innerArcRatio * ellipseRadius.y());
    arc->setSweepAngle(sweepAngle);
    QQuickPathPrivate::get(path)->appendPathElement(arc);
}

void QQuickEllipseShapePrivate::drawWithInnerRadius(QVector2D center, QVector2D ellipseRadius)
{
    drawInnerBeginCorner(); // path starts at the begin rounded corner on the inner arc

    drawOuterBeginCorner(); // path continues to the begin rounded corner on the outer arc

    // outer arc connecting begin and end rounded corners
    drawOuterArcRounded(center, ellipseRadius);

    // path continues to the end rounded corner on the inner arc
    drawInnerEndCorner();

    // inner arc connecting end and begin rounded corners
    drawInnerArcRounded(center, ellipseRadius);
}

void QQuickEllipseShapePrivate::drawWithoutInnerRadius(QVector2D center, QVector2D ellipseRadius)
{
    drawCenterCorner(); // path starts at rounded corner of ellipse center

    drawOuterBeginCorner(); // path continues to the begin rounded corner on the outer arc

    // outer arc connecting begin and end rounded corners
    drawOuterArcRounded(center, ellipseRadius);

    // path ends at the ellipse's center rounded corner
    const auto &rc = roundedCorners[RoundedCornerIndex::Center];
    addLine(rc.B);
}

void QQuickEllipseShapePrivate::updatePath()
{
    const qreal borderOffset = getBorderOffset();
    const QVector2D center =
            QVector2D(width.valueBypassingBindings(), height.valueBypassingBindings()) * 0.5f;
    const QVector2D ellipseRadius = center - QVector2D(borderOffset, borderOffset);

    QQuickPathPrivate::get(path)->clearPathElements(QQuickPathPrivate::DeleteElementPolicy::Delete);

    const qreal alpha = std::clamp(std::fabs(sweepAngle), qreal(0.0), qreal(359.9));
    const bool isFull = alpha >= 359.0;

    if (qFuzzyCompare(alpha, 0))
        return;

    // just an arc
    if (qFuzzyCompare(innerArcRatio, 1)) {
        drawOuterArc(center, ellipseRadius);
        return;
    }

    roundedCorners.reset(); // cleanup old results

    if (innerArcRatio != 0 && isFull) {
        // this is a donut
        drawOuterArc(center, ellipseRadius);
        drawFullInnerArc(center, ellipseRadius);
    } else if (innerArcRatio != 0 && !isFull) {
        // this is an outlined arc
        roundBeginEnd(center, ellipseRadius);
        drawWithInnerRadius(center, ellipseRadius);
    } else if (!isFull) {
        // this is a pie
        roundCenter(center, ellipseRadius);
        roundBeginEnd(center, ellipseRadius);
        drawWithoutInnerRadius(center, ellipseRadius);
    } else {
        drawOuterArc(center, ellipseRadius);
    }
}

/*!
    \qmltype EllipseShape
    \inqmlmodule QtQuick.Shapes.DesignHelpers
    \brief A shape component that can render an ellipse, an arc, or a pie slice.
    \since QtQuick 6.10

    The EllipseShape item paints an ellipse, which can be customized to appear
    as a full ellipse, an arc, or a filled pie slice. Its appearance is
    controlled by the \l startAngle and \l sweepAngle properties.

    \section1 Basic Ellipse
    By default, the item renders a full ellipse. The interior is filled with the
    \l fillColor, and the outline is drawn according to the \l strokeColor, \l
    strokeWidth, and \l strokeStyle properties.

    \section1 Arc and Pie Slices
    To create an arc or a pie slice, set the \l startAngle (0-360 degrees) and
    \l sweepAngle (0-360 degrees) to define the segment of the ellipse to draw.

    \b {Arc Mode}: To create a simple arc (just the outline), set the \l
    fillColor to \c "transparent". The arc's line style can be customized with
    \l dashPattern and \l dashOffset.

    \b {Pie Mode}: To create a filled pie slice (a segment connected to the
    center), simply set the \l fillColor. The outline of the slice will also be
    stroked.

    \b {Donut Mode}: To create a donut ring (a hollow ellipse), set the
    \l innerArcRatio to a value between 0.0 and 1.0. This defines the ratio of
    the inner ellipse's radius to the outer ellipse's radius.

    The area inside the stroke is painted using either a solid fill color,
    specified using the \l fillColor property, or a gradient, defined using one
    of the \l ShapeGradient subtypes and set using the \l fillGradient
    property. If both a color and a gradient are specified, the gradient is
    used.

    An optional border can be added to an ellipse with its own color and
    thickness by setting the \l strokeColor and \l strokeWidth properties.
    Setting the color to \c transparent creates a border without a fill color.

    Ellipse can be drawn with rounded corners using the \l cornerRadius
    property. The default value of the \l cornerRadius is 10 degrees.

    EllipseShape's default value for \l {QtQuick.Shapes::Shape::preferredRendererType} is
    \c Shape.CurveRenderer.

    \section1 Example Usage

    \snippet ellipseshape.qml ellipseShape

    \image path-ellipseshape.png {Ellipse with a pie slice cut out}
*/
QQuickEllipseShape::QQuickEllipseShape(QQuickItem *parent)
    : QQuickShape(*(new QQuickEllipseShapePrivate), parent)
{
    Q_D(QQuickEllipseShape);

    setPreferredRendererType(CurveRenderer);

    setWidth(200);
    setHeight(200);

    d->path = new QQuickShapePath(this);
    d->path->setParent(this);
    d->path->setStrokeWidth(1);
    d->path->setStrokeColor(QColorConstants::Black);
    d->path->setFillColor(QColorConstants::White);

    d->sp.append(d->path);
    d->path->setParent(this);
    d->extra.value().resourcesList.append(d->path);

    connect(d->path, &QQuickShapePath::strokeColorChanged, this, &QQuickEllipseShape::strokeColorChanged);
    connect(d->path, &QQuickShapePath::strokeWidthChanged, this, &QQuickEllipseShape::strokeWidthChanged);
    connect(d->path, &QQuickShapePath::fillColorChanged, this, &QQuickEllipseShape::fillColorChanged);
    connect(d->path, &QQuickShapePath::joinStyleChanged, this, &QQuickEllipseShape::joinStyleChanged);
    connect(d->path, &QQuickShapePath::capStyleChanged, this, &QQuickEllipseShape::capStyleChanged);
    connect(d->path, &QQuickShapePath::strokeStyleChanged, this, &QQuickEllipseShape::strokeStyleChanged);
    connect(d->path, &QQuickShapePath::dashOffsetChanged, this, &QQuickEllipseShape::dashOffsetChanged);
    connect(d->path, &QQuickShapePath::dashPatternChanged, this, &QQuickEllipseShape::dashPatternChanged);
    connect(d->path, &QQuickShapePath::fillItemChanged, this, &QQuickEllipseShape::fillItemChanged);
    connect(d->path, &QQuickShapePath::fillGradientChanged, this, &QQuickEllipseShape::fillGradientChanged);
    connect(d->path, &QQuickShapePath::fillRuleChanged, this, &QQuickEllipseShape::fillRuleChanged);
}

QQuickEllipseShape::~QQuickEllipseShape() = default;

/*!
    \qmlproperty real QtQuick.Shapes.DesignHelpers::EllipseShape::sweepAngle

    The angular extent in degrees to be drawn from the \l startAngle.

    If set to positive value, the arc is drawn in clockwise direction.
    If set to negative value, the arc is drawn in counter-clockwise direction.

    The default value is \c 360.
*/
qreal QQuickEllipseShape::sweepAngle() const
{
    Q_D(const QQuickEllipseShape);
    return d->sweepAngle;
}

void QQuickEllipseShape::setSweepAngle(qreal sweepAngle)
{
    Q_D(QQuickEllipseShape);
    if (qFuzzyCompare(d->sweepAngle, sweepAngle))
        return;
    d->sweepAngle = sweepAngle;
    d->updatePath();
    emit sweepAngleChanged();
}

/*!
    \qmlproperty real QtQuick.Shapes.DesignHelpers::EllipseShape::startAngle

    The property defines the starting angle in degrees from which to begin
    drawing the ellipse.

    0 degrees points to the top. Angle increases in clockwise direction.

    The default value is \c 0.
*/
qreal QQuickEllipseShape::startAngle() const
{
    Q_D(const QQuickEllipseShape);
    return d->startAngle;
}

void QQuickEllipseShape::setStartAngle(qreal startAngle)
{
    Q_D(QQuickEllipseShape);
    if (qFuzzyCompare(d->startAngle, startAngle))
        return;
    d->startAngle = startAngle;
    d->updatePath();
    emit startAngleChanged();
}

/*!
    \include shapepath.qdocinc {dashOffset-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

qreal QQuickEllipseShape::dashOffset() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->dashOffset();
}

void QQuickEllipseShape::setDashOffset(qreal offset)
{
    Q_D(QQuickEllipseShape);
    d->path->setDashOffset(offset);
}

/*!
    \qmlproperty real QtQuick.Shapes.DesignHelpers::EllipseShape::cornerRadius

    Controls the rounding of corners where the radial lines meet the elliptical
    arcs. For pie segments, this rounds the connection to the outer arc. For
    donut segments, this also rounds the connections to both inner and outer arcs.

    The default value is \c 10.
*/
qreal QQuickEllipseShape::cornerRadius() const
{
    Q_D(const QQuickEllipseShape);
    return d->cornerRadius;
}

void QQuickEllipseShape::setCornerRadius(qreal cornerRadius)
{
    Q_D(QQuickEllipseShape);
    if (qFuzzyCompare(d->cornerRadius, cornerRadius))
        return;
    d->cornerRadius = cornerRadius;
    d->updatePath();
    emit cornerRadiusChanged();
}

/*!
    \qmlproperty real QtQuick.Shapes.DesignHelpers::EllipseShape::innerArcRatio

    This property defines the ratio between the inner and outer arcs.

    Value range is between 0.0 and 1.0. Setting the value to 0.0 will cause
    the inner arc to collapse toward the center, drawing a solid filled
    ellipse. Setting the value to 1.0 makes the inner arc the same size as the
    outer ellipse, resulting in just an arc. Values between 0.0 and 1.0 create
    hollow elliptical rings.

    The default value is \c 0.
*/
qreal QQuickEllipseShape::innerArcRatio() const
{
    Q_D(const QQuickEllipseShape);
    return d->innerArcRatio;
}

void QQuickEllipseShape::setInnerArcRatio(qreal innerArcRatio)
{
    Q_D(QQuickEllipseShape);
    if (qFuzzyCompare(d->innerArcRatio, innerArcRatio))
        return;
    d->innerArcRatio = innerArcRatio;
    d->updatePath();
    emit innerArcRatioChanged();
}

/*!
    \qmlproperty real QtQuick.Shapes.DesignHelpers::EllipseShape::strokeWidth

    This property holds the stroke width.

    When set to a negative value, no stroking occurs.

    The default value is \c 1.
*/

qreal QQuickEllipseShape::strokeWidth() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->strokeWidth();
}

void QQuickEllipseShape::setStrokeWidth(qreal width)
{
    Q_D(QQuickEllipseShape);
    d->path->setStrokeWidth(width);
}

/*!
    \qmlproperty color QtQuick.Shapes.DesignHelpers::EllipseShape::fillColor

    This property holds the fill color.

    When set to \c transparent, no filling occurs.

    The default value is \c "white".

    \note If either \l fillGradient is set to something other than \c null, it
    will be used instead of \c fillColor.
*/

QColor QQuickEllipseShape::fillColor() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->fillColor();
}

void QQuickEllipseShape::setFillColor(const QColor &color)
{
    Q_D(QQuickEllipseShape);
    d->path->setFillColor(color);
}

/*!
    \qmlproperty color QtQuick.Shapes.DesignHelpers::EllipseShape::strokeColor

    This property holds the stroking color.

    When set to \c transparent, no stroking occurs.

    The default value is \c "black".
*/

QColor QQuickEllipseShape::strokeColor() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->strokeColor();
}

void QQuickEllipseShape::setStrokeColor(const QColor &color)
{
    Q_D(QQuickEllipseShape);
    d->path->setStrokeColor(color);
}

/*!
    \include shapepath.qdocinc {capStyle-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

QQuickShapePath::CapStyle QQuickEllipseShape::capStyle() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->capStyle();
}

void QQuickEllipseShape::setCapStyle(QQuickShapePath::CapStyle style)
{
    Q_D(QQuickEllipseShape);
    d->path->setCapStyle(style);
}

/*!
    \include shapepath.qdocinc {joinStyle-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

QQuickShapePath::JoinStyle QQuickEllipseShape::joinStyle() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->joinStyle();
}

void QQuickEllipseShape::setJoinStyle(QQuickShapePath::JoinStyle style)
{
    Q_D(QQuickEllipseShape);
    d->path->setJoinStyle(style);
}

/*!
    \include shapepath.qdocinc {strokeStyle-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

QQuickShapePath::StrokeStyle QQuickEllipseShape::strokeStyle() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->strokeStyle();
}

void QQuickEllipseShape::setStrokeStyle(QQuickShapePath::StrokeStyle style)
{
    Q_D(QQuickEllipseShape);
    d->path->setStrokeStyle(style);
}

/*!
    \include shapepath.qdocinc {fillRule-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

QQuickShapePath::FillRule QQuickEllipseShape::fillRule() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->fillRule();
}

void QQuickEllipseShape::setFillRule(QQuickShapePath::FillRule fillRule)
{
    Q_D(QQuickEllipseShape);
    d->path->setFillRule(fillRule);
}

/*!
    \include shapepath.qdocinc {dashPattern-property} {QtQuick.Shapes.DesignHelpers::EllipseShape}
*/

QList<qreal> QQuickEllipseShape::dashPattern() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->dashPattern();
}

void QQuickEllipseShape::setDashPattern(const QList<qreal> &array)
{
    Q_D(QQuickEllipseShape);
    d->path->setDashPattern(array);
}

/*!
    \qmlproperty ShapeGradient QtQuick.Shapes.DesignHelpers::EllipseShape::fillGradient

    The fillGradient of the ellipse fill color.

    By default, no fillGradient is enabled and the value is null. In this case, the
    fill uses a solid color based on the value of \l fillColor.

    When set, \l fillColor is ignored and filling is done using one of the
    \l ShapeGradient subtypes.

    \note The \l Gradient type cannot be used here. Rather, prefer using one of
    the advanced subtypes, like \l LinearGradient.
*/
QQuickShapeGradient *QQuickEllipseShape::fillGradient() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->fillGradient();
}

void QQuickEllipseShape::setFillGradient(QQuickShapeGradient *fillGradient)
{
    Q_D(QQuickEllipseShape);
    d->path->setFillGradient(fillGradient);
}

void QQuickEllipseShape::resetFillGradient()
{
    setFillGradient(nullptr);
}

/*!
    \qmlproperty enumeration QtQuick.Shapes.DesignHelpers::EllipseShape::borderMode

    The \l borderMode property determines where the border is drawn along the
    edge of the ellipse.

    \value EllipseShape.Inside
        The border is drawn along the inside edge of the item and does not
        affect the item width.

        This is the default value.
    \value EllipseShape.Middle
        The border is drawn over the edge of the item and does not
        affect the item width.
    \value EllipseShape.Outside
        The border is drawn along the outside edge of the item and increases
        the item width by the value of \l strokeWidth.

    \sa strokeWidth
*/
QQuickEllipseShape::BorderMode QQuickEllipseShape::borderMode() const
{
    Q_D(const QQuickEllipseShape);
    return d->borderMode;
}

void QQuickEllipseShape::setBorderMode(BorderMode borderMode)
{
    Q_D(QQuickEllipseShape);
    if (borderMode == d->borderMode)
        return;
    d->borderMode = borderMode;
    d->updatePath();
    emit borderModeChanged();
}

void QQuickEllipseShape::resetBorderMode()
{
    setBorderMode(BorderMode::Inside);
}

QQuickItem *QQuickEllipseShape::fillItem() const
{
    Q_D(const QQuickEllipseShape);
    return d->path->fillItem();
}

void QQuickEllipseShape::setFillItem(QQuickItem *newFillItem)
{
    Q_D(QQuickEllipseShape);
    d->path->setFillItem(newFillItem);
}

void QQuickEllipseShape::itemChange(ItemChange change, const ItemChangeData &value)
{
    Q_D(QQuickEllipseShape);

    if (d->path)
        d->updatePath();

    QQuickItem::itemChange(change, value);
}

QT_END_NAMESPACE

#include "moc_qquickellipseshape_p.cpp"
