#include <KoStopGradient.h>

Inheritance diagram for KoStopGradient:

Public Member Functions
void	bakeVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) override

KoResourceSP	clone () const override

void	colorAt (KoColor &, qreal t) const override
	reimplemented

QString	defaultFileExtension () const override
	reimplemented

	KoStopGradient (const KoStopGradient &rhs)

	KoStopGradient (const QString &filename=QString())

bool	loadFromDevice (QIODevice *dev, KisResourcesInterfaceSP resourcesInterface) override

KoStopGradient &	operator= (const KoStopGradient &rhs)=delete

bool	operator== (const KoStopGradient &rhs) const

QList< int >	requiredCanvasResources () const override

QPair< QString, QString >	resourceType () const override

QString	saveSvgGradient () const

bool	saveToDevice (QIODevice *dev) const override

void	setStops (QList< KoGradientStop > stops)
	Sets the gradient stops.

QList< KoGradientStop >	stops () const

bool	stopsAt (KoGradientStop &leftStop, KoGradientStop &rightStop, qreal t) const
	Find stops surrounding position, returns false if position outside gradient.

QGradient *	toQGradient () const override
	reimplemented

void	toXML (QDomDocument &doc, QDomElement &gradientElt) const
	toXML Convert the gradient to an XML string.

void	updateVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) override

	~KoStopGradient () override

Public Member Functions inherited from KoAbstractGradient
KoAbstractGradientSP	cloneAndBakeVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) const

KoAbstractGradientSP	cloneAndUpdateVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) const

const KoColorSpace *	colorSpace () const

QImage	generatePreview (int width, int height) const

QImage	generatePreview (int width, int height, KoCanvasResourcesInterfaceSP canvasResourcesInterface) const

	KoAbstractGradient (const KoAbstractGradient &rhs)

	KoAbstractGradient (const QString &filename)

void	setColorSpace (KoColorSpace *colorSpace)

void	setSpread (QGradient::Spread spreadMethod)

void	setType (QGradient::Type repeatType)

QGradient::Spread	spread () const

QGradient::Type	type () const

void	updatePreview ()

	~KoAbstractGradient () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KoResource
bool	active () const

void	addMetaData (QString key, QVariant value)
	store the given key, value pair in the resource

virtual void	clearSideLoadedResources ()

virtual QList< KoResourceLoadResult >	embeddedResources (KisResourcesInterfaceSP globalResourcesInterface) const

QString	filename () const

QImage	image () const

bool	isDirty () const

virtual bool	isEphemeral () const

virtual bool	isSerializable () const

	KoResource ()

	KoResource (const KoResource &rhs)

	KoResource (const QString &filename)

virtual QList< KoResourceLoadResult >	linkedResources (KisResourcesInterfaceSP globalResourcesInterface) const

bool	load (KisResourcesInterfaceSP resourcesInterface)

QString	md5Sum (bool generateIfEmpty=true) const

QMap< QString, QVariant >	metadata () const
	get a map with all the metadata

virtual QString	name () const

KoResource &	operator= (const KoResource &rhs)=delete

bool	permanent () const

QList< KoResourceLoadResult >	requiredResources (KisResourcesInterfaceSP globalResourcesInterface) const

int	resourceId () const

bool	save ()

void	setActive (bool active)

void	setDirty (bool value)
	Mark the preset as modified but not saved.

void	setFilename (const QString &filename)

void	setImage (const QImage &image)

void	setMD5Sum (const QString &md5sum)
	Set the md5sum of this resource. It must be in hex-encoded string format.

void	setName (const QString &name)

void	setPermanent (bool permanent)

void	setResourceId (int id)

void	setStorageLocation (const QString &location)

void	setValid (bool valid)

void	setVersion (int version)

virtual QList< KoResourceLoadResult >	sideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface) const

KoResourceSignature	signature () const

QString	storageLocation () const

QList< KoResourceLoadResult >	takeSideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface)

virtual QImage	thumbnail () const
	thumbnail the thumbnail image to use in resource selectors

virtual QString	thumbnailPath () const
	thumbnailPath returns the path to a separate thumbnail image, outside the actual resource file itself. If the path is relative, it is supposed start in the same location as the resource itself. If it's absolute, that is, it starts with "/", it is from the root of the storage.

virtual void	updateThumbnail ()
	updateThumbnail updates the thumbnail for this resource. Reimplement if your thumbnail is something else than the image set with setImage.

bool	valid () const

