KoSegmentGradient Class Reference

#include <KoSegmentGradient.h>

Inheritance diagram for KoSegmentGradient:

Public Member Functions
void	bakeVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) override
KoResourceSP	clone () const override
KoGradientSegment *	collapseSegment (KoGradientSegment *segment)
void	colorAt (KoColor &dst, qreal t) const override
	reimplemented
void	createSegment (int interpolation, int colorInterpolation, double startOffset, double endOffset, double middleOffset, const KoColor &leftColor, const KoColor &rightColor, KoGradientSegmentEndpointType leftType=COLOR_ENDPOINT, KoGradientSegmentEndpointType rightType=COLOR_ENDPOINT)
void	createSegment (int interpolation, int colorInterpolation, double startOffset, double endOffset, double middleOffset, const QColor &leftColor, const QColor &rightColor, KoGradientSegmentEndpointType leftType=COLOR_ENDPOINT, KoGradientSegmentEndpointType rightType=COLOR_ENDPOINT)
QString	defaultFileExtension () const override
	reimplemented
void	duplicateSegment (KoGradientSegment *segment)
const QList< double >	getHandlePositions () const
const QList< double >	getMiddleHandlePositions () const
	KoSegmentGradient (const KoSegmentGradient &rhs)
	KoSegmentGradient (const QString &file=QString())
bool	loadFromDevice (QIODevice *dev, KisResourcesInterfaceSP resourcesInterface) override
void	mirrorSegment (KoGradientSegment *segment)
void	moveSegmentEndOffset (KoGradientSegment *segment, double t)
void	moveSegmentMiddleOffset (KoGradientSegment *segment, double t)
void	moveSegmentStartOffset (KoGradientSegment *segment, double t)
KoSegmentGradient &	operator= (const KoSegmentGradient &rhs)=delete
KoGradientSegment *	removeSegment (KoGradientSegment *segment)
bool	removeSegmentPossible () const
QList< int >	requiredCanvasResources () const override
QPair< QString, QString >	resourceType () const override
bool	saveToDevice (QIODevice *dev) const override
KoGradientSegment *	segmentAt (qreal t) const
const QList< KoGradientSegment * > &	segments () const
void	setSegments (const QList< KoGradientSegment * > &segments)
void	splitSegment (KoGradientSegment *segment)
QGradient *	toQGradient () const override
	reimplemented
void	toXML (QDomDocument &doc, QDomElement &gradientElt) const
	toXML convert the gradient to xml.
void	updateVariableColors (KoCanvasResourcesInterfaceSP canvasResourcesInterface) override
	~KoSegmentGradient () 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 KoSegmentGradient	fromXML (const QDomElement &elt)
	fromXML get a segment gradient from xml.

Protected Member Functions
void	pushSegment (KoGradientSegment *segment)

Protected Attributes
QList< KoGradientSegment * >	m_segments

Private Member Functions
bool	init ()

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

KoSegmentGradient stores a segment based gradients like Gimp gradients

Definition at line 288 of file KoSegmentGradient.h.

Constructor & Destructor Documentation

KoSegmentGradient() [1/2]

KoSegmentGradient::KoSegmentGradient ( const QString & file = QString() )

explicit

Definition at line 49 of file KoSegmentGradient.cpp.

    : KoAbstractGradient(filename)
{
}

~KoSegmentGradient()

KoSegmentGradient::~KoSegmentGradient ( )

override

Definition at line 54 of file KoSegmentGradient.cpp.

{
    for (int i = 0; i < m_segments.count(); i++) {
        delete m_segments[i];
        m_segments[i] = 0;
    }
}

References m_segments.

KoSegmentGradient() [2/2]

KoSegmentGradient::KoSegmentGradient

(

const KoSegmentGradient &

rhs

)

Definition at line 62 of file KoSegmentGradient.cpp.

    : KoAbstractGradient(rhs)
{
    Q_FOREACH (KoGradientSegment *segment, rhs.m_segments) {
        pushSegment(new KoGradientSegment(*segment));
    }
}

References m_segments, and pushSegment().

Member Function Documentation

bakeVariableColors()

void KoSegmentGradient::bakeVariableColors ( KoCanvasResourcesInterfaceSP canvasResourcesInterface )

overridevirtual

Reimplemented from KoAbstractGradient.

Definition at line 1138 of file KoSegmentGradient.cpp.

{
    const KoColor fgColor = canvasResourcesInterface->resource(KoCanvasResource::ForegroundColor).value<KoColor>().convertedTo(colorSpace());
    const KoColor bgColor = canvasResourcesInterface->resource(KoCanvasResource::BackgroundColor).value<KoColor>().convertedTo(colorSpace());
 
    for (auto it = m_segments.begin(); it != m_segments.end(); ++it) {
        if ((*it)->hasVariableColors()) {
            (*it)->setVariableColors(fgColor, bgColor);
            (*it)->setStartType(COLOR_ENDPOINT);
            (*it)->setEndType(COLOR_ENDPOINT);
        }
    }
}

