Revision control
Copy as Markdown
// 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 "qquickstarshape_p.h"
#include "qquickstarshape_p_p.h"
#include <algorithm>
#include <QtMath>
#include <cstddef>
QT_BEGIN_NAMESPACE
namespace {
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)));
}
inline qreal cross(QVector2D a, QVector2D b)
{
return a.x() * b.y() - a.y() * b.x();
}
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;
}
} // namespace
QQuickStarShapePrivate::QQuickStarShapePrivate() = default;
QQuickStarShapePrivate::~QQuickStarShapePrivate() = default;
void QQuickStarShapePrivate::updatePoints()
{
points.clear();
const qreal rectWidth = width.valueBypassingBindings();
const qreal rectHeight = height.valueBypassingBindings();
const QVector2D center(rectWidth * 0.5, rectHeight * 0.5);
const QVector2D radius(rectWidth * 0.5, rectHeight * 0.5);
const QVector2D inner_radius = radius * std::min(std::max(ratio, qreal(0.001)), qreal(1.0));
const int numPoints = pointCount * 2;
const qreal sliceAngle = (360.0f / numPoints);
for (int i = 0; i < numPoints; ++i) {
const qreal angle = i * sliceAngle;
const auto p = arc_point(center, i % 2 == 0 ? radius : inner_radius, arc_angle(angle));
points.emplace_back(std::move(p));
}
}
void QQuickStarShapePrivate::constructPolygonPath()
{
auto *ppath = QQuickShapePathPrivate::get(path);
path->setStartX(points[0].x());
path->setStartY(points[0].y());
for (const auto &p : points) {
auto line = new QQuickPathLine(path);
line->setX(p.x());
line->setY(p.y());
ppath->appendPathElement(line, QQuickPathPrivate::ProcessPathPolicy::DontProcess);
}
auto line = new QQuickPathLine(path);
line->setX(points[0].x());
line->setY(points[0].y());
ppath->appendPathElement(line, QQuickPathPrivate::ProcessPathPolicy::DontProcess);
path->processPath();
}
void QQuickStarShapePrivate::constructRoundedPolygonPath()
{
const auto size = points.size();
auto *ppath = QQuickShapePathPrivate::get(path);
for (size_t i = 0; i < size; ++i) {
const auto &a = points[i];
const auto &b = points[(i == 0 ? size : i) - 1];
const auto &c = points[(i + 1 == size) ? 0 : (i + 1)];
const QVector2D ab = b - a;
const QVector2D ac = c - a;
const qreal alpha = angle_between_vectors(ab, ac);
const qreal halfAngle = std::fabs(alpha) * 0.5;
qreal corner_radius = cornerRadius;
auto edgeOffset = corner_radius / qTan(halfAngle);
const qreal edge = std::min(ab.length(), ac.length());
if (edgeOffset > edge * 0.5) {
edgeOffset = edge * 0.5;
corner_radius = edgeOffset * qTan(halfAngle);
}
const auto B = a + ab.normalized() * edgeOffset;
const auto C = a + ac.normalized() * edgeOffset;
if (i == 0) {
path->setStartX(B.x());
path->setStartY(B.y());
} else {
auto line = new QQuickPathLine(path);
line->setX(B.x());
line->setY(B.y());
ppath->appendPathElement(line, QQuickPathPrivate::ProcessPathPolicy::DontProcess);
}
auto arc = new QQuickPathArc(path);
arc->setX(C.x());
arc->setY(C.y());
arc->setRadiusX(corner_radius);
arc->setRadiusY(corner_radius);
arc->setDirection(alpha > 0 ? QQuickPathArc::ArcDirection::Counterclockwise
: QQuickPathArc::ArcDirection::Clockwise);
ppath->appendPathElement(arc, QQuickPathPrivate::ProcessPathPolicy::DontProcess);
}
auto line = new QQuickPathLine(path);
line->setX(path->startX());
line->setY(path->startY());
ppath->appendPathElement(line, QQuickPathPrivate::ProcessPathPolicy::DontProcess);
path->processPath();
}
void QQuickStarShapePrivate::updatePath()
{
QQuickShapePathPrivate::get(path)->clearPathElements(
QQuickPathPrivate::DeleteElementPolicy::Delete);
updatePoints();
if (qFuzzyCompare(cornerRadius, qreal(0.0)))
constructPolygonPath();
else
constructRoundedPolygonPath();
}
/*!
\qmltype StarShape
\inqmlmodule QtQuick.Shapes.DesignHelpers
\brief A filled star-shaped polygon with an optional border.
\since QtQuick 6.10
A star can be a star shaped stroke, a filling, or a stroke with filling.
The \l strokeColor, \l strokeWidth, and \l strokeStyle properties specify
the appearance of the outline. The \l dashPattern and \l dashOffset
properties specify the appearance of dashed stroke.
Set the \l pointCount property between 3 and 60 to specify the number of
points of the star. Set the \l ratio between 0.1 and 1 to specify the
distance of the inner points of the star from the center.
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 gradient property. If both a color and a gradient are specified, the gradient is
used.
To create a star with a stroke, set the \l strokeWidth property to a value greater than 0. The
\l strokeWidth property specifies the width of the polygon stroke. The default \l pointCount
value is 6 and the default \l strokeWidth value is 4. Setting the \l strokeWidth value to a
negative value hides the border.
The \l cornerRadius property specifies whether the star corners are rounded.
*/
QQuickStarShape::QQuickStarShape(QQuickItem *parent)
: QQuickShape(*(new QQuickStarShapePrivate), parent)
{
Q_D(QQuickStarShape);
setPreferredRendererType(CurveRenderer);
setWidth(200);
setHeight(200);
d->path = new QQuickShapePath(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, &QQuickStarShape::strokeColorChanged);
connect(d->path, &QQuickShapePath::strokeWidthChanged, this, &QQuickStarShape::strokeWidthChanged);
connect(d->path, &QQuickShapePath::fillColorChanged, this, &QQuickStarShape::fillColorChanged);
connect(d->path, &QQuickShapePath::joinStyleChanged, this, &QQuickStarShape::joinStyleChanged);
connect(d->path, &QQuickShapePath::capStyleChanged, this, &QQuickStarShape::capStyleChanged);
connect(d->path, &QQuickShapePath::strokeStyleChanged, this, &QQuickStarShape::strokeStyleChanged);
connect(d->path, &QQuickShapePath::dashOffsetChanged, this, &QQuickStarShape::dashOffsetChanged);
connect(d->path, &QQuickShapePath::dashPatternChanged, this, &QQuickStarShape::dashPatternChanged);
connect(d->path, &QQuickShapePath::fillItemChanged, this, &QQuickStarShape::fillItemChanged);
connect(d->path, &QQuickShapePath::fillGradientChanged, this, &QQuickStarShape::fillGradientChanged);
}
QQuickStarShape::~QQuickStarShape() = default;
/*!
\include shapepath.qdocinc {dashOffset-property}
{QtQuick.Shapes.DesignHelpers::StarShape}
*/
qreal QQuickStarShape::dashOffset() const
{
Q_D(const QQuickStarShape);
return d->path->dashOffset();
}
void QQuickStarShape::setDashOffset(qreal offset)
{
Q_D(QQuickStarShape);
d->path->setDashOffset(offset);
}
/*!
\qmlproperty real QtQuick.Shapes.DesignHelpers::StarShape::cornerRadius
The property controls the rounding of both the star's outer points and
inner points.
The default value is \c 10.
*/
qreal QQuickStarShape::cornerRadius() const
{
Q_D(const QQuickStarShape);
return d->cornerRadius;
}
void QQuickStarShape::setCornerRadius(qreal radius)
{
Q_D(QQuickStarShape);
if (qFuzzyCompare(d->cornerRadius, radius))
return;
d->cornerRadius = radius;
d->updatePath();
emit cornerRadiusChanged();
}
/*!
\qmlproperty real QtQuick.Shapes.DesignHelpers::StarShape::ratio
The property defines the distance of the inner points of the star from the
center.
The default value is \c 0.5.
*/
qreal QQuickStarShape::ratio() const
{
Q_D(const QQuickStarShape);
return d->ratio;
}
void QQuickStarShape::setRatio(qreal ratio)
{
Q_D(QQuickStarShape);
if (qFuzzyCompare(d->ratio, ratio))
return;
d->ratio = ratio;
d->updatePath();
emit ratioChanged();
}
/*!
\qmlproperty int QtQuick.Shapes.DesignHelpers::StarShape::pointCount
The property defines the total number of points the star has.
The default value is \c 6.
*/
int QQuickStarShape::pointCount() const
{
Q_D(const QQuickStarShape);
return d->pointCount;
}
void QQuickStarShape::setPointCount(int count)
{
Q_D(QQuickStarShape);
if (d->pointCount == count)
return;
d->pointCount = count;
d->updatePath();
emit pointCountChanged();
}
/*!
\qmlproperty real QtQuick.Shapes.DesignHelpers::StarShape::strokeWidth
This property holds the stroke width.
When set to a negative value, no stroking occurs.
The default value is \c 1.
*/
qreal QQuickStarShape::strokeWidth() const
{
Q_D(const QQuickStarShape);
return d->path->strokeWidth();
}
void QQuickStarShape::setStrokeWidth(qreal width)
{
Q_D(QQuickStarShape);
d->path->setStrokeWidth(width);
}
/*!
\qmlproperty color QtQuick.Shapes.DesignHelpers::StarShape::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 QQuickStarShape::fillColor() const
{
Q_D(const QQuickStarShape);
return d->path->fillColor();
}
void QQuickStarShape::setFillColor(const QColor &color)
{
Q_D(QQuickStarShape);
d->path->setFillColor(color);
}
/*!
\qmlproperty color QtQuick.Shapes.DesignHelpers::StarShape::strokeColor
This property holds the stroking color.
When set to \c transparent, no stroking occurs.
The default value is \c "black".
*/
QColor QQuickStarShape::strokeColor() const
{
Q_D(const QQuickStarShape);
return d->path->strokeColor();
}
void QQuickStarShape::setStrokeColor(const QColor &color)
{
Q_D(QQuickStarShape);
d->path->setStrokeColor(color);
}
/*!
\include shapepath.qdocinc {capStyle-property}
{QtQuick.Shapes.DesignHelpers::StarShape}
Since a star is drawn, the path forms a loop with no line end points.
Therefore, capStyle is only needed when strokeStyle == ShapePath.DashLine
*/
QQuickShapePath::CapStyle QQuickStarShape::capStyle() const
{
Q_D(const QQuickStarShape);
return d->path->capStyle();
}
void QQuickStarShape::setCapStyle(QQuickShapePath::CapStyle style)
{
Q_D(QQuickStarShape);
d->path->setCapStyle(style);
}
/*!
\include shapepath.qdocinc {joinStyle-property}
{QtQuick.Shapes.DesignHelpers::StarShape}
The joinStyle is only meaningful if cornerRadius == 0.
*/
QQuickShapePath::JoinStyle QQuickStarShape::joinStyle() const
{
Q_D(const QQuickStarShape);
return d->path->joinStyle();
}
void QQuickStarShape::setJoinStyle(QQuickShapePath::JoinStyle style)
{
Q_D(QQuickStarShape);
d->path->setJoinStyle(style);
}
/*!
\include shapepath.qdocinc {strokeStyle-property}
{QtQuick.Shapes.DesignHelpers::StarShape}
*/
QQuickShapePath::StrokeStyle QQuickStarShape::strokeStyle() const
{
Q_D(const QQuickStarShape);
return d->path->strokeStyle();
}
void QQuickStarShape::setStrokeStyle(QQuickShapePath::StrokeStyle style)
{
Q_D(QQuickStarShape);
d->path->setStrokeStyle(style);
}
/*!
\include shapepath.qdocinc {dashPattern-property}
{QtQuick.Shapes.DesignHelpers::StarShape}
*/
QList<qreal> QQuickStarShape::dashPattern() const
{
Q_D(const QQuickStarShape);
return d->path->dashPattern();
}
void QQuickStarShape::setDashPattern(const QList<qreal> &array)
{
Q_D(QQuickStarShape);
d->path->setDashPattern(array);
}
/*!
\qmlproperty ShapeGradient QtQuick.Shapes.DesignHelpers::StarShape::fillGradient
The fillGradient of the star 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 *QQuickStarShape::fillGradient() const
{
Q_D(const QQuickStarShape);
return d->path->fillGradient();
}
void QQuickStarShape::setFillGradient(QQuickShapeGradient *fillGradient)
{
Q_D(QQuickStarShape);
d->path->setFillGradient(fillGradient);
}
void QQuickStarShape::resetFillGradient()
{
setFillGradient(nullptr);
}
QQuickItem *QQuickStarShape::fillItem() const
{
Q_D(const QQuickStarShape);
return d->path->fillItem();
}
void QQuickStarShape::setFillItem(QQuickItem *newFillItem)
{
Q_D(QQuickStarShape);
d->path->setFillItem(newFillItem);
}
void QQuickStarShape::itemChange(ItemChange change, const ItemChangeData &value)
{
Q_D(QQuickStarShape);
if (d->path)
d->updatePath();
QQuickItem::itemChange(change, value);
}
QT_END_NAMESPACE
#include "moc_qquickstarshape_p.cpp"