int	version () const
	Get the version of the resource.

virtual	~KoResource ()

Static Public Member Functions
static QSharedPointer< KoStopGradient >	fromQGradient (const QGradient *gradient)
	Creates KoStopGradient from a QGradient.

static KoStopGradient	fromXML (const QDomElement &elt)
	fromXML convert a gradient from xml.

Protected Attributes
QPointF	m_focalPoint

bool	m_hasVariableStops = false

QPointF	m_start

QPointF	m_stop

QList< KoGradientStop >	m_stops

Private Member Functions
void	loadSvgGradient (QIODevice *file)

void	parseSvgGradient (const QDomElement &element, QHash< QString, const KoColorProfile * > profiles)

Additional Inherited Members
Public Attributes inherited from KoAbstractGradient
const KoColorSpace *	colorSpace

QGradient::Spread	spread

QGradient::Type	type

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Public Attributes inherited from KoResource
bool	active {true}

QString	filename

QImage	image

QString	md5sum

QMap< QString, QVariant >	metadata

bool	modified {false}

QString	name

bool	permanent {false}

int	resourceId {-1}

QString	storageLocation

bool	valid {false}

int	version {-1}

Detailed Description

Resource for colorstop based gradients like SVG gradients

Definition at line 89 of file KoStopGradient.h.

Constructor & Destructor Documentation

◆ KoStopGradient() [1/2]

KoStopGradient::KoStopGradient ( const QString & filename = QString() )

explicit

Definition at line 39 of file KoStopGradient.cpp.

    : KoAbstractGradient(filename)
{
}

◆ ~KoStopGradient()

KoStopGradient::~KoStopGradient ( )

override

Definition at line 44 of file KoStopGradient.cpp.

45{

46}

◆ KoStopGradient() [2/2]

KoStopGradient::KoStopGradient ( const KoStopGradient & rhs )

Definition at line 48 of file KoStopGradient.cpp.

    : KoAbstractGradient(rhs)
    , m_stops(rhs.m_stops)
    , m_start(rhs.m_start)
    , m_stop(rhs.m_stop)
    , m_focalPoint(rhs.m_focalPoint)
{
}

Member Function Documentation

◆ bakeVariableColors()

void KoStopGradient::bakeVariableColors ( KoCanvasResourcesInterfaceSP canvasResourcesInterface )

overridevirtual

Reimplemented from KoAbstractGradient.

Definition at line 269 of file KoStopGradient.cpp.

{
    const KoColor fgColor = canvasResourcesInterface->resource(KoCanvasResource::ForegroundColor).value<KoColor>();
    const KoColor bgColor = canvasResourcesInterface->resource(KoCanvasResource::BackgroundColor).value<KoColor>();
 
    for (auto it = m_stops.begin(); it != m_stops.end(); ++it) {
        if (it->type == FOREGROUNDSTOP) {
            it->color = fgColor;
            it->type = COLORSTOP;
        } else if (it->type == BACKGROUNDSTOP) {
            it->color = bgColor;
            it->type = COLORSTOP;
        }
    }
}

References KoCanvasResource::BackgroundColor, BACKGROUNDSTOP, COLORSTOP, KoCanvasResource::ForegroundColor, FOREGROUNDSTOP, and m_stops.

◆ clone()

KoResourceSP KoStopGradient::clone ( ) const

overridevirtual

Implements KoResource.

Definition at line 69 of file KoStopGradient.cpp.

{
    return KoResourceSP(new KoStopGradient(*this));
}

References KoStopGradient().

◆ colorAt()

void KoStopGradient::colorAt	(	KoColor &	dst,
		qreal	t ) const

overridevirtual

reimplemented

Reimplemented from KoAbstractGradient.

Definition at line 154 of file KoStopGradient.cpp.

{
    KoGradientStop leftStop, rightStop;
    if (!stopsAt(leftStop, rightStop, t)) return;
 
    const KoColorSpace *mixSpace = dst.colorSpace();
 
    KoColor buffer(mixSpace);
    KoColor startDummy(leftStop.color, mixSpace);
    KoColor endDummy(rightStop.color, mixSpace);
 
    const std::array<quint8 *, 2> colors = {{startDummy.data(), endDummy.data()}};
 
    qreal localT = NAN;
    qreal stopDistance = rightStop.position - leftStop.position;
    if (stopDistance < DBL_EPSILON) {
        localT = 0.5;
    } else {
        localT = (t - leftStop.position) / stopDistance;
    }
    std::array<qint16, 2> colorWeights {};
    colorWeights[0] = std::lround((1.0 - localT) * qint16_MAX);
    colorWeights[1] = qint16_MAX - colorWeights[0];
 
    mixSpace->mixColorsOp()->mixColors(colors.data(), colorWeights.data(), 2, buffer.data(), qint16_MAX);
 
    dst = buffer;
}