References KoCanvasResource::BackgroundColor, COLOR_ENDPOINT, and KoCanvasResource::ForegroundColor.

clone()

KoResourceSP KoSegmentGradient::clone ( ) const

overridevirtual

Implements KoResource.

Definition at line 70 of file KoSegmentGradient.cpp.

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

References KoSegmentGradient().

collapseSegment()

KoGradientSegment * KoSegmentGradient::collapseSegment

(

KoGradientSegment *

segment

)

removes the specific segment from the gradient color picker and modifies the previous and next segments so that they end and start where the middle of the passed segment was respectively.

Parameters

segment

the segment to remove

Returns

the segment which will be at the place of the old segment: the previous segment if the passed segment was not the first; the next segment if the passed segment was the first; 0 if the passed segment is not in the gradient or it is not possible to remove the segment.

Definition at line 1033 of file KoSegmentGradient.cpp.

{
    Q_ASSERT(segment != 0);
    if (m_segments.count() < 2)
        return 0;
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        double nextMiddlePositionPercentage, prevMiddlePositionPercentage;
        KoGradientSegment *nextSegment, *prevSegment, *returnSegment;
        if (it == m_segments.begin()) {
            nextSegment = (*(it + 1));
            nextMiddlePositionPercentage = (nextSegment->middleOffset() - nextSegment->startOffset()) / nextSegment->length();
            nextSegment->setStartOffset(segment->startOffset());
            nextSegment->setMiddleOffset(nextMiddlePositionPercentage * nextSegment->length() + nextSegment->startOffset());
            returnSegment = nextSegment;
        } else if (it == m_segments.end() - 1) {
            prevSegment = (*(it - 1));
            prevMiddlePositionPercentage = (prevSegment->middleOffset() - prevSegment->startOffset()) / prevSegment->length();
            prevSegment->setEndOffset(segment->endOffset());
            prevSegment->setMiddleOffset(prevMiddlePositionPercentage * prevSegment->length() + prevSegment->startOffset());
            returnSegment = prevSegment;
        } else {
            prevSegment = (*(it - 1));
            nextSegment = (*(it + 1));
            prevMiddlePositionPercentage = (prevSegment->middleOffset() - prevSegment->startOffset()) / prevSegment->length();
            nextMiddlePositionPercentage = (nextSegment->middleOffset() - nextSegment->startOffset()) / nextSegment->length();
            qreal offset = (segment->startOffset() + segment->endOffset()) / 2.0;
            prevSegment->setEndOffset(offset);
            prevSegment->setMiddleOffset(prevMiddlePositionPercentage * prevSegment->length() + prevSegment->startOffset());
            nextSegment->setStartOffset(offset);
            nextSegment->setMiddleOffset(nextMiddlePositionPercentage * nextSegment->length() + nextSegment->startOffset());
            returnSegment = prevSegment;
        }
 
        delete segment;
        m_segments.erase(it);
        return returnSegment;
    }
    return 0;
}

References KoGradientSegment::endOffset(), KoGradientSegment::length(), KoGradientSegment::middleOffset(), KoGradientSegment::setEndOffset(), KoGradientSegment::setMiddleOffset(), KoGradientSegment::setStartOffset(), and KoGradientSegment::startOffset().

colorAt()

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

overridevirtual

reimplemented

Reimplemented from KoAbstractGradient.

Definition at line 232 of file KoSegmentGradient.cpp.

{
    const KoGradientSegment *segment = segmentAt(t);
    if (segment) {
        segment->colorAt(dst, t);
    }
}

References KoGradientSegment::colorAt(), and segmentAt().

createSegment() [1/2]

void KoSegmentGradient::createSegment	(	int	interpolation,
		int	colorInterpolation,
		double	startOffset,
		double	endOffset,
		double	middleOffset,
		const KoColor &	leftColor,
		const KoColor &	rightColor,
		KoGradientSegmentEndpointType	leftType = COLOR_ENDPOINT,
		KoGradientSegmentEndpointType	rightType = COLOR_ENDPOINT )

Definition at line 877 of file KoSegmentGradient.cpp.

{
    KoGradientSegmentEndpoint left(startOffset, KoColor(leftColor, colorSpace()), leftType);
    KoGradientSegmentEndpoint right(endOffset, KoColor(rightColor, colorSpace()), rightType);
    pushSegment(new KoGradientSegment(interpolation, colorInterpolation, left, right, middleOffset));
}

References KoGradientSegment::colorInterpolation(), KoGradientSegment::endOffset(), KoGradientSegment::interpolation(), KoGradientSegment::KoGradientSegment(), KoGradientSegment::middleOffset(), and KoGradientSegment::startOffset().

