qquickrectangle.cpp

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
 
#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?
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;
}
 
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();
}
 
QQuickGradient::QQuickGradient(QObject *parent)
: QObject(parent)
{
}
 
QQuickGradient::~QQuickGradient()
{
}
 
QQmlListProperty<QQuickGradientStop> QQuickGradient::stops()
{
    return QQmlListProperty<QQuickGradientStop>(this, &m_stops);
}
 
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 (extra.isAllocated() && !implicitAA) {
        implicitAA = extra.value().topLeftRadius > 0.0
            || extra.value().topRightRadius > 0.0
            || extra.value().bottomLeftRadius > 0.0
            || extra.value().bottomRightRadius > 0.0;
    }
    setImplicitAntialiasing(implicitAA);
}
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();
}
 
QQuickPen *QQuickRectangle::border()
{
    Q_D(QQuickRectangle);
    if (!d->pen) {
        d->pen = new QQuickPen;
        QQml_setParent_noEvent(d->pen, this);
    }
    return d->pen;
}
 
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());
}
 
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();
}
 
qreal QQuickRectangle::topLeftRadius() const
{
    Q_D(const QQuickRectangle);
    if (d->extra.isAllocated())
        return qMax(d->extra.value().topLeftRadius, 0.);
    return 0;
}
 
void QQuickRectangle::setTopLeftRadius(qreal radius)
{
    Q_D(QQuickRectangle);
    if (d->extra.value().topLeftRadius == radius)
        return;
 
    if (radius < 0) { // use the fact that radius < 0 resets the radius.
        qmlWarning(this) << "topLeftRadius (" << radius << ") cannot be less than 0.";
        return;
    }
    d->extra.value().topLeftRadius = radius;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit topLeftRadiusChanged();
}
 
void QQuickRectangle::resetTopLeftRadius()
{
    Q_D(QQuickRectangle);
    if (!d->extra.isAllocated())
        return;
    if (d->extra.value().topLeftRadius < 0)
        return;
 
    d->extra.value().topLeftRadius = -1.;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit topLeftRadiusChanged();
}
 
qreal QQuickRectangle::topRightRadius() const
{
    Q_D(const QQuickRectangle);
    if (d->extra.isAllocated())
        return qMax(d->extra.value().topRightRadius, 0.);
    return 0;
}
 
void QQuickRectangle::setTopRightRadius(qreal radius)
{
    Q_D(QQuickRectangle);
    if (d->extra.value().topRightRadius == radius)
        return;
 
    if (radius < 0) { // use the fact that radius < 0 resets the radius.
        qmlWarning(this) << "topRightRadius (" << radius << ") cannot be less than 0.";
        return;
    }
    d->extra.value().topRightRadius = radius;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit topRightRadiusChanged();
}
 
void QQuickRectangle::resetTopRightRadius()
{
    Q_D(QQuickRectangle);
    if (!d->extra.isAllocated())
        return;
    if (d->extra.value().topRightRadius < 0)
        return;
 
    d->extra.value().topRightRadius = -1.;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit topRightRadiusChanged();
}
 
qreal QQuickRectangle::bottomLeftRadius() const
{
    Q_D(const QQuickRectangle);
    if (d->extra.isAllocated())
        return qMax(d->extra.value().bottomLeftRadius, 0.);
    return 0;
}
 
void QQuickRectangle::setBottomLeftRadius(qreal radius)
{
    Q_D(QQuickRectangle);
    if (d->extra.value().bottomLeftRadius == radius)
        return;
 
    if (radius < 0) { // use the fact that radius < 0 resets the radius.
        qmlWarning(this) << "bottomLeftRadius (" << radius << ") cannot be less than 0.";
        return;
    }
 
    d->extra.value().bottomLeftRadius = radius;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit bottomLeftRadiusChanged();
}
 
void QQuickRectangle::resetBottomLeftRadius()
{
    Q_D(QQuickRectangle);
    if (!d->extra.isAllocated())
        return;
    if (d->extra.value().bottomLeftRadius < 0)
        return;
 
    d->extra.value().bottomLeftRadius = -1.;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit bottomLeftRadiusChanged();
}
 
qreal QQuickRectangle::bottomRightRadius() const
{
    Q_D(const QQuickRectangle);
    if (d->extra.isAllocated())
        return qMax(d->extra.value().bottomRightRadius, 0.);
    return 0;
}
 
void QQuickRectangle::setBottomRightRadius(qreal radius)
{
    Q_D(QQuickRectangle);
    if (d->extra.value().bottomRightRadius == radius)
        return;
 
    if (radius < 0) { // use the fact that radius < 0 resets the radius.
        qmlWarning(this) << "bottomRightRadius (" << radius << ") cannot be less than 0.";
        return;
    }
 
    d->extra.value().bottomRightRadius = radius;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit bottomRightRadiusChanged();
}
 
void QQuickRectangle::resetBottomRightRadius()
{
    Q_D(QQuickRectangle);
    if (!d->extra.isAllocated())
        return;
    if (d->extra.value().bottomRightRadius < 0)
        return;
 
    d->extra.value().bottomRightRadius = -1.;
    d->maybeSetImplicitAntialiasing();
 
    update();
    emit bottomRightRadiusChanged();
}
 
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();
}
 
QSGNode *QQuickRectangle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
    Q_UNUSED(data);
    Q_D(QQuickRectangle);
 
    if (width() <= 0 || height() <= 0
            || (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 = window() ? window()->effectiveDevicePixelRatio() : 1.0;
            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->extra.isAllocated()) {
        rectangle->setTopLeftRadius(d->extra.value().topLeftRadius);
        rectangle->setTopRightRadius(d->extra.value().topRightRadius);
        rectangle->setBottomLeftRadius(d->extra.value().bottomLeftRadius);
        rectangle->setBottomRightRadius(d->extra.value().bottomRightRadius);
    } else {
        rectangle->setTopLeftRadius(-1.);
        rectangle->setTopRightRadius(-1.);
        rectangle->setBottomLeftRadius(-1.);
        rectangle->setBottomRightRadius(-1.);
    }
    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"