References KoGradientStop::color, KoColor::colorSpace(), KoColor::data(), KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KoGradientStop::position, qint16_MAX, and stopsAt().

◆ defaultFileExtension()

QString KoStopGradient::defaultFileExtension ( ) const

overridevirtual

reimplemented

Reimplemented from KoResource.

Definition at line 543 of file KoStopGradient.cpp.

{
    return QString(".svg");
}

◆ fromQGradient()

QSharedPointer< KoStopGradient > KoStopGradient::fromQGradient ( const QGradient * gradient )

static

Creates KoStopGradient from a QGradient.

Definition at line 183 of file KoStopGradient.cpp.

{
    if (!gradient)
        return QSharedPointer<KoStopGradient>(0);
 
    QSharedPointer<KoStopGradient> newGradient(new KoStopGradient(QString()));
    newGradient->setType(gradient->type());
    newGradient->setSpread(gradient->spread());
 
    switch (gradient->type()) {
    case QGradient::LinearGradient: {
        const QLinearGradient* g = static_cast<const QLinearGradient*>(gradient);
        newGradient->m_start = g->start();
        newGradient->m_stop = g->finalStop();
        newGradient->m_focalPoint = g->start();
        break;
    }
    case QGradient::RadialGradient: {
        const QRadialGradient* g = static_cast<const QRadialGradient*>(gradient);
        newGradient->m_start = g->center();
        newGradient->m_stop = g->center() + QPointF(g->radius(), 0);
        newGradient->m_focalPoint = g->focalPoint();
        break;
    }
    case QGradient::ConicalGradient: {
        const QConicalGradient* g = static_cast<const QConicalGradient*>(gradient);
        qreal radian = g->angle() * M_PI / 180.0;
        newGradient->m_start = g->center();
        newGradient->m_stop = QPointF(100.0 * cos(radian), 100.0 * sin(radian));
        newGradient->m_focalPoint = g->center();
        break;
    }
    default:
        return QSharedPointer<KoStopGradient>(0);;
    }
 
    Q_FOREACH(const QGradientStop & stop, gradient->stops()) {
        KoColor color(newGradient->colorSpace());
        color.fromQColor(stop.second);
        newGradient->m_stops.append(KoGradientStop(stop.first, color, COLORSTOP));
    }
 
    newGradient->setValid(true);
 
    return newGradient;
}

References COLORSTOP, KoColor::fromQColor(), KoStopGradient(), and M_PI.

◆ fromXML()

KoStopGradient KoStopGradient::fromXML ( const QDomElement & elt )

static

fromXML convert a gradient from xml.

Returns: a gradient.

Definition at line 563 of file KoStopGradient.cpp.

{
    KoStopGradient gradient;
    QList<KoGradientStop> stops;
    QDomElement stopElt = elt.firstChildElement("stop");
    while (!stopElt.isNull()) {
        qreal offset = KisDomUtils::toDouble(stopElt.attribute("offset", "0.0"));
        QString bitDepth = stopElt.attribute("bitdepth", Integer8BitsColorDepthID.id());
        KoColor color = KoColor::fromXML(stopElt.firstChildElement(), bitDepth);
        color.setOpacity(KisDomUtils::toDouble(stopElt.attribute("alpha", "1.0")));
        KoGradientStopType stoptype = static_cast<KoGradientStopType>(KisDomUtils::toInt(stopElt.attribute("stoptype", "0")));
        stops.append(KoGradientStop(offset, color, stoptype));
        stopElt = stopElt.nextSiblingElement("stop");
    }
    gradient.setStops(stops);
    return gradient;
}

References KoColor::fromXML(), KoID::id(), Integer8BitsColorDepthID, KoColor::setOpacity(), setStops(), stops(), KisDomUtils::toDouble(), and KisDomUtils::toInt().

◆ loadFromDevice()

bool KoStopGradient::loadFromDevice	(	QIODevice *	dev,
		KisResourcesInterfaceSP	resourcesInterface )

overridevirtual

Implements KoResource.

Definition at line 74 of file KoStopGradient.cpp.