createSegment() [2/2]

void KoSegmentGradient::createSegment	(	int	interpolation,
		int	colorInterpolation,
		double	startOffset,
		double	endOffset,
		double	middleOffset,
		const QColor &	leftColor,
		const QColor &	rightColor,
		KoGradientSegmentEndpointType	leftType = COLOR_ENDPOINT,
		KoGradientSegmentEndpointType	rightType = COLOR_ENDPOINT )

a gradient color picker can consist of one or more segments. A segment has two end points - each color in the gradient color picker represents a segment end point.

Parameters

interpolation
colorInterpolation
startOffset
endOffset
middleOffset
left
right
leftType
rightType

Returns

void

Definition at line 862 of file KoSegmentGradient.cpp.

{
    createSegment(interpolation
                  , colorInterpolation
                  , startOffset
                  , endOffset
                  , middleOffset
                  , KoColor(leftColor, colorSpace())
                  , KoColor(rightColor, colorSpace())
                  , leftType
                  , rightType);
 
}

References KoGradientSegment::colorInterpolation(), KoGradientSegment::endOffset(), KoGradientSegment::interpolation(), KoGradientSegment::middleOffset(), and KoGradientSegment::startOffset().

defaultFileExtension()

QString KoSegmentGradient::defaultFileExtension ( ) const

overridevirtual

reimplemented

Reimplemented from KoResource.

Definition at line 254 of file KoSegmentGradient.cpp.

{
    return QString(".ggr");
}

duplicateSegment()

void KoSegmentGradient::duplicateSegment

(

KoGradientSegment *

segment

)

duplicate the specified segment

Parameters

segment

the segment to duplicate

Returns

void

Definition at line 979 of file KoSegmentGradient.cpp.

{
    Q_ASSERT(segment != 0);
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        double middlePositionPercentage = (segment->middleOffset() - segment->startOffset()) / segment->length();
        double center = segment->startOffset() + segment->length() / 2;
        KoGradientSegmentEndpoint left(segment->startOffset(), segment->startColor(), segment->startType());
        KoGradientSegmentEndpoint right(center, segment->endColor(), segment->endType());
        KoGradientSegment* newSegment = new KoGradientSegment(
                    segment->interpolation(), segment->colorInterpolation(),
                    left, right,
                    segment->length() / 2 * middlePositionPercentage + segment->startOffset());
        m_segments.insert(it, newSegment);
        segment->setStartOffset(center);
        segment->setMiddleOffset(segment->length() * middlePositionPercentage  + segment->startOffset());
    }
}

References KoGradientSegment::colorInterpolation(), KoGradientSegment::endColor(), KoGradientSegment::endType(), KoGradientSegment::interpolation(), KoGradientSegment::KoGradientSegment(), KoGradientSegment::length(), KoGradientSegment::middleOffset(), KoGradientSegment::setMiddleOffset(), KoGradientSegment::setStartOffset(), KoGradientSegment::startColor(), KoGradientSegment::startOffset(), and KoGradientSegment::startType().

fromXML()

KoSegmentGradient KoSegmentGradient::fromXML ( const QDomElement & elt )

static

fromXML get a segment gradient from xml.

Returns

gradient

Definition at line 287 of file KoSegmentGradient.cpp.

{
    KoSegmentGradient gradient;
    QDomElement segmentElt = elt.firstChildElement("segment");
    while (!segmentElt.isNull()) {
        int interpolation = KisDomUtils::toInt(segmentElt.attribute("interpolation", "0.0"));
        int colorInterpolation = KisDomUtils::toInt(segmentElt.attribute("color-interpolation", "0.0"));
        double startOffset = KisDomUtils::toDouble(segmentElt.attribute("start-offset", "0.0"));
        qreal middleOffset = KisDomUtils::toDouble(segmentElt.attribute("middle-offset", "0.0"));
        qreal endOffset = KisDomUtils::toDouble(segmentElt.attribute("end-offset", "0.0"));
        QDomElement start = segmentElt.firstChildElement("start");
        QString startBitdepth = segmentElt.attribute("start-bitdepth", Integer8BitsColorDepthID.id());
        QColor left = KoColor::fromXML(start.firstChildElement(), startBitdepth).toQColor();
        left.setAlphaF(KisDomUtils::toDouble(segmentElt.attribute("start-alpha", "1.0")));
        QString endBitdepth = segmentElt.attribute("end-bitdepth", Integer8BitsColorDepthID.id());
        QDomElement end = segmentElt.firstChildElement("end");
        QColor right = KoColor::fromXML(end.firstChildElement(), endBitdepth).toQColor();
        right.setAlphaF(KisDomUtils::toDouble(segmentElt.attribute("end-alpha", "1.0")));
        KoGradientSegmentEndpointType leftType = static_cast<KoGradientSegmentEndpointType>(KisDomUtils::toInt(segmentElt.attribute("start-type", "0")));
        KoGradientSegmentEndpointType rightType = static_cast<KoGradientSegmentEndpointType>(KisDomUtils::toInt(segmentElt.attribute("end-type", "0")));
        gradient.createSegment(interpolation, colorInterpolation, startOffset, endOffset, middleOffset, left, right, leftType, rightType);
        segmentElt = segmentElt.nextSiblingElement("segment");
    }
    if (!gradient.segments().isEmpty()) {
        gradient.setValid(true);
    }
    return gradient;
}

