#include <psd_additional_layer_info_block.h>

Public Member Functions
QDomDocument	getASLXML ()

QSharedPointer< KoShapeBackground >	getBackground ()

QBrush	getBrush ()

QDomDocument	getFillLayerConfig ()

QGradient *	getGradient ()

bool	loadFromConfig (KisFilterConfigurationSP cfg)

void	setAlignWithLayer (bool align)

void	setAngle (float Angl)

void	setDither (bool Dthr)

void	setFromQGradient (const QGradient *gradient)

void	setGradient (const KoAbstractGradientSP &newGradient)

void	setOffset (QPointF Ofst)

void	setReverse (bool Rvrs)

void	setScale (float Scl)

void	setType (const QString type)

bool	svgCompatible ()

void	writeASL (KisAslXmlWriter &w)

Static Public Member Functions
static void	setupCatcher (const QString path, KisAslCallbackObjectCatcher &catcher, psd_layer_gradient_fill *data)

Public Attributes
bool	align_with_layer {false}

double	angle {0.0}

bool	dithered {false}

QDomDocument	gradient

int	imageHeight {1}

int	imageWidth {1}

QPointF	offset

QString	repeat {QString("none")}

bool	reverse {false}

double	scale {100.0}

QString	style {QString("linear")}

Detailed Description

Definition at line 239 of file psd_additional_layer_info_block.h.

Member Function Documentation

◆ getASLXML()

QDomDocument psd_layer_gradient_fill::getASLXML ( )

inline

Definition at line 469 of file psd_additional_layer_info_block.h.

                             {
        KisAslXmlWriter w;
        w.enterDescriptor("", "", "null");
        writeASL(w);
 
        w.leaveDescriptor();
 
        return w.document();
    }

◆ getBackground()

QSharedPointer< KoShapeBackground > psd_layer_gradient_fill::getBackground ( )

inline

Definition at line 622 of file psd_additional_layer_info_block.h.

                                                      {
        QGradient *pointer = getGradient();
        QSharedPointer<KoGradientBackground> bg = QSharedPointer<KoGradientBackground>(new KoGradientBackground(pointer));
        return bg;
    }

◆ getBrush()

QBrush psd_layer_gradient_fill::getBrush ( )

inline

Definition at line 520 of file psd_additional_layer_info_block.h.

                      {
        QGradient *grad = getGradient();
        if (grad) {
            QBrush brush = *grad;
            return brush;
        }
        return QBrush(Qt::transparent);
    }

◆ getFillLayerConfig()

QDomDocument psd_layer_gradient_fill::getFillLayerConfig ( )

inline

