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 "qtgradientutils_p.h"
++ #include "qtgradientmanager_p.h"
++
++ #include <QtGui/qbrush.h>
++ #include <QtGui/qpainter.h>
++
++ #include <QtXml/qdom.h>
++
++ #include <QtCore/qdebug.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ static QString gradientTypeToString(QGradient::Type type)
++ {
++ if (type == QGradient::LinearGradient)
++ return "LinearGradient"_L1;
++ if (type == QGradient::RadialGradient)
++ return "RadialGradient"_L1;
++ if (type == QGradient::ConicalGradient)
++ return "ConicalGradient"_L1;
++ return "NoGradient"_L1;
++ }
++
++ static QGradient::Type stringToGradientType(const QString &name)
++ {
++ if (name == "LinearGradient"_L1)
++ return QGradient::LinearGradient;
++ if (name == "RadialGradient"_L1)
++ return QGradient::RadialGradient;
++ if (name == "ConicalGradient"_L1)
++ return QGradient::ConicalGradient;
++ return QGradient::NoGradient;
++ }
++
++ static QString gradientSpreadToString(QGradient::Spread spread)
++ {
++ if (spread == QGradient::PadSpread)
++ return "PadSpread"_L1;
++ if (spread == QGradient::RepeatSpread)
++ return "RepeatSpread"_L1;
++ if (spread == QGradient::ReflectSpread)
++ return "ReflectSpread"_L1;
++ return "PadSpread"_L1;
++ }
++
++ static QGradient::Spread stringToGradientSpread(const QString &name)
++ {
++ if (name == "PadSpread"_L1)
++ return QGradient::PadSpread;
++ if (name == "RepeatSpread"_L1)
++ return QGradient::RepeatSpread;
++ if (name == "ReflectSpread"_L1)
++ return QGradient::ReflectSpread;
++ return QGradient::PadSpread;
++ }
++
++ static QString gradientCoordinateModeToString(QGradient::CoordinateMode mode)
++ {
++ if (mode == QGradient::LogicalMode)
++ return "LogicalMode"_L1;
++ if (mode == QGradient::StretchToDeviceMode)
++ return "StretchToDeviceMode"_L1;
++ if (mode == QGradient::ObjectBoundingMode)
++ return "ObjectBoundingMode"_L1;
++ return "StretchToDeviceMode"_L1;
++ }
++
++ static QGradient::CoordinateMode stringToGradientCoordinateMode(const QString &name)
++ {
++ if (name == "LogicalMode"_L1)
++ return QGradient::LogicalMode;
++ if (name == "StretchToDeviceMode"_L1)
++ return QGradient::StretchToDeviceMode;
++ if (name == "ObjectBoundingMode"_L1)
++ return QGradient::ObjectBoundingMode;
++ return QGradient::StretchToDeviceMode;
++ }
++
++ static QDomElement saveColor(QDomDocument &doc, QColor color)
++ {
++ QDomElement colorElem = doc.createElement("colorData"_L1);
++
++ colorElem.setAttribute("r"_L1, QString::number(color.red()));
++ colorElem.setAttribute("g"_L1, QString::number(color.green()));
++ colorElem.setAttribute("b"_L1, QString::number(color.blue()));
++ colorElem.setAttribute("a"_L1, QString::number(color.alpha()));
++
++ return colorElem;
++ }
++
++ static QDomElement saveGradientStop(QDomDocument &doc, const QGradientStop &stop)
++ {
++ QDomElement stopElem = doc.createElement("stopData"_L1);
++
++ stopElem.setAttribute("position"_L1, QString::number(stop.first));
++
++ const QDomElement colorElem = saveColor(doc, stop.second);
++ stopElem.appendChild(colorElem);
++
++ return stopElem;
++ }
++
++ static QDomElement saveGradient(QDomDocument &doc, const QGradient &gradient)
++ {
++ QDomElement gradElem = doc.createElement("gradientData"_L1);
++
++ const QGradient::Type type = gradient.type();
++ gradElem.setAttribute("type"_L1, gradientTypeToString(type));
++ gradElem.setAttribute("spread"_L1, gradientSpreadToString(gradient.spread()));
++ gradElem.setAttribute("coordinateMode"_L1, gradientCoordinateModeToString(gradient.coordinateMode()));
++
++ const QGradientStops stops = gradient.stops();
++ for (const QGradientStop &stop : stops)
++ gradElem.appendChild(saveGradientStop(doc, stop));
++
++ if (type == QGradient::LinearGradient) {
++ const QLinearGradient &g = *static_cast<const QLinearGradient *>(&gradient);
++ gradElem.setAttribute("startX"_L1, QString::number(g.start().x()));
++ gradElem.setAttribute("startY"_L1, QString::number(g.start().y()));
++ gradElem.setAttribute("endX"_L1, QString::number(g.finalStop().x()));
++ gradElem.setAttribute("endY"_L1, QString::number(g.finalStop().y()));
++ } else if (type == QGradient::RadialGradient) {
++ const QRadialGradient &g = *static_cast<const QRadialGradient *>(&gradient);
++ gradElem.setAttribute("centerX"_L1, QString::number(g.center().x()));
++ gradElem.setAttribute("centerY"_L1, QString::number(g.center().y()));
++ gradElem.setAttribute("focalX"_L1, QString::number(g.focalPoint().x()));
++ gradElem.setAttribute("focalY"_L1, QString::number(g.focalPoint().y()));
++ gradElem.setAttribute("radius"_L1, QString::number(g.radius()));
++ } else if (type == QGradient::ConicalGradient) {
++ const QConicalGradient &g = *static_cast<const QConicalGradient*>(&gradient);
++ gradElem.setAttribute("centerX"_L1, QString::number(g.center().x()));
++ gradElem.setAttribute("centerY"_L1, QString::number(g.center().y()));
++ gradElem.setAttribute("angle"_L1, QString::number(g.angle()));
++ }
++
++ return gradElem;
++ }
++
++ static QColor loadColor(const QDomElement &elem)
++ {
++ if (elem.tagName() != "colorData"_L1)
++ return QColor();
++
++ return QColor(elem.attribute("r"_L1).toInt(),
++ elem.attribute("g"_L1).toInt(),
++ elem.attribute("b"_L1).toInt(),
++ elem.attribute("a"_L1).toInt());
++ }
++
++ static QGradientStop loadGradientStop(const QDomElement &elem)
++ {
++ if (elem.tagName() != "stopData"_L1)
++ return QGradientStop();
++
++ const qreal pos = static_cast<qreal>(elem.attribute("position"_L1).toDouble());
++ return std::make_pair(pos, loadColor(elem.firstChild().toElement()));
++ }
++
++ static QGradient loadGradient(const QDomElement &elem)
++ {
++ if (elem.tagName() != "gradientData"_L1)
++ return QLinearGradient();
++
++ const QGradient::Type type = stringToGradientType(elem.attribute("type"_L1));
++ const QGradient::Spread spread = stringToGradientSpread(elem.attribute("spread"_L1));
++ const QGradient::CoordinateMode mode = stringToGradientCoordinateMode(elem.attribute("coordinateMode"_L1));
++
++ QGradient gradient = QLinearGradient();
++
++ if (type == QGradient::LinearGradient) {
++ QLinearGradient g;
++ g.setStart(elem.attribute("startX"_L1).toDouble(), elem.attribute("startY"_L1).toDouble());
++ g.setFinalStop(elem.attribute("endX"_L1).toDouble(), elem.attribute("endY"_L1).toDouble());
++ gradient = g;
++ } else if (type == QGradient::RadialGradient) {
++ QRadialGradient g;
++ g.setCenter(elem.attribute("centerX"_L1).toDouble(), elem.attribute("centerY"_L1).toDouble());
++ g.setFocalPoint(elem.attribute("focalX"_L1).toDouble(), elem.attribute("focalY"_L1).toDouble());
++ g.setRadius(elem.attribute("radius"_L1).toDouble());
++ gradient = g;
++ } else if (type == QGradient::ConicalGradient) {
++ QConicalGradient g;
++ g.setCenter(elem.attribute("centerX"_L1).toDouble(), elem.attribute("centerY"_L1).toDouble());
++ g.setAngle(elem.attribute("angle"_L1).toDouble());
++ gradient = g;
++ }
++
++ QDomElement stopElem = elem.firstChildElement();
++ while (!stopElem.isNull()) {
++ QGradientStop stop = loadGradientStop(stopElem);
++
++ gradient.setColorAt(stop.first, stop.second);
++
++ stopElem = stopElem.nextSiblingElement();
++ }
++
++ gradient.setSpread(spread);
++ gradient.setCoordinateMode(mode);
++
++ return gradient;
++ }
++
++ QString QtGradientUtils::saveState(const QtGradientManager *manager)
++ {
++ QDomDocument doc;
++
++ QDomElement rootElem = doc.createElement("gradients"_L1);
++
++ QMap<QString, QGradient> grads = manager->gradients();
++ for (auto itGrad = grads.cbegin(), end = grads.cend(); itGrad != end; ++itGrad) {
++ QDomElement idElem = doc.createElement("gradient"_L1);
++ idElem.setAttribute("name"_L1, itGrad.key());
++ QDomElement gradElem = saveGradient(doc, itGrad.value());
++ idElem.appendChild(gradElem);
++
++ rootElem.appendChild(idElem);
++ }
++
++ doc.appendChild(rootElem);
++
++ return doc.toString();
++ }
++
++ void QtGradientUtils::restoreState(QtGradientManager *manager, const QString &state)
++ {
++ manager->clear();
++
++ QDomDocument doc;
++ doc.setContent(state);
++
++ QDomElement rootElem = doc.documentElement();
++
++ QDomElement gradElem = rootElem.firstChildElement();
++ while (!gradElem.isNull()) {
++ const QString name = gradElem.attribute("name"_L1);
++ const QGradient gradient = loadGradient(gradElem.firstChildElement());
++
++ manager->addGradient(name, gradient);
++ gradElem = gradElem.nextSiblingElement();
++ }
++ }
++
++ QPixmap QtGradientUtils::gradientPixmap(const QGradient &gradient, QSize size,
++ bool checkeredBackground)
++ {
++ QImage image(size, QImage::Format_ARGB32);
++ QPainter p(&image);
++ p.setCompositionMode(QPainter::CompositionMode_Source);
++
++ if (checkeredBackground) {
++ int pixSize = 20;
++ QPixmap pm(2 * pixSize, 2 * pixSize);
++
++ QPainter pmp(&pm);
++ pmp.fillRect(0, 0, pixSize, pixSize, Qt::lightGray);
++ pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::lightGray);
++ pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::darkGray);
++ pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::darkGray);
++
++ p.setBrushOrigin((size.width() % pixSize + pixSize) / 2, (size.height() % pixSize + pixSize) / 2);
++ p.fillRect(0, 0, size.width(), size.height(), pm);
++ p.setBrushOrigin(0, 0);
++ p.setCompositionMode(QPainter::CompositionMode_SourceOver);
++ }
++
++ const qreal scaleFactor = 0.999999;
++ p.scale(scaleFactor, scaleFactor);
++ QGradient grad = gradient;
++ grad.setCoordinateMode(QGradient::StretchToDeviceMode);
++ p.fillRect(QRect(0, 0, size.width(), size.height()), grad);
++ p.drawRect(QRect(0, 0, size.width() - 1, size.height() - 1));
++
++ return QPixmap::fromImage(image);
++ }
++
++ static QString styleSheetFillName(const QGradient &gradient)
++ {
++ QString result;
++
++ switch (gradient.type()) {
++ case QGradient::LinearGradient:
++ result += "qlineargradient"_L1;
++ break;
++ case QGradient::RadialGradient:
++ result += "qradialgradient"_L1;
++ break;
++ case QGradient::ConicalGradient:
++ result += "qconicalgradient"_L1;
++ break;
++ default:
++ qWarning() << "QtGradientUtils::styleSheetFillName(): gradient type" << gradient.type() << "not supported!";
++ break;
++ }
++
++ return result;
++ }
++
++ static QStringList styleSheetParameters(const QGradient &gradient)
++ {
++ QStringList result;
++
++ if (gradient.type() != QGradient::ConicalGradient) {
++ QString spread;
++ switch (gradient.spread()) {
++ case QGradient::PadSpread:
++ spread = "pad"_L1;
++ break;
++ case QGradient::ReflectSpread:
++ spread = "reflect"_L1;
++ break;
++ case QGradient::RepeatSpread:
++ spread = "repeat"_L1;
++ break;
++ default:
++ qWarning() << "QtGradientUtils::styleSheetParameters(): gradient spread" << gradient.spread() << "not supported!";
++ break;
++ }
++ result << "spread:"_L1 + spread;
++ }
++
++ switch (gradient.type()) {
++ case QGradient::LinearGradient: {
++ const QLinearGradient *linearGradient = static_cast<const QLinearGradient*>(&gradient);
++ result << "x1:"_L1 + QString::number(linearGradient->start().x())
++ << "y1:"_L1 + QString::number(linearGradient->start().y())
++ << "x2:"_L1 + QString::number(linearGradient->finalStop().x())
++ << "y2:"_L1 + QString::number(linearGradient->finalStop().y());
++ break;
++ }
++ case QGradient::RadialGradient: {
++ const QRadialGradient *radialGradient = static_cast<const QRadialGradient*>(&gradient);
++ result << "cx:"_L1 + QString::number(radialGradient->center().x())
++ << "cy:"_L1 + QString::number(radialGradient->center().y())
++ << "radius:"_L1 + QString::number(radialGradient->radius())
++ << "fx:"_L1 + QString::number(radialGradient->focalPoint().x())
++ << "fy:"_L1 + QString::number(radialGradient->focalPoint().y());
++ break;
++ }
++ case QGradient::ConicalGradient: {
++ const QConicalGradient *conicalGradient = static_cast<const QConicalGradient*>(&gradient);
++ result << "cx:"_L1 + QString::number(conicalGradient->center().x())
++ << "cy:"_L1 + QString::number(conicalGradient->center().y())
++ << "angle:"_L1 + QString::number(conicalGradient->angle());
++ break;
++ }
++ default:
++ qWarning() << "QtGradientUtils::styleSheetParameters(): gradient type" << gradient.type() << "not supported!";
++ break;
++ }
++
++ return result;
++ }
++
++ static QStringList styleSheetStops(const QGradient &gradient)
++ {
++ QStringList result;
++ const QGradientStops &stops = gradient.stops();
++ for (const QGradientStop &stop : stops) {
++ const QColor color = stop.second;
++
++ const QString stopDescription = "stop:"_L1 + QString::number(stop.first) + " rgba("_L1
++ + QString::number(color.red()) + ", "_L1
++ + QString::number(color.green()) + ", "_L1
++ + QString::number(color.blue()) + ", "_L1
++ + QString::number(color.alpha()) + QLatin1Char(')');
++ result << stopDescription;
++ }
++
++ return result;
++ }
++
++ QString QtGradientUtils::styleSheetCode(const QGradient &gradient)
++ {
++ QStringList gradientParameters;
++ gradientParameters << styleSheetParameters(gradient) << styleSheetStops(gradient);
++
++ return styleSheetFillName(gradient) + QLatin1Char('(') + gradientParameters.join(", "_L1) + QLatin1Char(')');
++ }
++
++ QT_END_NAMESPACE