{
    Q_UNUSED(resourcesInterface);
    loadSvgGradient(dev);
    if (m_stops.count() >= 2) {
        setValid(true);
    }
    updatePreview();
    return true;
}

References loadSvgGradient(), m_stops, KoResource::setValid(), and KoAbstractGradient::updatePreview().

◆ loadSvgGradient()

void KoStopGradient::loadSvgGradient ( QIODevice * file )

private

Definition at line 299 of file KoStopGradient.cpp.

{
    QDomDocument doc;
 
    if (!(doc.setContent(file))) {
        file->close();
    } else {
        QHash<QString, const KoColorProfile*> profiles;
        for (QDomElement e = doc.documentElement().firstChildElement("defs"); !e.isNull(); e = e.nextSiblingElement("defs")) {
            for (QDomElement profileEl = e.firstChildElement("color-profile"); !profileEl.isNull(); profileEl = profileEl.nextSiblingElement("color-profile")) {
                const QString href = profileEl.attribute("xlink:href");
                const QByteArray uniqueId = QByteArray::fromHex(profileEl.attribute("local").toLatin1());
                const QString name = profileEl.attribute("name");
 
                const KoColorProfile *profile =
                        KoColorSpaceRegistry::instance()->profileByUniqueId(uniqueId);
                if (!profile) {
                    QFile file(href);
                    if (file.size() > 0 && file.open(QIODevice::ReadOnly)) {
                        KoColorSpaceEngine *engine = KoColorSpaceEngineRegistry::instance()->get("icc");
                        KIS_ASSERT(engine);
                        profile = engine->addProfile(href);
                    }
                }
 
 
                if (profile && !profiles.contains(name)) {
                    profiles.insert(name, profile);
                }
            }
        }
        for (QDomNode n = doc.documentElement().firstChild(); !n.isNull(); n = n.nextSibling()) {
            QDomElement e = n.toElement();
 
            if (e.isNull()) continue;
 
            if (e.tagName() == "linearGradient" || e.tagName() == "radialGradient") {
                parseSvgGradient(e, profiles);
                return;
            }
            // Inkscape gradients are in another defs
            if (e.tagName() == "defs") {
 
 
                for (QDomNode defnode = e.firstChild(); !defnode.isNull(); defnode = defnode.nextSibling()) {
                    QDomElement defelement = defnode.toElement();
 
                    if (defelement.isNull()) continue;
 
                    if (defelement.tagName() == "linearGradient" || defelement.tagName() == "radialGradient") {
                        parseSvgGradient(defelement, profiles);
                        return;
                    }
                }
            }
        }
    }
}

References KoColorSpaceEngine::addProfile(), KoGenericRegistry< T >::get(), KoColorSpaceEngineRegistry::instance(), KoColorSpaceRegistry::instance(), KIS_ASSERT, KoResource::name, parseSvgGradient(), and KoColorSpaceRegistry::profileByUniqueId().

◆ operator=()

KoStopGradient & KoStopGradient::operator= ( const KoStopGradient & rhs )

delete

◆ operator==()

bool KoStopGradient::operator== ( const KoStopGradient & rhs ) const

Definition at line 57 of file KoStopGradient.cpp.

{
    return
        *colorSpace() == *rhs.colorSpace() &&
        spread() == rhs.spread() &&
        type() == rhs.type() &&
        m_start == rhs.m_start &&
        m_stop == rhs.m_stop &&
        m_focalPoint == rhs.m_focalPoint &&
            m_stops == rhs.m_stops;
}

References KoAbstractGradient::colorSpace, m_focalPoint, m_start, m_stop, m_stops, KoAbstractGradient::spread, and KoAbstractGradient::type.

◆ parseSvgGradient()

void KoStopGradient::parseSvgGradient	(	const QDomElement &	element,
		QHash< QString, const KoColorProfile * >	profiles )

private

Definition at line 359 of file KoStopGradient.cpp.