Definition at line 321 of file psd_additional_layer_info_block.h.

                                      {
        KisFilterConfigurationSP cfg;
        cfg = KisGeneratorRegistry::instance()->value("gradient")->defaultConfiguration(KisGlobalResourcesInterface::instance());
        cfg->setProperty("gradient", gradient.toString());
        cfg->setProperty("dither", dithered);
        cfg->setProperty("reverse", reverse);
 
        cfg->setProperty("shape", style);
        cfg->setProperty("repeat", repeat);
 
        cfg->setProperty("end_position_coordinate_system", "polar");
 
        cfg->setProperty("end_position_distance_units", "percent_of_width");
        cfg->setProperty("start_position_x_units", "percent_of_width");
        cfg->setProperty("start_position_y_units", "percent_of_height");
 
        // angle seems to go from -180 to +180;
        double fixedAngle = fmod(360.0 + angle, 360.0);
 
        double scaleModifier = 1.0;
 
        if (style == "square") {
            fixedAngle = fmod((45.0 + fixedAngle), 360.0);
 
            scaleModifier = cos(kisDegreesToRadians(45.0));
            double halfAngle = fmod(fabs(fixedAngle), 180.0);
            scaleModifier *= 1/cos(kisDegreesToRadians(45.0 - fmod(halfAngle, 45.0) ));
            if (halfAngle >= 45.0 && halfAngle < 135.0) {
                scaleModifier = (scaleModifier) * (imageHeight / imageWidth);
            }
 
        } else {
            double halfAngle = fmod(fabs(fixedAngle), 180.0);
            scaleModifier *= 1/cos(kisDegreesToRadians(halfAngle));
            if (halfAngle >= 45.0 && halfAngle < 135.0) {
                scaleModifier = (scaleModifier) * (imageHeight / imageWidth);
            }
 
        }
 
        cfg->setProperty("end_position_angle", fixedAngle);
 
        if (style == "linear") {
            // linear has the problem that in Krita it rotates around the top-left,
            // while in psd it rotates around the middle.
            QPointF center(imageWidth*0.5, imageHeight*0.5);
 
            QTransform rotate;
            rotate.rotate(fixedAngle);
            QTransform tf = QTransform::fromTranslate(-center.x(), -center.y())
                    * rotate * QTransform::fromTranslate(center.x(), center.y());
            QPointF topleft = tf.inverted().map(QPointF(0.0, 0.0));
            double xPercentage = (topleft.x()/double(imageWidth)) * 100.0;
            double yPercentage = (topleft.y()/double(imageHeight)) * 100.0;
 
            cfg->setProperty("end_position_distance", scale * scaleModifier);
            cfg->setProperty("start_position_x", xPercentage + offset.x());
            cfg->setProperty("start_position_y", yPercentage + offset.y());
        } else {
            cfg->setProperty("end_position_distance", scale * 0.5 * fabs(scaleModifier));
            cfg->setProperty("start_position_x", (50.0)+offset.x());
            cfg->setProperty("start_position_y", (50.0)+offset.y());
        }
 
        QDomDocument doc;
        doc.setContent(cfg->toXML());
        return doc;
    }

References KisBaseProcessor::defaultConfiguration(), KisGeneratorRegistry::instance(), KisGlobalResourcesInterface::instance(), kisDegreesToRadians(), and KoGenericRegistry< T >::value().

◆ getGradient()

QGradient * psd_layer_gradient_fill::getGradient ( )

inline

Definition at line 528 of file psd_additional_layer_info_block.h.

                             {
        QGradient *pointer = nullptr;
        if (!gradient.isNull()) {
            const QDomElement gradientElement = gradient.firstChildElement();
            if (!gradientElement.isNull()) {
                const QString gradientType = gradientElement.attribute("type");
                if (gradientType == "stop") {
                    const KoStopGradient grad = KoStopGradient::fromXML(gradientElement);
                    if (grad.valid()) {
                        pointer = grad.toQGradient();
                    }
                } else if (gradientType == "segment") {
                    const KoSegmentGradient grad = KoSegmentGradient::fromXML(gradientElement);
                    if (grad.valid()) {
                        pointer = grad.toQGradient();
                    }
                }
            }
        }
        if (pointer) {
            QGradient::CoordinateMode mode = QGradient::ObjectBoundingMode;
            pointer->setCoordinateMode(mode);
 
            if (reverse) {
                QGradientStops newStops;
                Q_FOREACH(QGradientStop stop, pointer->stops()) {
                    newStops.append(QPair<double, QColor>(1.0-stop.first, stop.second));
                }
                pointer->setStops(newStops);
            }
 
            QLinearGradient *g = static_cast<QLinearGradient*>(pointer);
            QLineF line = QLineF::fromPolar(0.5*(scale*0.01), angle);
            line.translate(QPointF(0.5, 0.5)+(offset*0.01));
 
            if (style == "radial") {
                QRadialGradient *r = new QRadialGradient(line.p1(), line.length());
                r->setCoordinateMode(mode);
 
                r->setSpread(pointer->spread());
                r->setStops(pointer->stops());
                pointer = r;
 
            } else if (style == "bilinear") {
                QLinearGradient *b = new QLinearGradient();
                Q_FOREACH(QGradientStop stop, pointer->stops()) {
                    double pos = 0.5 - stop.first*0.5;
                    b->setColorAt(pos, stop.second);
                    double pos2 = 1.0 - pos;
                    if (pos != pos2) {
                        b->setColorAt(pos2, stop.second);
                    }
                }
                b->setCoordinateMode(mode);
 
                b->setFinalStop(line.p2());
                line.setAngle(180+angle);
                b->setStart(line.p2());
                pointer = b;
            } else if (g) {
                g->setFinalStop(line.p2());
                line.setAngle(180+angle);
                g->setStart(line.p2());
                pointer = g;
            }
        }
 
        return pointer;
    }