References createSegment(), KoColor::fromXML(), KoID::id(), Integer8BitsColorDepthID, segments(), KoResource::setValid(), KisDomUtils::toDouble(), KisDomUtils::toInt(), and KoColor::toQColor().

getHandlePositions()

const QList< double > KoSegmentGradient::getHandlePositions

(

)

const

gets a list of end points of the segments in the gradient color picker. If two colors, one segment then two end points, and if three colors, then two segments with four endpoints.

Returns

a list of double values

Definition at line 884 of file KoSegmentGradient.cpp.

{
    QList<double> handlePositions;
 
    handlePositions.push_back(m_segments[0]->startOffset());
    for (int i = 0; i < m_segments.count(); i++) {
        handlePositions.push_back(m_segments[i]->endOffset());
    }
    return handlePositions;
}

References KoGradientSegment::endOffset(), and KoGradientSegment::startOffset().

getMiddleHandlePositions()

const QList< double > KoSegmentGradient::getMiddleHandlePositions

(

)

const

gets a list of middle points of the segments in the gradient color picker.

Returns

a list of double values

Definition at line 895 of file KoSegmentGradient.cpp.

{
    QList<double> middleHandlePositions;
 
    for (int i = 0; i < m_segments.count(); i++) {
        middleHandlePositions.push_back(m_segments[i]->middleOffset());
    }
    return middleHandlePositions;
}

References KoGradientSegment::middleOffset().

init()

bool KoSegmentGradient::init ( )

private

loadFromDevice()

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

overridevirtual

Implements KoResource.

Definition at line 75 of file KoSegmentGradient.cpp.

{
    Q_UNUSED(resourcesInterface);
 
    QByteArray data = dev->readAll();
 
    QTextStream fileContent(data, QIODevice::ReadOnly);
    KisPortingUtils::setUtf8OnStream(fileContent);
    fileContent.setAutoDetectUnicode(true);
 
    QString header = fileContent.readLine();
 
    if (header != "GIMP Gradient") {
        return false;
    }
 
    QString nameDefinition = fileContent.readLine();
    QString numSegmentsText;
 
    if (nameDefinition.startsWith("Name: ")) {
        QString nameText = nameDefinition.right(nameDefinition.length() - 6);
        setName(nameText);
 
        numSegmentsText = fileContent.readLine();
    } else {
        // Older format without name.
 
        numSegmentsText = nameDefinition;
    }
 
    dbgPigment << "Loading gradient: " << name();
 
    int numSegments;
    bool ok;
 
    numSegments = numSegmentsText.toInt(&ok);
 
    if (!ok || numSegments < 1) {
        return false;
    }
    m_segments.clear();
 
    dbgPigment << "Number of segments = " << numSegments;
 
    const KoColorSpace *rgbColorSpace = KoColorSpaceRegistry::instance()->rgb16(KoColorSpaceRegistry::instance()->p709SRGBProfile());
 
    for (int i = 0; i < numSegments; i++) {
 
        QString segmentText = fileContent.readLine();
        QStringList values = segmentText.split(' ');
 
        qreal leftOffset = values[0].toDouble();
        qreal middleOffset = values[1].toDouble();
        qreal rightOffset = values[2].toDouble();
 
        qreal leftRed = values[3].toDouble();
        qreal leftGreen = values[4].toDouble();
        qreal leftBlue = values[5].toDouble();
        qreal leftAlpha = values[6].toDouble();
 
        qreal rightRed = values[7].toDouble();
        qreal rightGreen = values[8].toDouble();
        qreal rightBlue = values[9].toDouble();
        qreal rightAlpha = values[10].toDouble();
 
        int interpolationType = values[11].toInt();
        int colorInterpolationType = values[12].toInt();
 
        KoGradientSegmentEndpointType startType, endType;
        if (values.count() >= 15) { //file supports FG/BG colors
            startType = static_cast<KoGradientSegmentEndpointType>(values[13].toInt());
            endType = static_cast<KoGradientSegmentEndpointType>(values[14].toInt());
        }
        else {
            startType = endType = COLOR_ENDPOINT;
        }
        std::array<quint16, 4> data;
        data[2] = static_cast<quint16>(leftRed * quint16_MAX + 0.5);
        data[1] = static_cast<quint16>(leftGreen * quint16_MAX + 0.5);
        data[0] = static_cast<quint16>(leftBlue * quint16_MAX + 0.5);
        data[3] = static_cast<quint16>(leftAlpha * quint16_MAX + 0.5);
 
        KoColor leftColor(reinterpret_cast<quint8 *>(data.data()), rgbColorSpace);
 
        data[2] = static_cast<quint16>(rightRed * quint16_MAX + 0.5);
        data[1] = static_cast<quint16>(rightGreen * quint16_MAX + 0.5);
        data[0] = static_cast<quint16>(rightBlue * quint16_MAX + 0.5);
        data[3] = static_cast<quint16>(rightAlpha * quint16_MAX + 0.5);
 
        KoColor rightColor(reinterpret_cast<quint8 *>(data.data()), rgbColorSpace);
        KoGradientSegmentEndpoint left(leftOffset, leftColor, startType);
        KoGradientSegmentEndpoint right(rightOffset, rightColor, endType);
 
        KoGradientSegment *segment = new KoGradientSegment(interpolationType, colorInterpolationType, left, right, middleOffset);
        Q_CHECK_PTR(segment);
 
        if (!segment -> isValid()) {
            delete segment;
            return false;
        }
 
        m_segments.push_back(segment);
    }
 
    if (!m_segments.isEmpty()) {
        updatePreview();
        setValid(true);
        return true;
    } else {
        return false;
    }
 
}