{
    m_stops.clear();
    m_hasVariableStops = false;
    setSpread(QGradient::PadSpread);
 
    /*QString href = e.attribute( "xlink:href" ).mid( 1 );
    if( !href.isEmpty() )
    {
    }*/
    setName(element.attribute("id", i18n("SVG Gradient")));
 
    bool bbox = element.attribute("gradientUnits") != "userSpaceOnUse";
 
    if (element.tagName() == "linearGradient") {
 
        if (bbox) {
            QString s;
 
            s = element.attribute("x1", "0%");
            qreal xOrigin;
            if (s.endsWith('%'))
                xOrigin = s.remove('%').toDouble();
            else
                xOrigin = s.toDouble() * 100.0;
 
            s = element.attribute("y1", "0%");
            qreal yOrigin;
            if (s.endsWith('%'))
                yOrigin = s.remove('%').toDouble();
            else
                yOrigin = s.toDouble() * 100.0;
 
            s = element.attribute("x2", "100%");
            qreal xVector;
            if (s.endsWith('%'))
                xVector = s.remove('%').toDouble();
            else
                xVector = s.toDouble() * 100.0;
 
            s = element.attribute("y2", "0%");
            qreal yVector;
            if (s.endsWith('%'))
                yVector = s.remove('%').toDouble();
            else
                yVector = s.toDouble() * 100.0;
 
            m_start = QPointF(xOrigin, yOrigin);
            m_stop = QPointF(xVector, yVector);
        }
        else {
            m_start = QPointF(element.attribute("x1").toDouble(), element.attribute("y1").toDouble());
            m_stop = QPointF(element.attribute("x2").toDouble(), element.attribute("y2").toDouble());
        }
        setType(QGradient::LinearGradient);
    }
    else {
        if (bbox) {
            QString s;
 
            s = element.attribute("cx", "50%");
            qreal xOrigin;
            if (s.endsWith('%'))
                xOrigin = s.remove('%').toDouble();
            else
                xOrigin = s.toDouble() * 100.0;
 
            s = element.attribute("cy", "50%");
            qreal yOrigin;
            if (s.endsWith('%'))
                yOrigin = s.remove('%').toDouble();
            else
                yOrigin = s.toDouble() * 100.0;
 
            s = element.attribute("cx", "50%");
            qreal xVector;
            if (s.endsWith('%'))
                xVector = s.remove('%').toDouble();
            else
                xVector = s.toDouble() * 100.0;
 
            s = element.attribute("r", "50%");
            if (s.endsWith('%'))
                xVector += s.remove('%').toDouble();
            else
                xVector += s.toDouble() * 100.0;
 
            s = element.attribute("cy", "50%");
            qreal yVector;
            if (s.endsWith('%'))
                yVector = s.remove('%').toDouble();
            else
                yVector = s.toDouble() * 100.0;
 
            s = element.attribute("fx", "50%");
            qreal xFocal;
            if (s.endsWith('%'))
                xFocal = s.remove('%').toDouble();
            else
                xFocal = s.toDouble() * 100.0;
 
            s = element.attribute("fy", "50%");
            qreal yFocal;
            if (s.endsWith('%'))
                yFocal = s.remove('%').toDouble();
            else
                yFocal = s.toDouble() * 100.0;
 
            m_start = QPointF(xOrigin, yOrigin);
            m_stop = QPointF(xVector, yVector);
            m_focalPoint = QPointF(xFocal, yFocal);
        }
        else {
            m_start = QPointF(element.attribute("cx").toDouble(), element.attribute("cy").toDouble());
            m_stop = QPointF(element.attribute("cx").toDouble() + element.attribute("r").toDouble(),
                element.attribute("cy").toDouble());
            m_focalPoint = QPointF(element.attribute("fx").toDouble(), element.attribute("fy").toDouble());
        }
        setType(QGradient::RadialGradient);
    }
    // handle spread method
    QString spreadMethod = element.attribute("spreadMethod");
    if (!spreadMethod.isEmpty()) {
        if (spreadMethod == "reflect")
            setSpread(QGradient::ReflectSpread);
        else if (spreadMethod == "repeat")
            setSpread(QGradient::RepeatSpread);
    }
 
    for (QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement colorstop = n.toElement();
        if (colorstop.tagName() == "stop") {
            qreal opacity = 0.0;
            KoColor color;
            float off;
            QString temp = colorstop.attribute("offset");
            if (temp.contains('%')) {
                temp = temp.left(temp.length() - 1);
                off = temp.toFloat() / 100.0;
            }
            else
                off = temp.toFloat();
 
            if (!colorstop.attribute("stop-color").isEmpty())
                color = KoColor::fromSVG11(colorstop.attribute("stop-color"), profiles);
            else {
                // try style attr
                QString style = colorstop.attribute("style").simplified();
                QStringList substyles = style.split(';', Qt::SkipEmptyParts);
                Q_FOREACH(const QString & s, substyles) {
                    QStringList substyle = s.split(':');
                    QString command = substyle[0].trimmed();
                    QString params = substyle[1].trimmed();
                    if (command == "stop-color")
                        color = KoColor::fromSVG11(params, profiles);
                    if (command == "stop-opacity")
                        opacity = params.toDouble();
                }
 
            }
            if (!colorstop.attribute("stop-opacity").isEmpty())
                opacity = colorstop.attribute("stop-opacity").toDouble();
 
            color.setOpacity(static_cast<quint8>(std::lround(opacity * OPACITY_OPAQUE_U8)));
            QString stopTypeStr = colorstop.attribute("krita:stop-type", "color-stop");
            KoGradientStopType stopType = KoGradientStop::typeFromString(stopTypeStr);
            if (stopType != COLORSTOP) {
                m_hasVariableStops = true;
            }
            //According to the SVG spec each gradient offset has to be equal to or greater than the previous one
            //if not it needs to be adjusted to be equal
            if (m_stops.count() > 0 && m_stops.last().position >= off) {
                off = m_stops.last().position;
            }
            m_stops.append(KoGradientStop(off, color, stopType));
        }
    }
    if (m_stops.count() >= 2) {
        setValid(true);
    } else {
        setValid(false);
    }
}