References KoSegmentGradient::fromXML(), KoStopGradient::fromXML(), KoSegmentGradient::toQGradient(), KoStopGradient::toQGradient(), and KoResource::valid.

◆ loadFromConfig()

bool psd_layer_gradient_fill::loadFromConfig ( KisFilterConfigurationSP cfg )

inline

Definition at line 390 of file psd_additional_layer_info_block.h.

                                                      {
        if (cfg->name() != "gradient") {
            return false;
        }
 
        bool res = bool(gradient.setContent(cfg->getString("gradient", "")));
        dithered = cfg->getBool("dither");
        reverse = cfg->getBool("reverse");
        align_with_layer = false; // not supported.
 
        style = cfg->getString("shape", "linear");
        repeat = cfg->getString("repeat", "none");
 
        bool polar = (cfg->getString("end_position_coordinate_system") == "polar");
 
        QPointF start(cfg->getDouble("start_position_x", 0.0), cfg->getDouble("start_position_y", 0.0));
        if (polar) {
            angle = cfg->getDouble("end_position_angle", 0.0);
            scale = cfg->getDouble("end_position_distance", 100.0);
        } else {
            // assume cartesian
            QPointF end(cfg->getDouble("end_position_x", 1.0), cfg->getDouble("end_position_y", 1.0));
            // calculate angle and scale.
            double width  = start.x() - end.x();
            double height = start.y() - end.y();
            angle = fmod(360.0 + kisRadiansToDegrees(atan2(width, height)), 360.0);
            scale = sqrt((width*width) + (height*height));
        }
 
 
        if (style == "linear") {
            QPointF center(imageWidth*0.5, imageHeight*0.5);
 
            QTransform rotate;
            rotate.rotate(angle);
            QTransform tf = QTransform::fromTranslate(-center.x(), -center.y())
                    * rotate * QTransform::fromTranslate(center.x(), center.y());
            QPointF topleft = tf.inverted().map(QPointF(0.0, 0.0));
            double xPercentage = (topleft.x()/double(imageWidth)) * 100.0;
            double yPercentage = (topleft.y()/double(imageHeight)) * 100.0;
            offset = QPointF((start.x() - xPercentage), (start.y() - yPercentage));
        } else {
            scale = scale*2;
            offset = QPointF((start.x() - 50.0), (start.y() - 50.0));
        }
 
        double scaleModifier = 1.0;
        if (style == "square") {
            scaleModifier = cos(kisDegreesToRadians(45.0));
            double halfAngle = fmod(fabs(angle), 180.0);
            scaleModifier *= 1/cos(kisDegreesToRadians(45.0 - fmod(halfAngle, 45.0) ));
            if (halfAngle >= 45.0 && halfAngle < 135.0) {
                scaleModifier = (scaleModifier) * (imageHeight / imageWidth);
            }
 
            angle = angle - 45.0;
            if (angle < 0) {
                angle = 360.0 - angle;
            }
 
        } else {
            double halfAngle = fmod(fabs(angle), 180.0);
            scaleModifier *= 1/cos(kisDegreesToRadians(halfAngle));
            if (halfAngle >= 45.0 && halfAngle < 135.0) {
                scaleModifier = (scaleModifier) * (imageHeight / imageWidth);
            }
 
        }
 
        if (angle > 180) {
            angle = (0.0 - fmod(angle, 180.0));
        }
 
        scale /= fabs(scaleModifier);
 
 
        return res;
    }