References COLOR_ENDPOINT, dbgPigment, KoColorSpaceRegistry::instance(), m_segments, KoResource::name, quint16_MAX, KoColorSpaceRegistry::rgb16(), KoResource::setName(), KisPortingUtils::setUtf8OnStream(), KoResource::setValid(), and KoAbstractGradient::updatePreview().

mirrorSegment()

void KoSegmentGradient::mirrorSegment

(

KoGradientSegment *

segment

)

create a segment horizontally reversed to the specified one.

Parameters

segment

the segment to reverse

Returns

void

Definition at line 998 of file KoSegmentGradient.cpp.

{
    Q_ASSERT(segment != 0);
 
    segment->mirrorSegment();
}

References KoGradientSegment::mirrorSegment().

moveSegmentEndOffset()

void KoSegmentGradient::moveSegmentEndOffset	(	KoGradientSegment *	segment,
		double	t )

Moves the endoffset of the specified segment to the specified value and corrects the startoffset of the following segment. If the segment is the last segment the endoffset will be set to 1.0 . The offset will maximally be moved till the middle of the current or the following segment. This is useful if someone moves the segment handler in the gradient color picker, and needs the segment to move with it. Sets the end position of the segment to the correct new position.

Parameters

segment	the segment for which to move the relative end position within the gradient color picker.
t	the new end position for the segment

Returns

void

Definition at line 926 of file KoSegmentGradient.cpp.

{
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        if (it + 1 == m_segments.end()) {
            segment->setEndOffset(1.0);
            return;
        }
        KoGradientSegment* followingSegment = (*(it + 1));
        if (t < segment->endOffset()) {
            if (t < segment->middleOffset())
                t = segment->middleOffset();
        } else {
            if (t > followingSegment->middleOffset())
                t = followingSegment->middleOffset();
        }
        followingSegment->setStartOffset(t);
        segment->setEndOffset(t);
    }
}

References KoGradientSegment::endOffset(), KoGradientSegment::middleOffset(), KoGradientSegment::setEndOffset(), and KoGradientSegment::setStartOffset().

moveSegmentMiddleOffset()

void KoSegmentGradient::moveSegmentMiddleOffset	(	KoGradientSegment *	segment,
		double	t )

moves the Middle of the specified segment to the specified value. The offset will maximally be moved till the endoffset or startoffset of the segment. This sets the middle of the segment to the same position as the handler of the gradient color picker.

Parameters

segment	the segment for which to move the relative middle position within the gradient color picker.
t	the new middle position for the segment

Returns

void

Definition at line 947 of file KoSegmentGradient.cpp.

{
    if (segment) {
        if (t > segment->endOffset())
            segment->setMiddleOffset(segment->endOffset());
        else if (t < segment->startOffset())
            segment->setMiddleOffset(segment->startOffset());
        else
            segment->setMiddleOffset(t);
    }
}

References KoGradientSegment::endOffset(), KoGradientSegment::setMiddleOffset(), and KoGradientSegment::startOffset().

moveSegmentStartOffset()

void KoSegmentGradient::moveSegmentStartOffset	(	KoGradientSegment *	segment,
		double	t )