References COLORSTOP, KoColor::fromSVG11(), m_focalPoint, m_hasVariableStops, m_start, m_stop, m_stops, OPACITY_OPAQUE_U8, KoResource::setName(), KoColor::setOpacity(), KoAbstractGradient::setSpread(), KoAbstractGradient::setType(), KoResource::setValid(), and KoGradientStop::typeFromString().

◆ requiredCanvasResources()

QList< int > KoStopGradient::requiredCanvasResources ( ) const

overridevirtual

A list of per-canvas active resources that are needed for this resource to function properly. E.g. some gradients may require Fg/Bg colors and some presets would like to know about the current gradient selection.

Returns: a list of canvas resources needed for the current resource

Reimplemented from KoResource.

Definition at line 255 of file KoStopGradient.cpp.

{
    QList<int> result;
 
    if (std::find_if_not(m_stops.begin(), m_stops.end(),
                         kismpl::mem_equal_to(&KoGradientStop::type, COLORSTOP))
        != m_stops.end()) {
 
        result << KoCanvasResource::ForegroundColor << KoCanvasResource::BackgroundColor;
    }
 
    return result;
}

References KoCanvasResource::BackgroundColor, COLORSTOP, KoCanvasResource::ForegroundColor, m_stops, kismpl::mem_equal_to(), and KoGradientStop::type.

◆ resourceType()

QPair< QString, QString > KoStopGradient::resourceType ( ) const

inlineoverridevirtual

Returns: the resource type

Implements KoResource.

Definition at line 104 of file KoStopGradient.h.

                                                          {
        return QPair<QString, QString>(ResourceType::Gradients, ResourceSubType::StopGradients);
    }

References ResourceType::Gradients, and ResourceSubType::StopGradients.

◆ saveSvgGradient()

QString KoStopGradient::saveSvgGradient ( ) const

Definition at line 581 of file KoStopGradient.cpp.

{
    QDomDocument doc;
 
    doc.setContent(QString("<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:krita=\"%1\" > </svg>").arg(KoXmlNS::krita));
 
    const QString spreadMethod[3] = {
        QString("pad"),
        QString("reflect"),
        QString("repeat")
    };
 
    QDomElement gradient = doc.createElement("linearGradient");
    gradient.setAttribute("id", name());
    gradient.setAttribute("gradientUnits", "objectBoundingBox");
    gradient.setAttribute("spreadMethod", spreadMethod[spread()]);
 
    QHash<QString, const KoColorProfile*> profiles;
    for(const KoGradientStop & stop: m_stops) {
        QDomElement stopEl = doc.createElement("stop");
        stopEl.setAttribute("stop-color", stop.color.toSVG11(&profiles));
        stopEl.setAttribute("offset", QString().setNum(stop.position));
        stopEl.setAttribute("stop-opacity", stop.color.opacityF());
        stopEl.setAttribute("krita:stop-type", stop.typeString());
        gradient.appendChild(stopEl);
    }
 
    if (profiles.size()>0) {
        QDomElement defs = doc.createElement("defs");
        for (QString key: profiles.keys()) {
            const KoColorProfile * profile = profiles.value(key);
 
            QDomElement profileEl = doc.createElement("color-profile");
            profileEl.setAttribute("name", key);
            QString val = profile->uniqueId().toHex();
            profileEl.setAttribute("local", val);
            profileEl.setAttribute("xlink:href", profile->fileName());
            defs.appendChild(profileEl);
        }
        doc.documentElement().appendChild(defs);
    }
 
    doc.documentElement().appendChild(gradient);
 
    return doc.toString();
}