References kisDegreesToRadians(), and kisRadiansToDegrees().

◆ setAlignWithLayer()

void psd_layer_gradient_fill::setAlignWithLayer ( bool align )

inline

Definition at line 298 of file psd_additional_layer_info_block.h.

                                       {
        align_with_layer = align;
    }

◆ setAngle()

void psd_layer_gradient_fill::setAngle ( float Angl )

inline

Definition at line 278 of file psd_additional_layer_info_block.h.

                              {
        angle = Angl;
    }

◆ setDither()

void psd_layer_gradient_fill::setDither ( bool Dthr )

inline

Definition at line 270 of file psd_additional_layer_info_block.h.

                              {
        dithered = Dthr;
    }

◆ setFromQGradient()

void psd_layer_gradient_fill::setFromQGradient ( const QGradient * gradient )

inline

Definition at line 598 of file psd_additional_layer_info_block.h.

                                                     {
        setGradient(KoStopGradient::fromQGradient(gradient));
        if (gradient->coordinateMode() == QGradient::ObjectBoundingMode) {
            align_with_layer = true;
        }
        if (gradient->type() == QGradient::LinearGradient) {
            const QLinearGradient *g = static_cast<const QLinearGradient*>(gradient);
            QLineF line(g->start(), g->finalStop());
            offset = (line.center()-QPointF(0.5, 0.5))*100.0;
            angle = line.angle();
            if (angle > 180) {
                angle = (0.0 - fmod(angle, 180.0));
            }
            scale = (line.length())*100.0;
            style = "linear";
        } else {
            const QRadialGradient *g = static_cast<const QRadialGradient*>(gradient);
            offset = (g->center()-QPointF(0.5, 0.5)) * 100.0;
            angle = 0;
            scale = (g->radius()*2) * 100.0;
            style = "radial";
        }
    }

References KoStopGradient::fromQGradient().

◆ setGradient()

void psd_layer_gradient_fill::setGradient ( const KoAbstractGradientSP & newGradient )

inline

Definition at line 253 of file psd_additional_layer_info_block.h.

                                                              {
        QDomDocument document;
        QDomElement gradientElement = document.createElement("gradient");
        gradientElement.setAttribute("name", newGradient->name());
 
        if (dynamic_cast<KoStopGradient*>(newGradient.data())) {
            KoStopGradient *gradient = dynamic_cast<KoStopGradient*>(newGradient.data());
            gradient->toXML(document, gradientElement);
        } else if (dynamic_cast<KoSegmentGradient*>(newGradient.data())) {
            KoSegmentGradient *gradient = dynamic_cast<KoSegmentGradient*>(newGradient.data());
            gradient->toXML(document, gradientElement);
        }
 
        document.appendChild(gradientElement);
        gradient = document;
    }

References KoSegmentGradient::toXML(), and KoStopGradient::toXML().

◆ setOffset()

void psd_layer_gradient_fill::setOffset ( QPointF Ofst )

inline

Definition at line 306 of file psd_additional_layer_info_block.h.

                                 {
        offset = Ofst;
    }

◆ setReverse()

void psd_layer_gradient_fill::setReverse ( bool Rvrs )

inline

Definition at line 274 of file psd_additional_layer_info_block.h.

                               {
        reverse = Rvrs;
    }

◆ setScale()

void psd_layer_gradient_fill::setScale ( float Scl )

inline

Definition at line 302 of file psd_additional_layer_info_block.h.

                             {
        scale = Scl;
    }

◆ setType()

void psd_layer_gradient_fill::setType ( const QString type )

inline

Definition at line 282 of file psd_additional_layer_info_block.h.

                                     {
        repeat = "none";
        if (type == "Lnr "){
            style = "linear";
        } else if (type == "Rdl "){
            style = "radial";
        } else if (type == "Angl"){
            style = "conical";
        } else if (type == "Rflc"){
            style = "bilinear";
            repeat ="alternate";
        } else {
            style = "square"; // diamond???
        }
    }