Moves the StartOffset of the specified segment to the specified value and corrects the endoffset of the previous segment. If the segment is the first Segment the startoffset will be set to 0.0 . The offset will maximally be moved till the middle of the current or the previous segment. This is useful if someone clicks to move the handler for a segment, to set the half the segment to the right and half the segment to the left of the handler.

Parameters

segment	the segment for which to move the relative offset within the gradient color picker.
t	the new startoff position for the segment

Returns

void

Definition at line 905 of file KoSegmentGradient.cpp.

{
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        if (it == m_segments.begin()) {
            segment->setStartOffset(0.0);
            return;
        }
        KoGradientSegment* previousSegment = (*(it - 1));
        if (t > segment->startOffset()) {
            if (t > segment->middleOffset())
                t = segment->middleOffset();
        } else {
            if (t < previousSegment->middleOffset())
                t = previousSegment->middleOffset();
        }
        previousSegment->setEndOffset(t);
        segment->setStartOffset(t);
    }
}

References KoGradientSegment::middleOffset(), KoGradientSegment::setEndOffset(), KoGradientSegment::setStartOffset(), and KoGradientSegment::startOffset().

operator=()

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

delete

pushSegment()

void KoSegmentGradient::pushSegment ( KoGradientSegment * segment )

inlineprotected

Definition at line 475 of file KoSegmentGradient.h.

                                                        {
        m_segments.push_back(segment);
    }

removeSegment()

KoGradientSegment * KoSegmentGradient::removeSegment

(

KoGradientSegment *

segment

)

removes the specific segment from the gradient color picker.

Parameters

segment

the segment to remove

Returns

the segment which will be at the place of the old segment. 0 if the segment is not in the gradient or it is not possible to remove the segment.

Definition at line 1005 of file KoSegmentGradient.cpp.

{
    Q_ASSERT(segment != 0);
    if (m_segments.count() < 2)
        return 0;
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        double middlePositionPercentage;
        KoGradientSegment* nextSegment;
        if (it == m_segments.begin()) {
            nextSegment = (*(it + 1));
            middlePositionPercentage = (nextSegment->middleOffset() - nextSegment->startOffset()) / nextSegment->length();
            nextSegment->setStartOffset(segment->startOffset());
            nextSegment->setMiddleOffset(middlePositionPercentage * nextSegment->length() + nextSegment->startOffset());
        } else {
            nextSegment = (*(it - 1));
            middlePositionPercentage = (nextSegment->middleOffset() - nextSegment->startOffset()) / nextSegment->length();
            nextSegment->setEndOffset(segment->endOffset());
            nextSegment->setMiddleOffset(middlePositionPercentage * nextSegment->length() + nextSegment->startOffset());
        }
 
        delete segment;
        m_segments.erase(it);
        return nextSegment;
    }
    return 0;
}

References KoGradientSegment::endOffset(), KoGradientSegment::length(), KoGradientSegment::middleOffset(), KoGradientSegment::setEndOffset(), KoGradientSegment::setMiddleOffset(), KoGradientSegment::setStartOffset(), and KoGradientSegment::startOffset().

removeSegmentPossible()

bool KoSegmentGradient::removeSegmentPossible

(

)

const

checks if it's possible to remove a segment (at least two segments in the gradient)

Returns

true if it's possible to remove an segment

Definition at line 1074 of file KoSegmentGradient.cpp.

{
    if (m_segments.count() < 2)
        return false;
    return true;
}

requiredCanvasResources()

QList< int > KoSegmentGradient::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 1120 of file KoSegmentGradient.cpp.

{
    bool hasVariableColors = false;
    for (int i = 0; i < m_segments.count(); i++) {
        if (m_segments[i]->hasVariableColors()) {
            hasVariableColors = true;
            break;
        }
    }
 
    QList<int> result;
    if (hasVariableColors) {
        result << KoCanvasResource::ForegroundColor << KoCanvasResource::BackgroundColor;
    }
 
    return result;
}

References KoCanvasResource::BackgroundColor, KoCanvasResource::ForegroundColor, and KoGradientSegment::hasVariableColors().

resourceType()

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

inlineoverridevirtual

Returns

the resource type

Implements KoResource.

Definition at line 301 of file KoSegmentGradient.h.

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

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

saveToDevice()

bool KoSegmentGradient::saveToDevice ( QIODevice * dev ) const

overridevirtual

Reimplemented from KoResource.

Definition at line 189 of file KoSegmentGradient.cpp.