References KoColorProfile::fileName, KoXmlNS::krita, m_stops, KoResource::name, KoAbstractGradient::spread, and KoColorProfile::uniqueId().

◆ saveToDevice()

bool KoStopGradient::saveToDevice ( QIODevice * dev ) const

overridevirtual

Reimplemented from KoResource.

Definition at line 628 of file KoStopGradient.cpp.

{
    QTextStream stream(dev);
    KisPortingUtils::setUtf8OnStream(stream);
    stream << saveSvgGradient();
 
    return true;
}

References saveSvgGradient(), and KisPortingUtils::setUtf8OnStream().

◆ setStops()

void KoStopGradient::setStops ( QList< KoGradientStop > stops )

Sets the gradient stops.

Definition at line 230 of file KoStopGradient.cpp.

{
    m_stops.clear();
    m_hasVariableStops = false;
    KoColor color;
    Q_FOREACH(const KoGradientStop & stop, stops) {
        color = stop.color;
        m_stops.append(KoGradientStop(stop.position, color, stop.type));
        if (stop.type != COLORSTOP) {
            m_hasVariableStops = true;
        }
    }
    if (m_stops.count() >= 2) {
        setValid(true);
    } else {
        setValid(false);
    }
    updatePreview();
}

References KoGradientStop::color, COLORSTOP, m_hasVariableStops, m_stops, KoGradientStop::position, KoResource::setValid(), stops(), KoGradientStop::type, and KoAbstractGradient::updatePreview().

◆ stops()

QList< KoGradientStop > KoStopGradient::stops ( ) const

Definition at line 250 of file KoStopGradient.cpp.

{
    return m_stops;
}

References m_stops.

◆ stopsAt()

bool KoStopGradient::stopsAt	(	KoGradientStop &	leftStop,
		KoGradientStop &	rightStop,
		qreal	t ) const

Find stops surrounding position, returns false if position outside gradient.

Definition at line 122 of file KoStopGradient.cpp.

{
    if (!m_stops.count())
        return false;
 
    KIS_SAFE_ASSERT_RECOVER(!qIsNaN(t)) { // if it's nan, it would crash in the last 'else'
        leftStop = m_stops.first();
        rightStop = KoGradientStop(-std::numeric_limits<double>::infinity(), leftStop.color, leftStop.type);
        return true;
    }
 
    if (t <= m_stops.first().position || m_stops.count() == 1) {
        // we have only one stop or t is before the first stop
        leftStop = m_stops.first();
        rightStop = KoGradientStop(-std::numeric_limits<double>::infinity(), leftStop.color, leftStop.type);
        return true;
    } else if (t >= m_stops.last().position) {
        // t is after the last stop
        rightStop = m_stops.last();
        leftStop = KoGradientStop(std::numeric_limits<double>::infinity(), rightStop.color, rightStop.type);
        return true;
    } else {
        // we have at least two color stops
        // -> find the two stops which frame our t
        auto it = std::lower_bound(m_stops.begin(), m_stops.end(), KoGradientStop(t, KoColor(), COLORSTOP),
                                   kismpl::mem_less(&KoGradientStop::position));
        leftStop = *(it - 1);
        rightStop = *(it);
        return true;
    }
}

References KoGradientStop::color, COLORSTOP, KIS_SAFE_ASSERT_RECOVER, m_stops, kismpl::mem_less(), KoGradientStop::position, and KoGradientStop::type.

◆ toQGradient()

QGradient * KoStopGradient::toQGradient ( ) const

overridevirtual

reimplemented

Reimplemented from KoAbstractGradient.

Definition at line 85 of file KoStopGradient.cpp.

{
    QGradient* gradient;
 
    switch (type()) {
    case QGradient::LinearGradient: {
        gradient = new QLinearGradient(m_start, m_stop);
        break;
    }
    case QGradient::RadialGradient: {
        QPointF diff = m_stop - m_start;
        qreal radius = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
        gradient = new QRadialGradient(m_start, radius, m_focalPoint);
        break;
    }
    case QGradient::ConicalGradient: {
        qreal angle = atan2(m_start.y(), m_start.x()) * 180.0 / M_PI;
        if (angle < 0.0)
            angle += 360.0;
        gradient = new QConicalGradient(m_start, angle);
        break;
    }
    default:
        return 0;
    }
    QColor color;
    for (QList<KoGradientStop>::const_iterator i = m_stops.begin(); i != m_stops.end(); ++i) {
        i->color.toQColor(&color);
        gradient->setColorAt(i->position, color);
    }
 
    gradient->setCoordinateMode(QGradient::ObjectBoundingMode);
    gradient->setSpread(this->spread());
 
    return gradient;
}