◆ setupCatcher()

static void psd_layer_gradient_fill::setupCatcher	(	const QString	path,
		KisAslCallbackObjectCatcher &	catcher,
		psd_layer_gradient_fill *	data )

inlinestatic

Definition at line 310 of file psd_additional_layer_info_block.h.

                                                                                                                      {
        catcher.subscribeGradient(path + "/Grad", std::bind(&psd_layer_gradient_fill::setGradient, data, std::placeholders::_1));
        catcher.subscribeBoolean(path + "/Dthr", std::bind(&psd_layer_gradient_fill::setDither, data, std::placeholders::_1));
        catcher.subscribeBoolean(path + "/Rvrs", std::bind(&psd_layer_gradient_fill::setReverse, data, std::placeholders::_1));
        catcher.subscribeUnitFloat(path + "/Angl", "#Ang", std::bind(&psd_layer_gradient_fill::setAngle, data, std::placeholders::_1));
        catcher.subscribeEnum(path + "/Type", "GrdT", std::bind(&psd_layer_gradient_fill::setType, data, std::placeholders::_1));
        catcher.subscribeBoolean(path + "/Algn", std::bind(&psd_layer_gradient_fill::setAlignWithLayer, data, std::placeholders::_1));
        catcher.subscribeUnitFloat(path + "/Scl ", "#Prc", std::bind(&psd_layer_gradient_fill::setScale, data, std::placeholders::_1));
        catcher.subscribePoint(path + "/Ofst", std::bind(&psd_layer_gradient_fill::setOffset, data, std::placeholders::_1));
    }

References setAlignWithLayer(), setAngle(), setDither(), setGradient(), setOffset(), setReverse(), setScale(), setType(), KisAslCallbackObjectCatcher::subscribeBoolean(), KisAslCallbackObjectCatcher::subscribeEnum(), KisAslCallbackObjectCatcher::subscribeGradient(), KisAslCallbackObjectCatcher::subscribePoint(), and KisAslCallbackObjectCatcher::subscribeUnitFloat().

◆ svgCompatible()

bool psd_layer_gradient_fill::svgCompatible ( )

inline

Definition at line 628 of file psd_additional_layer_info_block.h.

                         {
        if (style == "radial" || style == "linear") {
            return true;
        }
        return false;
    }

◆ writeASL()

void psd_layer_gradient_fill::writeASL ( KisAslXmlWriter & w )

inline

Definition at line 479 of file psd_additional_layer_info_block.h.

                                      {
        if (!gradient.isNull()) {
            const QDomElement gradientElement = gradient.firstChildElement();
            if (!gradientElement.isNull()) {
                const QString gradientType = gradientElement.attribute("type");
                if (gradientType == "stop") {
                    const KoStopGradient grad = KoStopGradient::fromXML(gradientElement);
                    if (grad.valid()) {
                        w.writeStopGradient("Grad", grad);
                    }
                } else if (gradientType == "segment") {
                    const KoSegmentGradient grad = KoSegmentGradient::fromXML(gradientElement);
                    if (grad.valid()) {
                        w.writeSegmentGradient("Grad", grad);
                    }
                }
            }
        }
        w.writeBoolean("Dthr", dithered);
        w.writeBoolean("Rvrs", reverse);
        w.writeUnitFloat("Angl", "#Ang", angle);
 
        QString type = "Lnr ";
        if (style == "linear"){
            type = "Lnr ";
        } else if (style == "radial") {
            type = "Rdl ";
        } else if (style == "conical"){
            type = "Angl";
        } else if (style == "bilinear"){
            type = "Rflc";
        } else if (style == "square") {
            type = "Dmnd";
        }
 
        w.writeEnum("Type", "GrdT", type);
        w.writeBoolean("Algn", align_with_layer);
        w.writeUnitFloat("Scl ", "#Prc", scale);
        w.writePoint("Ofst", offset);
    }