{
    QTextStream fileContent(dev);
    KisPortingUtils::setUtf8OnStream(fileContent);
    fileContent << "GIMP Gradient\n";
    fileContent << "Name: " << name() << "\n";
    fileContent << m_segments.count() << "\n";
 
    Q_FOREACH (KoGradientSegment* segment, m_segments) {
        fileContent << QString::number(segment->startOffset(), 'f') << " " << QString::number(segment->middleOffset(), 'f') << " "
                    << QString::number(segment->endOffset(), 'f') << " ";
 
        QColor startColor = segment->startColor().toQColor();
        QColor endColor = segment->endColor().toQColor();
        fileContent << QString::number(startColor.redF(), 'f') << " " << QString::number(startColor.greenF(), 'f') << " "
                    << QString::number(startColor.blueF(), 'f') << " " << QString::number(startColor.alphaF(), 'f') << " ";
        fileContent << QString::number(endColor.redF(), 'f') << " " << QString::number(endColor.greenF(), 'f') << " "
                    << QString::number(endColor.blueF(), 'f') << " " << QString::number(endColor.alphaF(), 'f') << " ";
 
        fileContent << (int)segment->interpolation() << " " << (int)segment->colorInterpolation() << " ";
 
        fileContent << (int)segment->startType() << " " << (int)segment->endType() << "\n";
 
    }
 
    return true;
}

References KoGradientSegment::colorInterpolation(), KoGradientSegment::endColor(), KoGradientSegment::endOffset(), KoGradientSegment::endType(), KoGradientSegment::interpolation(), m_segments, KoGradientSegment::middleOffset(), KoResource::name, KisPortingUtils::setUtf8OnStream(), KoGradientSegment::startColor(), KoGradientSegment::startOffset(), KoGradientSegment::startType(), and KoColor::toQColor().

segmentAt()

KoGradientSegment * KoSegmentGradient::segmentAt

(

qreal

t

)

const

Returns the segment at a given position

Parameters

t	position inside the gradient, with 0 <= t <= 1

Returns

the segment the position, 0 if no segment is found

Definition at line 217 of file KoSegmentGradient.cpp.

{
    if (t < 0.0) return 0;
    if (t > 1.0) return 0;
    if (m_segments.isEmpty()) return 0;
 
    for (QList<KoGradientSegment *>::const_iterator it = m_segments.begin(); it != m_segments.end(); ++it) {
        if (t > (*it)->startOffset() - DBL_EPSILON && t < (*it)->endOffset() + DBL_EPSILON) {
            return *it;
        }
    }
 
    return 0;
}

References m_segments.

segments()

const QList< KoGradientSegment * > & KoSegmentGradient::segments

(

)

const

Definition at line 1081 of file KoSegmentGradient.cpp.

{
    return m_segments;
}

setSegments()

void KoSegmentGradient::setSegments

(

const QList< KoGradientSegment * > &

segments

)

Definition at line 1086 of file KoSegmentGradient.cpp.

{
    for (int i = 0; i < m_segments.count(); i++) {
        delete m_segments[i];
    }
    m_segments.clear();
    KoColor color;
    for (const KoGradientSegment *segment : segments) {
        KoGradientSegment *newSegment =
            new KoGradientSegment(
                segment->interpolation(),
                segment->colorInterpolation(),
                KoGradientSegmentEndpoint(
                    segment->startOffset(),
                    segment->startColor().convertedTo(colorSpace()),
                    segment->startType()
                ),
                KoGradientSegmentEndpoint(
                    segment->endOffset(),
                    segment->endColor().convertedTo(colorSpace()),
                    segment->endType()
                ),
                segment->middleOffset()
            );
        m_segments.append(newSegment);
    }
    if (!m_segments.isEmpty()) {
        setValid(true);
    } else {
        setValid(false);
    }
    updatePreview();
}

References KoGradientSegment::KoGradientSegment().

splitSegment()

void KoSegmentGradient::splitSegment

(

KoGradientSegment *

segment

)

splits the specified segment into two equal parts

Parameters

segment

the segment to split

Returns

void

Definition at line 959 of file KoSegmentGradient.cpp.

{
    Q_ASSERT(segment != 0);
    QList<KoGradientSegment*>::iterator it = std::find(m_segments.begin(), m_segments.end(), segment);
    if (it != m_segments.end()) {
        KoColor midleoffsetColor(segment->endColor().colorSpace());
        segment->colorAt(midleoffsetColor, segment->middleOffset());
        KoGradientSegmentEndpoint left(segment->startOffset(), segment->startColor(), segment->startType());
        KoGradientSegmentEndpoint right(segment->middleOffset(), midleoffsetColor, COLOR_ENDPOINT);
        KoGradientSegment* newSegment = new KoGradientSegment(
                    segment->interpolation(), segment->colorInterpolation(),
                    left, right,
                    (segment->middleOffset() - segment->startOffset()) / 2 + segment->startOffset());
        m_segments.insert(it, newSegment);
        segment->setStartColor(midleoffsetColor);
        segment->setStartOffset(segment->middleOffset());
        segment->setMiddleOffset((segment->endOffset() - segment->startOffset()) / 2 + segment->startOffset());
    }
}