References m_focalPoint, M_PI, m_start, m_stop, m_stops, KoAbstractGradient::spread, and KoAbstractGradient::type.

◆ toXML()

void KoStopGradient::toXML	(	QDomDocument &	doc,
		QDomElement &	gradientElt ) const

toXML Convert the gradient to an XML string.

Definition at line 548 of file KoStopGradient.cpp.

{
    gradientElt.setAttribute("type", "stop");
    for (int s = 0; s < m_stops.size(); s++) {
        KoGradientStop stop = m_stops.at(s);
        QDomElement stopElt = doc.createElement("stop");
        stopElt.setAttribute("offset", KisDomUtils::toString(stop.position));
        stopElt.setAttribute("bitdepth", stop.color.colorSpace()->colorDepthId().id());
        stopElt.setAttribute("alpha", KisDomUtils::toString(stop.color.opacityF()));
        stopElt.setAttribute("stoptype", KisDomUtils::toString(stop.type));
        stop.color.toXML(doc, stopElt);
        gradientElt.appendChild(stopElt);
    }
}

References KoGradientStop::color, KoColorSpace::colorDepthId(), KoColor::colorSpace(), KoID::id(), m_stops, KoColor::opacityF(), KoGradientStop::position, KisDomUtils::toString(), KoColor::toXML(), and KoGradientStop::type.

◆ updateVariableColors()

void KoStopGradient::updateVariableColors ( KoCanvasResourcesInterfaceSP canvasResourcesInterface )

overridevirtual

Reimplemented from KoAbstractGradient.

Definition at line 285 of file KoStopGradient.cpp.

{
    const KoColor fgColor = canvasResourcesInterface->resource(KoCanvasResource::ForegroundColor).value<KoColor>();
    const KoColor bgColor = canvasResourcesInterface->resource(KoCanvasResource::BackgroundColor).value<KoColor>();
 
    for (auto it = m_stops.begin(); it != m_stops.end(); ++it) {
        if (it->type == FOREGROUNDSTOP) {
            it->color = fgColor;
        } else if (it->type == BACKGROUNDSTOP) {
            it->color = bgColor;
        }
    }
}

References KoCanvasResource::BackgroundColor, BACKGROUNDSTOP, KoCanvasResource::ForegroundColor, FOREGROUNDSTOP, and m_stops.

Member Data Documentation

◆ m_focalPoint

QPointF KoStopGradient::m_focalPoint

protected

Definition at line 152 of file KoStopGradient.h.

◆ m_hasVariableStops

bool KoStopGradient::m_hasVariableStops = false

protected

Definition at line 149 of file KoStopGradient.h.

◆ m_start

QPointF KoStopGradient::m_start

protected

Definition at line 150 of file KoStopGradient.h.

◆ m_stop

QPointF KoStopGradient::m_stop

protected

Definition at line 151 of file KoStopGradient.h.

◆ m_stops

QList<KoGradientStop> KoStopGradient::m_stops

protected

Definition at line 148 of file KoStopGradient.h.

The documentation for this class was generated from the following files:

libs/pigment/resources/KoStopGradient.h
libs/pigment/resources/KoStopGradient.cpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KoStopGradient() [1/2]

◆ ~KoStopGradient()

◆ KoStopGradient() [2/2]

Member Function Documentation

◆ bakeVariableColors()

◆ clone()

◆ colorAt()

◆ defaultFileExtension()

◆ fromQGradient()

◆ fromXML()

◆ loadFromDevice()

◆ loadSvgGradient()

◆ operator=()

◆ operator==()

◆ parseSvgGradient()

◆ requiredCanvasResources()

◆ resourceType()

◆ saveSvgGradient()

◆ saveToDevice()

◆ setStops()

◆ stops()

◆ stopsAt()

◆ toQGradient()

◆ toXML()

◆ updateVariableColors()

Member Data Documentation

◆ m_focalPoint

◆ m_hasVariableStops

◆ m_start

◆ m_stop

◆ m_stops