Revision control
++ // 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
++
++ #include "qquickrectangle_p.h"
++ #include "qquickrectangle_p_p.h"
++
++ #include <QtQml/qqmlinfo.h>
++
++ #include <QtQuick/private/qsgcontext_p.h>
++ #include <private/qsgadaptationlayer_p.h>
++
++ #include <private/qqmlmetatype_p.h>
++
++ #include <QtGui/qpixmapcache.h>
++ #include <QtCore/qmath.h>
++ #include <QtCore/qmetaobject.h>
++
++ QT_BEGIN_NAMESPACE
++
++ // XXX todo - should we change rectangle to draw entirely within its width/height?
++ /*!
++ \internal
++ \class QQuickPen
++ \brief For specifying a pen used for drawing rectangle borders on a QQuickView
++
++ By default, the pen is invalid and nothing is drawn. You must either set a color (then the default
++ width is 1) or a width (then the default color is black).
++
++ A width of 1 indicates is a single-pixel line on the border of the item being painted.
++
++ Example:
++ \qml
++ Rectangle {
++ border.width: 2
++ border.color: "red"
++ }
++ \endqml
++ */
++
++ QQuickPen::QQuickPen(QObject *parent)
++ : QObject(parent)
++ , m_width(1)
++ , m_color(Qt::black)
++ , m_aligned(true)
++ , m_valid(false)
++ {
++ }
++
++ qreal QQuickPen::width() const
++ {
++ return m_width;
++ }
++
++ void QQuickPen::setWidth(qreal w)
++ {
++ if (m_width == w && m_valid)
++ return;
++
++ m_width = w;
++ m_valid = m_color.alpha() && (qRound(m_width) >= 1 || (!m_aligned && m_width > 0));
++ static_cast<QQuickItem*>(parent())->update();
++ emit widthChanged();
++ }
++
++ QColor QQuickPen::color() const
++ {
++ return m_color;
++ }
++
++ void QQuickPen::setColor(const QColor &c)
++ {
++ m_color = c;
++ m_valid = m_color.alpha() && (qRound(m_width) >= 1 || (!m_aligned && m_width > 0));
++ static_cast<QQuickItem*>(parent())->update();
++ emit colorChanged();
++ }
++
++ bool QQuickPen::pixelAligned() const
++ {
++ return m_aligned;
++ }
++
++ void QQuickPen::setPixelAligned(bool aligned)
++ {
++ if (aligned == m_aligned)
++ return;
++ m_aligned = aligned;
++ m_valid = m_color.alpha() && (qRound(m_width) >= 1 || (!m_aligned && m_width > 0));
++ static_cast<QQuickItem*>(parent())->update();
++ emit pixelAlignedChanged();
++ }
++
++ bool QQuickPen::isValid() const
++ {
++ return m_valid;
++ }
++
++ /*!
++ \qmltype GradientStop
++ \nativetype QQuickGradientStop
++ \inqmlmodule QtQuick
++ \ingroup qtquick-visual-utility
++ \brief Defines the color at a position in a Gradient.
++
++ \sa Gradient
++ */
++
++ /*!
++ \qmlproperty real QtQuick::GradientStop::position
++ \qmlproperty color QtQuick::GradientStop::color
++
++ The position and color properties describe the color used at a given
++ position in a gradient, as represented by a gradient stop.
++
++ The default position is 0.0; the default color is black.
++
++ \sa Gradient
++ */
++ QQuickGradientStop::QQuickGradientStop(QObject *parent)
++ : QObject(parent)
++ {
++ }
++
++ qreal QQuickGradientStop::position() const
++ {
++ return m_position;
++ }
++
++ void QQuickGradientStop::setPosition(qreal position)
++ {
++ m_position = position; updateGradient();
++ }
++
++ QColor QQuickGradientStop::color() const
++ {
++ return m_color;
++ }
++
++ void QQuickGradientStop::setColor(const QColor &color)
++ {
++ m_color = color; updateGradient();
++ }
++
++ void QQuickGradientStop::updateGradient()
++ {
++ if (QQuickGradient *grad = qobject_cast<QQuickGradient*>(parent()))
++ grad->doUpdate();
++ }
++
++ /*!
++ \qmltype Gradient
++ \nativetype QQuickGradient
++ \inqmlmodule QtQuick
++ \ingroup qtquick-visual-utility
++ \brief Defines a gradient fill.
++
++ A gradient is defined by two or more colors, which will be blended seamlessly.
++
++ The colors are specified as a set of GradientStop child items, each of
++ which defines a position on the gradient from 0.0 to 1.0 and a color.
++ The position of each GradientStop is defined by setting its
++ \l{GradientStop::}{position} property; its color is defined using its
++ \l{GradientStop::}{color} property.
++
++ A gradient without any gradient stops is rendered as a solid white fill.
++
++ Note that this item is not a visual representation of a gradient. To display a
++ gradient, use a visual item (like \l Rectangle) which supports the use
++ of gradients.
++
++ \section1 Example Usage
++
++ \div {class="float-right"}
++ \inlineimage qml-gradient.png
++ {Vertical gradient from red to yellow to green}
++ \enddiv
++
++ The following example declares a \l Rectangle item with a gradient starting
++ with red, blending to yellow at one third of the height of the rectangle,
++ and ending with green:
++
++ \snippet qml/gradient.qml code
++
++ \clearfloat
++ \section1 Performance and Limitations
++
++ Calculating gradients can be computationally expensive compared to the use
++ of solid color fills or images. Consider using gradients for static items
++ in a user interface.
++
++ Since Qt 5.12, vertical and horizontal linear gradients can be applied to items.
++ If you need to apply angled gradients, a combination of rotation and clipping
++ can be applied to the relevant items. Alternatively, consider using
++ QtQuick.Shapes::LinearGradient or QtGraphicalEffects::LinearGradient. These
++ approaches can all introduce additional performance requirements for your application.
++
++ The use of animations involving gradient stops may not give the desired
++ result. An alternative way to animate gradients is to use pre-generated
++ images or SVG drawings containing gradients.
++
++ \sa GradientStop
++ */
++
++ /*!
++ \qmlproperty list<GradientStop> QtQuick::Gradient::stops
++ \qmldefault
++
++ This property holds the gradient stops describing the gradient.
++
++ By default, this property contains an empty list.
++
++ To set the gradient stops, define them as children of the Gradient.
++ */
++ QQuickGradient::QQuickGradient(QObject *parent)
++ : QObject(parent)
++ {
++ }
++
++ QQuickGradient::~QQuickGradient()
++ {
++ }
++
++ QQmlListProperty<QQuickGradientStop> QQuickGradient::stops()
++ {
++ return QQmlListProperty<QQuickGradientStop>(this, &m_stops);
++ }
++
++ /*!
++ \qmlproperty enumeration QtQuick::Gradient::orientation
++ \since 5.12
++
++ Set this property to define the direction of the gradient.
++
++ \value Gradient.Vertical a vertical gradient
++ \value Gradient.Horizontal a horizontal gradient
++
++ The default is Gradient.Vertical.
++ */
++ void QQuickGradient::setOrientation(Orientation orientation)
++ {
++ if (m_orientation == orientation)
++ return;
++
++ m_orientation = orientation;
++ emit orientationChanged();
++ emit updated();
++ }
++
++ QGradientStops QQuickGradient::gradientStops() const
++ {
++ QGradientStops stops;
++ for (int i = 0; i < m_stops.size(); ++i){
++ int j = 0;
++ while (j < stops.size() && stops.at(j).first < m_stops[i]->position())
++ j++;
++ stops.insert(j, QGradientStop(m_stops.at(i)->position(), m_stops.at(i)->color()));
++ }
++ return stops;
++ }
++
++ void QQuickGradient::doUpdate()
++ {
++ emit updated();
++ }
++
++ int QQuickRectanglePrivate::doUpdateSlotIdx = -1;
++
++ void QQuickRectanglePrivate::maybeSetImplicitAntialiasing()
++ {
++ bool implicitAA = (radius > 0);
++ if (extraRectangle.isAllocated() && !implicitAA) {
++ const auto &extra = extraRectangle.value();
++ implicitAA = (extra.isTopLeftRadiusSet && extra.topLeftRadius > 0)
++ || (extra.isTopRightRadiusSet && extra.topRightRadius > 0)
++ || (extra.isBottomLeftRadiusSet && extra.bottomLeftRadius > 0)
++ || (extra.isBottomRightRadiusSet && extra.bottomRightRadius > 0);
++ }
++ setImplicitAntialiasing(implicitAA);
++ }
++ /*!
++ \qmltype Rectangle
++ \nativetype QQuickRectangle
++ \inqmlmodule QtQuick
++ \inherits Item
++ \ingroup qtquick-visual
++ \brief Paints a filled rectangle with an optional border.
++
++ Rectangle items are used to fill areas with solid color or gradients, and/or
++ to provide a rectangular border.
++
++ \section1 Appearance
++
++ Each Rectangle item is painted using either a solid fill color, specified using
++ the \l color property, or a gradient, defined using a Gradient type and set
++ using the \l gradient property. If both a color and a gradient are specified,
++ the gradient is used.
++
++ You can add an optional border to a rectangle with its own color and thickness
++ by setting the \l border.color and \l border.width properties. Set the color
++ to "transparent" to paint a border without a fill color.
++
++ You can also create rounded rectangles using the \l radius property. Since this
++ introduces curved edges to the corners of a rectangle, it may be appropriate to
++ set the \l Item::antialiasing property to improve its appearance. To set the
++ radii individually for different corners, you can use the properties
++ \l topLeftRadius, \l topRightRadius, \l bottomLeftRadius and
++ \l bottomRightRadius.
++
++ \section1 Example Usage
++
++ \div {class="float-right"}
++ \inlineimage declarative-rect.png
++ {Red rectangle with rounded corners and black border}
++ \enddiv
++
++ The following example shows the effects of some of the common properties on a
++ Rectangle item, which in this case is used to create a square:
++
++ \snippet qml/rectangle/rectangle.qml document
++
++ \clearfloat
++ \section1 Performance
++
++ Using the \l Item::antialiasing property improves the appearance of a rounded rectangle at
++ the cost of rendering performance. You should consider unsetting this property
++ for rectangles in motion, and only set it when they are stationary.
++
++ \sa Image
++ */
++
++ QQuickRectangle::QQuickRectangle(QQuickItem *parent)
++ : QQuickItem(*(new QQuickRectanglePrivate), parent)
++ {
++ setFlag(ItemHasContents);
++ #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
++ setAcceptTouchEvents(false);
++ #endif
++ }
++
++ void QQuickRectangle::doUpdate()
++ {
++ update();
++ }
++
++ /*!
++ \qmlproperty bool QtQuick::Rectangle::antialiasing
++
++ Used to decide if the Rectangle should use antialiasing or not.
++ \l {Antialiasing} provides information on the performance implications
++ of this property.
++
++ The default is true for Rectangles with a radius, and false otherwise.
++ */
++
++ /*!
++ \qmlpropertygroup QtQuick::Rectangle::border
++ \qmlproperty int QtQuick::Rectangle::border.width
++ \qmlproperty color QtQuick::Rectangle::border.color
++ \qmlproperty bool QtQuick::Rectangle::border.pixelAligned
++
++ The width and color used to draw the border of the rectangle.
++
++ A width of 1 creates a thin line. For no line, use a width of 0 or a transparent color.
++
++ \note The width of the rectangle's border does not affect the geometry of the
++ rectangle itself or its position relative to other items if anchors are used.
++
++ The border is rendered within the rectangle's boundaries.
++
++ If \c pixelAligned is \c true (the default), the rendered border width is rounded to a whole
++ number of pixels, after device pixel ratio scaling. Setting \c pixelAligned to \c false will
++ allow fractional border widths, which may be desirable when \c antialiasing is enabled.
++ */
++ QQuickPen *QQuickRectangle::border()
++ {
++ Q_D(QQuickRectangle);
++ if (!d->pen) {
++ d->pen = new QQuickPen;
++ QQml_setParent_noEvent(d->pen, this);
++ }
++ return d->pen;
++ }
++
++ /*!
++ \qmlproperty var QtQuick::Rectangle::gradient
++
++ The gradient to use to fill the rectangle.
++
++ This property allows for the construction of simple vertical or horizontal gradients.
++ Other gradients may be formed by adding rotation to the rectangle.
++
++ \div {class="float-left"}
++ \inlineimage declarative-rect_gradient.png
++ {Four rectangles showing gradient variations}
++ \enddiv
++
++ \snippet qml/rectangle/rectangle-gradient.qml rectangles
++ \clearfloat
++
++ The property also accepts gradient presets from QGradient::Preset. Note however
++ that due to Rectangle only supporting simple vertical or horizontal gradients,
++ any preset with an unsupported angle will revert to the closest representation.
++
++ \snippet qml/rectangle/rectangle-gradient.qml presets
++ \clearfloat
++
++ If both a gradient and a color are specified, the gradient will be used.
++
++ \sa Gradient, color
++ */
++ QJSValue QQuickRectangle::gradient() const
++ {
++ Q_D(const QQuickRectangle);
++ return d->gradient;
++ }
++
++ void QQuickRectangle::setGradient(const QJSValue &gradient)
++ {
++ Q_D(QQuickRectangle);
++ if (d->gradient.equals(gradient))
++ return;
++
++ static int updatedSignalIdx = QMetaMethod::fromSignal(&QQuickGradient::updated).methodIndex();
++ if (d->doUpdateSlotIdx < 0)
++ d->doUpdateSlotIdx = QQuickRectangle::staticMetaObject.indexOfSlot("doUpdate()");
++
++ if (auto oldGradient = qobject_cast<QQuickGradient*>(d->gradient.toQObject()))
++ QMetaObject::disconnect(oldGradient, updatedSignalIdx, this, d->doUpdateSlotIdx);
++
++ if (gradient.isQObject()) {
++ if (auto newGradient = qobject_cast<QQuickGradient*>(gradient.toQObject())) {
++ d->gradient = gradient;
++ QMetaObject::connect(newGradient, updatedSignalIdx, this, d->doUpdateSlotIdx);
++ } else {
++ qmlWarning(this) << "Can't assign "
++ << QQmlMetaType::prettyTypeName(gradient.toQObject()) << " to gradient property";
++ d->gradient = QJSValue();
++ }
++ } else if (gradient.isNumber() || gradient.isString()) {
++ static const QMetaEnum gradientPresetMetaEnum = QMetaEnum::fromType<QGradient::Preset>();
++ Q_ASSERT(gradientPresetMetaEnum.isValid());
++
++ QGradient result;
++
++ // This code could simply use gradient.toVariant().convert<QGradient::Preset>(),
++ // but QTBUG-76377 prevents us from doing error checks. So we need to
++ // do them manually. Also, NumPresets cannot be used.
++
++ if (gradient.isNumber()) {
++ const auto preset = QGradient::Preset(gradient.toInt());
++ if (preset != QGradient::NumPresets && gradientPresetMetaEnum.valueToKey(preset))
++ result = QGradient(preset);
++ } else if (gradient.isString()) {
++ const auto presetName = gradient.toString();
++ if (presetName != QLatin1String("NumPresets")) {
++ bool ok;
++ const auto presetInt = gradientPresetMetaEnum.keyToValue(qPrintable(presetName), &ok);
++ if (ok)
++ result = QGradient(QGradient::Preset(presetInt));
++ }
++ }
++
++ if (result.type() != QGradient::NoGradient) {
++ d->gradient = gradient;
++ } else {
++ qmlWarning(this) << "No such gradient preset '" << gradient.toString() << "'";
++ d->gradient = QJSValue();
++ }
++ } else if (gradient.isNull() || gradient.isUndefined()) {
++ d->gradient = gradient;
++ } else {
++ qmlWarning(this) << "Unknown gradient type. Expected int, string, or Gradient";
++ d->gradient = QJSValue();
++ }
++
++ update();
++ }
++
++ void QQuickRectangle::resetGradient()
++ {
++ setGradient(QJSValue());
++ }
++
++ /*!
++ \qmlproperty real QtQuick::Rectangle::radius
++ This property holds the corner radius used to draw a rounded rectangle.
++
++ If radius is non-zero, the rectangle will be painted as a rounded rectangle,
++ otherwise it will be painted as a normal rectangle. Individual corner radii
++ can be set as well (see below). These values will override \l radius. If
++ they are unset (by setting them to \c undefined), \l radius will be used instead.
++
++ \sa topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius
++ */
++ qreal QQuickRectangle::radius() const
++ {
++ Q_D(const QQuickRectangle);
++ return d->radius;
++ }
++
++ void QQuickRectangle::setRadius(qreal radius)
++ {
++ Q_D(QQuickRectangle);
++ if (d->radius == radius)
++ return;
++
++ d->radius = radius;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit radiusChanged();
++
++ if (d->extraRectangle.isAllocated()) {
++ if (!d->extraRectangle->isTopLeftRadiusSet)
++ emit topLeftRadiusChanged();
++ if (!d->extraRectangle->isTopRightRadiusSet)
++ emit topRightRadiusChanged();
++ if (!d->extraRectangle->isBottomLeftRadiusSet)
++ emit bottomLeftRadiusChanged();
++ if (!d->extraRectangle->isBottomRightRadiusSet)
++ emit bottomRightRadiusChanged();
++ } else {
++ emit topLeftRadiusChanged();
++ emit topRightRadiusChanged();
++ emit bottomLeftRadiusChanged();
++ emit bottomRightRadiusChanged();
++ }
++ }
++
++ /*!
++ \since 6.7
++ \qmlproperty real QtQuick::Rectangle::topLeftRadius
++ This property holds the radius used to draw the top left corner.
++
++ If \l topLeftRadius is not set, \l radius will be used instead.
++ If \l topLeftRadius is zero, the corner will be sharp.
++
++ \sa radius, topRightRadius, bottomLeftRadius, bottomRightRadius
++ */
++ qreal QQuickRectangle::topLeftRadius() const
++ {
++ Q_D(const QQuickRectangle);
++ if (d->extraRectangle.isAllocated() && d->extraRectangle->isTopLeftRadiusSet)
++ return d->extraRectangle->topLeftRadius;
++ return d->radius;
++ }
++
++ void QQuickRectangle::setTopLeftRadius(qreal radius)
++ {
++ Q_D(QQuickRectangle);
++ if (d->extraRectangle.isAllocated()
++ && d->extraRectangle->topLeftRadius == radius
++ && d->extraRectangle->isTopLeftRadiusSet) {
++ return;
++ }
++
++ d->extraRectangle.value().topLeftRadius = radius;
++ d->extraRectangle.value().isTopLeftRadiusSet = true;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit topLeftRadiusChanged();
++ }
++
++ void QQuickRectangle::resetTopLeftRadius()
++ {
++ Q_D(QQuickRectangle);
++ if (!d->extraRectangle.isAllocated())
++ return;
++ if (!d->extraRectangle->isTopLeftRadiusSet)
++ return;
++
++ d->extraRectangle->isTopLeftRadiusSet = false;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit topLeftRadiusChanged();
++ }
++
++ /*!
++ \since 6.7
++ \qmlproperty real QtQuick::Rectangle::topRightRadius
++ This property holds the radius used to draw the top right corner.
++
++ If \l topRightRadius is not set, \l radius will be used instead.
++ If \l topRightRadius is zero, the corner will be sharp.
++
++ \sa radius, topLeftRadius, bottomLeftRadius, bottomRightRadius
++ */
++ qreal QQuickRectangle::topRightRadius() const
++ {
++ Q_D(const QQuickRectangle);
++ if (d->extraRectangle.isAllocated() && d->extraRectangle->isTopRightRadiusSet)
++ return d->extraRectangle->topRightRadius;
++ return d->radius;
++ }
++
++ void QQuickRectangle::setTopRightRadius(qreal radius)
++ {
++ Q_D(QQuickRectangle);
++ if (d->extraRectangle.isAllocated()
++ && d->extraRectangle->topRightRadius == radius
++ && d->extraRectangle->isTopRightRadiusSet) {
++ return;
++ }
++
++ d->extraRectangle.value().topRightRadius = radius;
++ d->extraRectangle.value().isTopRightRadiusSet = true;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit topRightRadiusChanged();
++ }
++
++ void QQuickRectangle::resetTopRightRadius()
++ {
++ Q_D(QQuickRectangle);
++ if (!d->extraRectangle.isAllocated())
++ return;
++ if (!d->extraRectangle.value().isTopRightRadiusSet)
++ return;
++
++ d->extraRectangle->isTopRightRadiusSet = false;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit topRightRadiusChanged();
++ }
++
++ /*!
++ \since 6.7
++ \qmlproperty real QtQuick::Rectangle::bottomLeftRadius
++ This property holds the radius used to draw the bottom left corner.
++
++ If \l bottomLeftRadius is not set, \l radius will be used instead.
++ If \l bottomLeftRadius is zero, the corner will be sharp.
++
++ \sa radius, topLeftRadius, topRightRadius, bottomRightRadius
++ */
++ qreal QQuickRectangle::bottomLeftRadius() const
++ {
++ Q_D(const QQuickRectangle);
++ if (d->extraRectangle.isAllocated() && d->extraRectangle->isBottomLeftRadiusSet)
++ return d->extraRectangle->bottomLeftRadius;
++ return d->radius;
++ }
++
++ void QQuickRectangle::setBottomLeftRadius(qreal radius)
++ {
++ Q_D(QQuickRectangle);
++ if (d->extraRectangle.isAllocated()
++ && d->extraRectangle->bottomLeftRadius == radius
++ && d->extraRectangle->isBottomLeftRadiusSet) {
++ return;
++ }
++
++ d->extraRectangle.value().bottomLeftRadius = radius;
++ d->extraRectangle.value().isBottomLeftRadiusSet = true;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit bottomLeftRadiusChanged();
++ }
++
++ void QQuickRectangle::resetBottomLeftRadius()
++ {
++ Q_D(QQuickRectangle);
++ if (!d->extraRectangle.isAllocated())
++ return;
++ if (!d->extraRectangle.value().isBottomLeftRadiusSet)
++ return;
++
++ d->extraRectangle->isBottomLeftRadiusSet = false;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit bottomLeftRadiusChanged();
++ }
++
++ /*!
++ \since 6.7
++ \qmlproperty real QtQuick::Rectangle::bottomRightRadius
++ This property holds the radius used to draw the bottom right corner.
++
++ If \l bottomRightRadius is not set, \l radius will be used instead.
++ If \l bottomRightRadius is zero, the corner will be sharp.
++
++ \sa radius, topLeftRadius, topRightRadius, bottomLeftRadius
++ */
++ qreal QQuickRectangle::bottomRightRadius() const
++ {
++ Q_D(const QQuickRectangle);
++ if (d->extraRectangle.isAllocated() && d->extraRectangle->isBottomRightRadiusSet)
++ return d->extraRectangle->bottomRightRadius;
++ return d->radius;
++ }
++
++ void QQuickRectangle::setBottomRightRadius(qreal radius)
++ {
++ Q_D(QQuickRectangle);
++ if (d->extraRectangle.isAllocated()
++ && d->extraRectangle->bottomRightRadius == radius
++ && d->extraRectangle->isBottomRightRadiusSet) {
++ return;
++ }
++
++ d->extraRectangle.value().bottomRightRadius = radius;
++ d->extraRectangle.value().isBottomRightRadiusSet = true;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit bottomRightRadiusChanged();
++ }
++
++ void QQuickRectangle::resetBottomRightRadius()
++ {
++ Q_D(QQuickRectangle);
++ if (!d->extraRectangle.isAllocated())
++ return;
++ if (!d->extraRectangle.value().isBottomRightRadiusSet)
++ return;
++
++ d->extraRectangle->isBottomRightRadiusSet = false;
++ d->maybeSetImplicitAntialiasing();
++
++ update();
++ emit bottomRightRadiusChanged();
++ }
++
++ /*!
++ \qmlproperty color QtQuick::Rectangle::color
++ This property holds the color used to fill the rectangle.
++
++ The default color is white.
++
++ \div {class="float-right"}
++ \inlineimage rect-color.png
++ {Green and blue rectangles demonstrating color property}
++ \enddiv
++
++ The following example shows rectangles with colors specified
++ using hexadecimal and named color notation:
++
++ \snippet qml/rectangle/rectangle-colors.qml rectangles
++
++ \clearfloat
++ If both a gradient and a color are specified, the gradient will be used.
++
++ \sa gradient
++ */
++ QColor QQuickRectangle::color() const
++ {
++ Q_D(const QQuickRectangle);
++ return d->color;
++ }
++
++ void QQuickRectangle::setColor(const QColor &c)
++ {
++ Q_D(QQuickRectangle);
++ if (d->color == c)
++ return;
++
++ d->color = c;
++ update();
++ emit colorChanged();
++ }
++
++ void QQuickRectangle::resetColor()
++ {
++ setColor(Qt::white);
++ }
++
++ QSGNode *QQuickRectangle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
++ {
++ Q_UNUSED(data);
++ Q_D(QQuickRectangle);
++
++ if (width() <= 0 || height() <= 0
++ || (d->gradient.isUndefined() && d->color.alpha() == 0 && (!d->pen || d->pen->width() == 0 || d->pen->color().alpha() == 0))) {
++ delete oldNode;
++ return nullptr;
++ }
++
++ QSGInternalRectangleNode *rectangle = static_cast<QSGInternalRectangleNode *>(oldNode);
++ if (!rectangle) rectangle = d->sceneGraphContext()->createInternalRectangleNode();
++
++ rectangle->setRect(QRectF(0, 0, width(), height()));
++ rectangle->setColor(d->color);
++
++ if (d->pen && d->pen->isValid()) {
++ rectangle->setPenColor(d->pen->color());
++ qreal penWidth = d->pen->width();
++ if (d->pen->pixelAligned()) {
++ qreal dpr = d->effectiveDevicePixelRatio();
++ penWidth = qRound(penWidth * dpr) / dpr; // Ensures integer width after dpr scaling
++ }
++ rectangle->setPenWidth(penWidth);
++ rectangle->setAligned(false); // width rounding already done, so the Node should not do it
++ } else {
++ rectangle->setPenWidth(0);
++ }
++
++ rectangle->setRadius(d->radius);
++ if (d->extraRectangle.isAllocated()) {
++ const auto &extra = d->extraRectangle.value();
++ if (extra.isTopLeftRadiusSet)
++ rectangle->setTopLeftRadius(extra.topLeftRadius);
++ else
++ rectangle->resetTopLeftRadius();
++ if (extra.isTopRightRadiusSet)
++ rectangle->setTopRightRadius(extra.topRightRadius);
++ else
++ rectangle->resetTopRightRadius();
++ if (extra.isBottomLeftRadiusSet)
++ rectangle->setBottomLeftRadius(extra.bottomLeftRadius);
++ else
++ rectangle->resetBottomLeftRadius();
++ if (extra.isBottomRightRadiusSet)
++ rectangle->setBottomRightRadius(extra.bottomRightRadius);
++ else
++ rectangle->resetBottomRightRadius();
++ } else {
++ rectangle->resetTopLeftRadius();
++ rectangle->resetTopRightRadius();
++ rectangle->resetBottomLeftRadius();
++ rectangle->resetBottomRightRadius();
++ }
++ rectangle->setAntialiasing(antialiasing());
++
++ QGradientStops stops;
++ bool vertical = true;
++ if (d->gradient.isQObject()) {
++ auto gradient = qobject_cast<QQuickGradient*>(d->gradient.toQObject());
++ Q_ASSERT(gradient);
++ stops = gradient->gradientStops();
++ vertical = gradient->orientation() == QQuickGradient::Vertical;
++ } else if (d->gradient.isNumber() || d->gradient.isString()) {
++ QGradient preset(d->gradient.toVariant().value<QGradient::Preset>());
++ if (preset.type() == QGradient::LinearGradient) {
++ auto linearGradient = static_cast<QLinearGradient&>(preset);
++ const QPointF start = linearGradient.start();
++ const QPointF end = linearGradient.finalStop();
++ vertical = qAbs(start.y() - end.y()) >= qAbs(start.x() - end.x());
++ stops = linearGradient.stops();
++ if ((vertical && start.y() > end.y()) || (!vertical && start.x() > end.x())) {
++ // QSGInternalRectangleNode doesn't support stops in the wrong order,
++ // so we need to manually reverse them here.
++ QGradientStops reverseStops;
++ for (auto it = stops.rbegin(); it != stops.rend(); ++it) {
++ auto stop = *it;
++ stop.first = 1 - stop.first;
++ reverseStops.append(stop);
++ }
++ stops = reverseStops;
++ }
++ }
++ }
++ rectangle->setGradientStops(stops);
++ rectangle->setGradientVertical(vertical);
++
++ rectangle->update();
++
++ return rectangle;
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qquickrectangle_p.cpp"