References COLOR_ENDPOINT, KoGradientSegment::colorAt(), KoGradientSegment::colorInterpolation(), KoColor::colorSpace(), KoGradientSegment::endColor(), KoGradientSegment::endOffset(), KoGradientSegment::interpolation(), KoGradientSegment::KoGradientSegment(), KoGradientSegment::middleOffset(), KoGradientSegment::setMiddleOffset(), KoGradientSegment::setStartColor(), KoGradientSegment::setStartOffset(), KoGradientSegment::startColor(), KoGradientSegment::startOffset(), and KoGradientSegment::startType().

toQGradient()

QGradient * KoSegmentGradient::toQGradient ( ) const

overridevirtual

reimplemented

Reimplemented from KoAbstractGradient.

Definition at line 240 of file KoSegmentGradient.cpp.

{
    QGradient* gradient = new QLinearGradient();
 
    QColor color;
    Q_FOREACH (KoGradientSegment* segment, m_segments) {
        segment->startColor().toQColor(&color);
        gradient->setColorAt(segment->startOffset() , color);
        segment->endColor().toQColor(&color);
        gradient->setColorAt(segment->endOffset() , color);
    }
    return gradient;
}

References KoGradientSegment::endColor(), KoGradientSegment::endOffset(), m_segments, KoGradientSegment::startColor(), KoGradientSegment::startOffset(), and KoColor::toQColor().

toXML()

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

toXML convert the gradient to xml.

Definition at line 259 of file KoSegmentGradient.cpp.

{
    gradientElt.setAttribute("type", "segment");
    Q_FOREACH(KoGradientSegment *segment, this->segments()) {
        QDomElement segmentElt = doc.createElement("segment");
        QDomElement start = doc.createElement("start");
        QDomElement end = doc.createElement("end");
        segmentElt.setAttribute("start-offset", KisDomUtils::toString(segment->startOffset()));
        const KoColor startColor = segment->startColor();
        segmentElt.setAttribute("start-bitdepth", startColor.colorSpace()->colorDepthId().id());
        segmentElt.setAttribute("start-alpha", KisDomUtils::toString(startColor.opacityF()));
        segmentElt.setAttribute("start-type", KisDomUtils::toString(segment->startType()));
        startColor.toXML(doc, start);
        segmentElt.setAttribute("middle-offset", KisDomUtils::toString(segment->middleOffset()));
        segmentElt.setAttribute("end-offset", KisDomUtils::toString(segment->endOffset()));
        const KoColor endColor = segment->endColor();
        segmentElt.setAttribute("end-bitdepth", endColor.colorSpace()->colorDepthId().id());
        segmentElt.setAttribute("end-alpha", KisDomUtils::toString(endColor.opacityF()));
        segmentElt.setAttribute("end-type", KisDomUtils::toString(segment->endType()));
        endColor.toXML(doc, end);
        segmentElt.setAttribute("interpolation", KisDomUtils::toString(segment->interpolation()));
        segmentElt.setAttribute("color-interpolation", KisDomUtils::toString(segment->colorInterpolation()));
        segmentElt.appendChild(start);
        segmentElt.appendChild(end);
        gradientElt.appendChild(segmentElt);
    }
}

References KoColorSpace::colorDepthId(), KoGradientSegment::colorInterpolation(), KoColor::colorSpace(), KoGradientSegment::endColor(), KoGradientSegment::endOffset(), KoGradientSegment::endType(), KoID::id(), KoGradientSegment::interpolation(), KoGradientSegment::middleOffset(), KoColor::opacityF(), segments(), KoGradientSegment::startColor(), KoGradientSegment::startOffset(), KoGradientSegment::startType(), KisDomUtils::toString(), and KoColor::toXML().

updateVariableColors()

void KoSegmentGradient::updateVariableColors ( KoCanvasResourcesInterfaceSP canvasResourcesInterface )

overridevirtual

Reimplemented from KoAbstractGradient.

Definition at line 1152 of file KoSegmentGradient.cpp.

{
    const KoColor fgColor = canvasResourcesInterface->resource(KoCanvasResource::ForegroundColor).value<KoColor>().convertedTo(colorSpace());
    const KoColor bgColor = canvasResourcesInterface->resource(KoCanvasResource::BackgroundColor).value<KoColor>().convertedTo(colorSpace());
 
    for (auto it = m_segments.begin(); it != m_segments.end(); ++it) {
        if ((*it)->hasVariableColors()) {
            (*it)->setVariableColors(fgColor, bgColor);
        }
    }
}

References KoCanvasResource::BackgroundColor, and KoCanvasResource::ForegroundColor.

Member Data Documentation

m_segments

QList<KoGradientSegment *> KoSegmentGradient::m_segments

protected

Definition at line 479 of file KoSegmentGradient.h.

---

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

• libs/pigment/resources/KoSegmentGradient.h
• libs/pigment/resources/KoSegmentGradient.cpp