SvgStyleWriter Class Reference

Helper class to save svg styles. More...

#include <SvgStyleWriter.h>

Static Public Member Functions
static QString	embedShape (const KoShape *shape, SvgSavingContext &context)
static void	saveMetadata (const KoShape *shape, SvgSavingContext &context)
static void	saveSvgBasicStyle (const bool isVisible, const qreal transparency, const QVector< KoShape::PaintOrder > paintOrder, bool inheritPaintorder, SvgSavingContext &context, bool textShape=false)
	Saves only stroke, fill and transparency of the shape.
static void	saveSvgFill (QSharedPointer< KoShapeBackground > background, const bool fillRuleEvenOdd, const QRectF outlineRect, const QSizeF size, const QTransform absoluteTransform, SvgSavingContext &context)
	Saves fill style of specified shape.
static void	saveSvgStroke (KoShapeStrokeModelSP, SvgSavingContext &context)
	Saves stroke style of specified shape.
static void	saveSvgStyle (KoShape *shape, SvgSavingContext &context)
	Saves the style of the specified shape.

Static Protected Member Functions
static void	saveSvgClipping (KoShape *shape, SvgSavingContext &context)
	Saves clipping of specified shape.
static void	saveSvgColorStops (const QGradientStops &colorStops, SvgSavingContext &context)
	Saves gradient color stops.
static QString	saveSvgGradient (const QGradient *gradient, const QTransform &gradientTransform, SvgSavingContext &context)
	Saves gradient.
static void	saveSvgMarkers (KoShape *shape, SvgSavingContext &context)
	Saves markers of the path shape if present.
static void	saveSvgMasking (KoShape *shape, SvgSavingContext &context)
	Saves masking of specified shape.
static QString	saveSvgMeshGradient (SvgMeshGradient *gradient, const QTransform &transform, SvgSavingContext &context)
static QString	saveSvgPattern (QSharedPointer< KoPatternBackground > pattern, const QSizeF shapeSize, const QTransform absoluteTransform, SvgSavingContext &context)
	Saves pattern.
static QString	saveSvgVectorPattern (QSharedPointer< KoVectorPatternBackground > pattern, const QRectF outlineRect, SvgSavingContext &context)

Detailed Description

Helper class to save svg styles.

Definition at line 35 of file SvgStyleWriter.h.

Member Function Documentation

embedShape()

QString SvgStyleWriter::embedShape ( const KoShape * shape, SvgSavingContext & context )

static

Definition at line 207 of file SvgStyleWriter.cpp.

{
    QList<KoShape *> shapes;
    KoShape* clonedShape = shape->cloneShape();
    if (!clonedShape) {
        return QString();
    }
    const QString uid = context.createUID("path");
    clonedShape->setName(uid);
    shapes.append(clonedShape);
    embedShapes(shapes, context.styleWriter());
    return uid;
}

References KoShape::cloneShape(), SvgSavingContext::createUID(), embedShapes(), KoShape::setName(), and SvgSavingContext::styleWriter.

saveMetadata()

void SvgStyleWriter::saveMetadata ( const KoShape * shape, SvgSavingContext & context )

static

Definition at line 221 of file SvgStyleWriter.cpp.

{
    const QString title = shape->additionalAttribute("title");
    if (!title.trimmed().isEmpty()) {
        context.shapeWriter().startElement("title");
        context.shapeWriter().addTextNode(title);
        context.shapeWriter().endElement();
    }
    const QString desc = shape->additionalAttribute("desc");
    if (!desc.trimmed().isEmpty()) {
        context.shapeWriter().startElement("desc");
        context.shapeWriter().addTextNode(desc);
        context.shapeWriter().endElement();
    }
}

References KoShape::additionalAttribute(), and SvgSavingContext::shapeWriter.

saveSvgBasicStyle()

void SvgStyleWriter::saveSvgBasicStyle ( const bool isVisible, const qreal transparency, const QVector< KoShape::PaintOrder > paintOrder, bool inheritPaintorder, SvgSavingContext & context, bool textShape = false )

static

Saves only stroke, fill and transparency of the shape.

Definition at line 70 of file SvgStyleWriter.cpp.

{
    if (!isVisible) {
        context.shapeWriter().addAttribute("display", "none");
    } else if (transparency > 0.0) {
        context.shapeWriter().addAttribute("opacity", 1.0 - transparency);
    }
    if (!paintOrder.isEmpty() && !inheritPaintorder) {
 
        const bool notDefault = paintOrder != KoShape::defaultPaintOrder();
 
        if ((!textShape && notDefault) || textShape) {
            QStringList order;
            Q_FOREACH(const KoShape::PaintOrder p, paintOrder) {
                if (p == KoShape::Fill) {
                    order.append("fill");
                } else if (p == KoShape::Stroke) {
                    order.append("stroke");
                } else if (p == KoShape::Markers) {
                    order.append("markers");
                }
            }
            context.shapeWriter().addAttribute("paint-order", order.join(" "));
        }
    }
 
}

References KoShape::defaultPaintOrder(), KoShape::Fill, KoShape::Markers, p, SvgSavingContext::shapeWriter, and KoShape::Stroke.

saveSvgClipping()

void SvgStyleWriter::saveSvgClipping ( KoShape * shape, SvgSavingContext & context )

staticprotected

Saves clipping of specified shape.

Definition at line 237 of file SvgStyleWriter.cpp.

{
    KoClipPath *clipPath = shape->clipPath();
    if (!clipPath)
        return;
 
    const QString uid = context.createUID("clippath");
 
    context.styleWriter().startElement("clipPath");
    context.styleWriter().addAttribute("id", uid);
    context.styleWriter().addAttribute("clipPathUnits", KoFlake::coordinateToString(clipPath->coordinates()));
 
    embedShapes(clipPath->clipShapes(), context.styleWriter());
 
    context.styleWriter().endElement(); // clipPath
 
    context.shapeWriter().addAttribute("clip-path", "url(#" + uid + ")");
    if (clipPath->clipRule() != Qt::WindingFill)
        context.shapeWriter().addAttribute("clip-rule", "evenodd");
}

References KoShape::clipPath(), KoClipPath::clipRule, KoClipPath::clipShapes(), KoClipPath::coordinates, KoFlake::coordinateToString(), SvgSavingContext::createUID(), embedShapes(), SvgSavingContext::shapeWriter, and SvgSavingContext::styleWriter.

saveSvgColorStops()

void SvgStyleWriter::saveSvgColorStops ( const QGradientStops & colorStops, SvgSavingContext & context )

staticprotected

Saves gradient color stops.

Definition at line 344 of file SvgStyleWriter.cpp.

{
    Q_FOREACH (const QGradientStop &stop, colorStops) {
        context.styleWriter().startElement("stop");
        context.styleWriter().addAttribute("stop-color", stop.second.name());
        context.styleWriter().addAttribute("offset", stop.first);
        context.styleWriter().addAttribute("stop-opacity", stop.second.alphaF());
        context.styleWriter().endElement();
    }
}

References SvgSavingContext::styleWriter.

saveSvgFill()

void SvgStyleWriter::saveSvgFill ( QSharedPointer< KoShapeBackground > background, const bool fillRuleEvenOdd, const QRectF outlineRect, const QSizeF size, const QTransform absoluteTransform, SvgSavingContext & context )

static

Saves fill style of specified shape.

Definition at line 98 of file SvgStyleWriter.cpp.

{
    if (! background) {
        context.shapeWriter().addAttribute("fill", "none");
    }
 
    QBrush fill(Qt::NoBrush);
    QSharedPointer<KoColorBackground>  cbg = qSharedPointerDynamicCast<KoColorBackground>(background);
    if (cbg) {
        context.shapeWriter().addAttribute("fill", cbg->color().name());
        if (cbg->color().alphaF() < 1.0)
            context.shapeWriter().addAttribute("fill-opacity", cbg->color().alphaF());
    }
    QSharedPointer<KoGradientBackground>  gbg = qSharedPointerDynamicCast<KoGradientBackground>(background);
    if (gbg) {
        QString gradientId = saveSvgGradient(gbg->gradient(), gbg->transform(), context);
        context.shapeWriter().addAttribute("fill", "url(#" + gradientId + ")");
    }
    QSharedPointer<KoMeshGradientBackground> mgbg = qSharedPointerDynamicCast<KoMeshGradientBackground>(background);
    if (mgbg) {
        QString gradientId = saveSvgMeshGradient(mgbg->gradient(), mgbg->transform(), context);
        context.shapeWriter().addAttribute("fill", "url(#" + gradientId + ")");
    }
    QSharedPointer<KoPatternBackground>  pbg = qSharedPointerDynamicCast<KoPatternBackground>(background);
    if (pbg) {
        const QString patternId = saveSvgPattern(pbg, size, absoluteTransform, context);
        context.shapeWriter().addAttribute("fill", "url(#" + patternId + ")");
    }
    QSharedPointer<KoVectorPatternBackground>  vpbg = qSharedPointerDynamicCast<KoVectorPatternBackground>(background);
    if (vpbg) {
        const QString patternId = saveSvgVectorPattern(vpbg, outlineRect, context);
        context.shapeWriter().addAttribute("fill", "url(#" + patternId + ")");
    }
 
    // non-zero is default, so only write fillrule if evenodd is set
    if (fillRuleEvenOdd)
        context.shapeWriter().addAttribute("fill-rule", "evenodd");
}

References saveSvgGradient(), saveSvgMeshGradient(), saveSvgPattern(), saveSvgVectorPattern(), and SvgSavingContext::shapeWriter.

saveSvgGradient()

QString SvgStyleWriter::saveSvgGradient ( const QGradient * gradient, const QTransform & gradientTransform, SvgSavingContext & context )

staticprotected

Saves gradient.

Definition at line 365 of file SvgStyleWriter.cpp.

{
    if (! gradient)
        return QString();
 
    const QString spreadMethod[3] = {
        QString("pad"),
        QString("reflect"),
        QString("repeat")
    };
 
    const QString uid = context.createUID("gradient");
 
    if (gradient->type() == QGradient::LinearGradient) {
        const QLinearGradient * g = static_cast<const QLinearGradient*>(gradient);
        context.styleWriter().startElement("linearGradient");
        context.styleWriter().addAttribute("id", uid);
        SvgUtil::writeTransformAttributeLazy("gradientTransform", gradientTransform, context.styleWriter());
        context.styleWriter().addAttribute("gradientUnits", convertGradientMode(g->coordinateMode()));
        context.styleWriter().addAttribute("x1", g->start().x());
        context.styleWriter().addAttribute("y1", g->start().y());
        context.styleWriter().addAttribute("x2", g->finalStop().x());
        context.styleWriter().addAttribute("y2", g->finalStop().y());
        context.styleWriter().addAttribute("spreadMethod", spreadMethod[g->spread()]);
        // color stops
        saveSvgColorStops(gradient->stops(), context);
        context.styleWriter().endElement();
    } else if (gradient->type() == QGradient::RadialGradient) {
        const QRadialGradient * g = static_cast<const QRadialGradient*>(gradient);
        context.styleWriter().startElement("radialGradient");
        context.styleWriter().addAttribute("id", uid);
        SvgUtil::writeTransformAttributeLazy("gradientTransform", gradientTransform, context.styleWriter());
        context.styleWriter().addAttribute("gradientUnits", convertGradientMode(g->coordinateMode()));
        context.styleWriter().addAttribute("cx", g->center().x());
        context.styleWriter().addAttribute("cy", g->center().y());
        context.styleWriter().addAttribute("fx", g->focalPoint().x());
        context.styleWriter().addAttribute("fy", g->focalPoint().y());
        context.styleWriter().addAttribute("r", g->radius());
        context.styleWriter().addAttribute("spreadMethod", spreadMethod[g->spread()]);
        // color stops
        saveSvgColorStops(gradient->stops(), context);
        context.styleWriter().endElement();
    } else if (gradient->type() == QGradient::ConicalGradient) {
        //const QConicalGradient * g = static_cast<const QConicalGradient*>( gradient );
        // fake conical grad as radial.
        // fugly but better than data loss.
        /*
        printIndentation( m_defs, m_indent2 );
        *m_defs << "<radialGradient id=\"" << uid << "\" ";
        *m_defs << "gradientUnits=\"userSpaceOnUse\" ";
        *m_defs << "cx=\"" << g->center().x() << "\" ";
        *m_defs << "cy=\"" << g->center().y() << "\" ";
        *m_defs << "fx=\"" << grad.focalPoint().x() << "\" ";
        *m_defs << "fy=\"" << grad.focalPoint().y() << "\" ";
        double r = sqrt( pow( grad.vector().x() - grad.origin().x(), 2 ) + pow( grad.vector().y() - grad.origin().y(), 2 ) );
        *m_defs << "r=\"" << QString().setNum( r ) << "\" ";
        *m_defs << spreadMethod[g->spread()];
        *m_defs << ">" << Qt::endl;
 
        // color stops
        getColorStops( gradient->stops() );
 
        printIndentation( m_defs, m_indent2 );
        *m_defs << "</radialGradient>" << Qt::endl;
        *m_body << "url(#" << uid << ")";
        */
    }
 
    return uid;
}

References convertGradientMode(), SvgSavingContext::createUID(), saveSvgColorStops(), SvgSavingContext::styleWriter, and SvgUtil::writeTransformAttributeLazy().

saveSvgMarkers()

void SvgStyleWriter::saveSvgMarkers ( KoShape * shape, SvgSavingContext & context )

staticprotected

Saves markers of the path shape if present.

Definition at line 329 of file SvgStyleWriter.cpp.

{
    KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
    if (!pathShape || !pathShape->hasMarkers()) return;
 
 
    tryEmbedMarker(pathShape, "marker-start", KoFlake::StartMarker, context);
    tryEmbedMarker(pathShape, "marker-mid", KoFlake::MidMarker, context);
    tryEmbedMarker(pathShape, "marker-end", KoFlake::EndMarker, context);
 
    if (pathShape->autoFillMarkers()) {
        context.shapeWriter().addAttribute("krita:marker-fill-method", "auto");
    }
}

References KoPathShape::autoFillMarkers(), KoFlake::EndMarker, KoPathShape::hasMarkers(), KoFlake::MidMarker, SvgSavingContext::shapeWriter, and KoFlake::StartMarker.

saveSvgMasking()

void SvgStyleWriter::saveSvgMasking ( KoShape * shape, SvgSavingContext & context )

staticprotected

Saves masking of specified shape.

Definition at line 258 of file SvgStyleWriter.cpp.

{
    KoClipMask*clipMask = shape->clipMask();
    if (!clipMask)
        return;
 
    const QString uid = context.createUID("clipmask");
 
    context.styleWriter().startElement("mask");
    context.styleWriter().addAttribute("id", uid);
    context.styleWriter().addAttribute("maskUnits", KoFlake::coordinateToString(clipMask->coordinates()));
    context.styleWriter().addAttribute("maskContentUnits", KoFlake::coordinateToString(clipMask->contentCoordinates()));
 
    const QRectF rect = clipMask->maskRect();
 
    context.styleWriter().addAttribute("x", rect.x());
    context.styleWriter().addAttribute("y", rect.y());
    context.styleWriter().addAttribute("width", rect.width());
    context.styleWriter().addAttribute("height", rect.height());
 
    embedShapes(clipMask->shapes(), context.styleWriter());
 
    context.styleWriter().endElement(); // clipMask
 
    context.shapeWriter().addAttribute("mask", "url(#" + uid + ")");
}

References KoShape::clipMask(), KoClipMask::contentCoordinates, KoClipMask::coordinates, KoFlake::coordinateToString(), SvgSavingContext::createUID(), embedShapes(), KoClipMask::maskRect, KoClipMask::shapes, SvgSavingContext::shapeWriter, and SvgSavingContext::styleWriter.

saveSvgMeshGradient()

QString SvgStyleWriter::saveSvgMeshGradient ( SvgMeshGradient * gradient, const QTransform & transform, SvgSavingContext & context )

staticprotected

Definition at line 436 of file SvgStyleWriter.cpp.

{
    if (!gradient || !gradient->isValid())
        return QString();
 
    const QString uid = context.createUID("meshgradient");
    context.styleWriter().startElement("meshgradient");
    context.styleWriter().addAttribute("id", uid);
 
    if (gradient->gradientUnits() == KoFlake::ObjectBoundingBox) {
        context.styleWriter().addAttribute("gradientUnits", "objectBoundingBox");
    } else {
        context.styleWriter().addAttribute("gradientUnits", "userSpaceOnUse");
    }
 
    SvgUtil::writeTransformAttributeLazy("transform", transform, context.styleWriter());
 
    SvgMeshArray *mesharray = gradient->getMeshArray().data();
    QPointF start = mesharray->getPatch(0, 0)->getStop(SvgMeshPatch::Top).point;
 
    context.styleWriter().addAttribute("x", start.x());
    context.styleWriter().addAttribute("y", start.y());
 
    if (gradient->type() == SvgMeshGradient::BILINEAR) {
        context.styleWriter().addAttribute("type", "bilinear");
    } else {
        context.styleWriter().addAttribute("type", "bicubic");
    }
 
    for (int row = 0; row < mesharray->numRows(); ++row) {
 
        const QString uid = context.createUID("meshrow");
        context.styleWriter().startElement("meshrow");
        context.styleWriter().addAttribute("id", uid);
 
        for (int col = 0; col < mesharray->numColumns(); ++col) {
 
            const QString uid = context.createUID("meshpatch");
            context.styleWriter().startElement("meshpatch");
            context.styleWriter().addAttribute("id", uid);
 
            SvgMeshPatch *patch = mesharray->getPatch(row, col);
 
            for (int s = 0; s < 4; ++s) {
                SvgMeshPatch::Type type = static_cast<SvgMeshPatch::Type> (s);
 
                // only first row and first col have Top and Left stop, respectively
                if ((row != 0 && s == SvgMeshPatch::Top) ||
                    (col != 0 && s == SvgMeshPatch::Left)) {
                    continue;
                }
 
                context.styleWriter().startElement("stop");
 
                std::array<QPointF, 4> segment = patch->getSegment(type);
 
                QString pathstr;
                QTextStream stream(&pathstr);
                KisPortingUtils::setUtf8OnStream(stream);
 
                stream.setRealNumberPrecision(10);
                // TODO: other path type?
                stream << "C "
                       << segment[1].x() << "," << segment[1].y() << " "
                       << segment[2].x() << "," << segment[2].y() << " "
                       << segment[3].x() << "," << segment[3].y(); // I don't see any harm, inkscape does this too
 
                context.styleWriter().addAttribute("path", pathstr);
 
                // don't add color/opacity if stop is in first row and stop == Top (or)
                // don't add color/opacity if stop is not in first row and stop == Right
                if ((row != 0 || col == 0 || s != SvgMeshPatch::Top) &&
                    (row == 0 || s != SvgMeshPatch::Right)) {
 
                    SvgMeshStop stop = patch->getStop(type);
                    context.styleWriter().addAttribute("stop-color", stop.color.name());
                    context.styleWriter().addAttribute("stop-opacity", stop.color.alphaF());
                }
 
                context.styleWriter().endElement(); // stop
            }
 
            context.styleWriter().endElement();  // meshpatch
        }
        context.styleWriter().endElement(); // meshrow
    }
    context.styleWriter().endElement(); // meshgradient
 
    return uid;
}

References SvgMeshGradient::BILINEAR, SvgMeshStop::color, SvgSavingContext::createUID(), SvgMeshGradient::getMeshArray(), SvgMeshArray::getPatch(), SvgMeshPatch::getSegment(), SvgMeshPatch::getStop(), SvgMeshGradient::gradientUnits(), SvgMeshGradient::isValid(), SvgMeshPatch::Left, SvgMeshArray::numColumns(), SvgMeshArray::numRows(), KoFlake::ObjectBoundingBox, SvgMeshStop::point, SvgMeshPatch::Right, KisPortingUtils::setUtf8OnStream(), SvgSavingContext::styleWriter, SvgMeshPatch::Top, SvgMeshGradient::type(), and SvgUtil::writeTransformAttributeLazy().

saveSvgPattern()

QString SvgStyleWriter::saveSvgPattern ( QSharedPointer< KoPatternBackground > pattern, const QSizeF shapeSize, const QTransform absoluteTransform, SvgSavingContext & context )

staticprotected

Saves pattern.

Definition at line 529 of file SvgStyleWriter.cpp.

{
    const QString uid = context.createUID("pattern");
 
    const QSizeF patternSize = pattern->patternDisplaySize();
    const QSize imageSize = pattern->pattern().size();
 
    // calculate offset in point
    QPointF offset = pattern->referencePointOffset();
    offset.rx() = 0.01 * offset.x() * patternSize.width();
    offset.ry() = 0.01 * offset.y() * patternSize.height();
 
    // now take the reference point into account
    switch (pattern->referencePoint()) {
    case KoPatternBackground::TopLeft:
        break;
    case KoPatternBackground::Top:
        offset += QPointF(0.5 * shapeSize.width(), 0.0);
        break;
    case KoPatternBackground::TopRight:
        offset += QPointF(shapeSize.width(), 0.0);
        break;
    case KoPatternBackground::Left:
        offset += QPointF(0.0, 0.5 * shapeSize.height());
        break;
    case KoPatternBackground::Center:
        offset += QPointF(0.5 * shapeSize.width(), 0.5 * shapeSize.height());
        break;
    case KoPatternBackground::Right:
        offset += QPointF(shapeSize.width(), 0.5 * shapeSize.height());
        break;
    case KoPatternBackground::BottomLeft:
        offset += QPointF(0.0, shapeSize.height());
        break;
    case KoPatternBackground::Bottom:
        offset += QPointF(0.5 * shapeSize.width(), shapeSize.height());
        break;
    case KoPatternBackground::BottomRight:
        offset += QPointF(shapeSize.width(), shapeSize.height());
        break;
    }
 
    offset = absoluteTransform.map(offset);
 
    context.styleWriter().startElement("pattern");
    context.styleWriter().addAttribute("id", uid);
    context.styleWriter().addAttribute("x", SvgUtil::toUserSpace(offset.x()));
    context.styleWriter().addAttribute("y", SvgUtil::toUserSpace(offset.y()));
 
    if (pattern->repeat() == KoPatternBackground::Stretched) {
        context.styleWriter().addAttribute("width", "100%");
        context.styleWriter().addAttribute("height", "100%");
        context.styleWriter().addAttribute("patternUnits", "objectBoundingBox");
    } else {
        context.styleWriter().addAttribute("width", SvgUtil::toUserSpace(patternSize.width()));
        context.styleWriter().addAttribute("height", SvgUtil::toUserSpace(patternSize.height()));
        context.styleWriter().addAttribute("patternUnits", "userSpaceOnUse");
    }
 
    context.styleWriter().addAttribute("viewBox", QString("0 0 %1 %2").arg(KisDomUtils::toString(imageSize.width())).arg(KisDomUtils::toString(imageSize.height())));
    //*m_defs << " patternContentUnits=\"userSpaceOnUse\"";
 
    context.styleWriter().startElement("image");
    context.styleWriter().addAttribute("x", "0");
    context.styleWriter().addAttribute("y", "0");
    context.styleWriter().addAttribute("width", QString("%1px").arg(KisDomUtils::toString(imageSize.width())));
    context.styleWriter().addAttribute("height", QString("%1px").arg(KisDomUtils::toString(imageSize.height())));
 
    QBuffer buffer;
    buffer.open(QIODevice::WriteOnly);
    if (pattern->pattern().save(&buffer, "PNG")) {
        const QString mimeType = KisMimeDatabase::mimeTypeForSuffix("*.png");
        context.styleWriter().addAttribute("xlink:href", "data:"+ mimeType + ";base64," + buffer.data().toBase64());
    }
 
    context.styleWriter().endElement(); // image
    context.styleWriter().endElement(); // pattern
 
    return uid;
}

References KoPatternBackground::Bottom, KoPatternBackground::BottomLeft, KoPatternBackground::BottomRight, KoPatternBackground::Center, SvgSavingContext::createUID(), KoPatternBackground::Left, KisMimeDatabase::mimeTypeForSuffix(), KoPatternBackground::Right, KoPatternBackground::Stretched, SvgSavingContext::styleWriter, KoPatternBackground::Top, KoPatternBackground::TopLeft, KoPatternBackground::TopRight, KisDomUtils::toString(), and SvgUtil::toUserSpace().

saveSvgStroke()

void SvgStyleWriter::saveSvgStroke ( KoShapeStrokeModelSP stroke, SvgSavingContext & context )

static

Saves stroke style of specified shape.

Definition at line 137 of file SvgStyleWriter.cpp.

{
    const QSharedPointer<KoShapeStroke> lineBorder = qSharedPointerDynamicCast<KoShapeStroke>(stroke);
 
    if (! lineBorder)
        return;
 
    QString strokeStr("none");
    if (lineBorder->lineBrush().gradient()) {
        QString gradientId = saveSvgGradient(lineBorder->lineBrush().gradient(), lineBorder->lineBrush().transform(), context);
        strokeStr = "url(#" + gradientId + ")";
    } else {
        if (lineBorder->color().isValid()) {
            strokeStr = lineBorder->color().name();
        }
        if (lineBorder->color().alphaF() < 1.0) {
            context.shapeWriter().addAttribute("stroke-opacity", lineBorder->color().alphaF());
        }
    }
    if (!strokeStr.isEmpty())
        context.shapeWriter().addAttribute("stroke", strokeStr);
 
    context.shapeWriter().addAttribute("stroke-width", SvgUtil::toUserSpace(lineBorder->lineWidth()));
 
    if (lineBorder->capStyle() == Qt::FlatCap)
        context.shapeWriter().addAttribute("stroke-linecap", "butt");
    else if (lineBorder->capStyle() == Qt::RoundCap)
        context.shapeWriter().addAttribute("stroke-linecap", "round");
    else if (lineBorder->capStyle() == Qt::SquareCap)
        context.shapeWriter().addAttribute("stroke-linecap", "square");
 
    if (lineBorder->joinStyle() == Qt::MiterJoin) {
        context.shapeWriter().addAttribute("stroke-linejoin", "miter");
        context.shapeWriter().addAttribute("stroke-miterlimit", lineBorder->miterLimit());
    } else if (lineBorder->joinStyle() == Qt::RoundJoin)
        context.shapeWriter().addAttribute("stroke-linejoin", "round");
    else if (lineBorder->joinStyle() == Qt::BevelJoin)
        context.shapeWriter().addAttribute("stroke-linejoin", "bevel");
 
    // dash
    if (lineBorder->lineStyle() > Qt::SolidLine) {
        qreal dashFactor = lineBorder->lineWidth();
 
        if (lineBorder->dashOffset() != 0)
            context.shapeWriter().addAttribute("stroke-dashoffset", dashFactor * lineBorder->dashOffset());
 
        QString dashStr;
        const QVector<qreal> dashes = lineBorder->lineDashes();
        int dashCount = dashes.size();
        for (int i = 0; i < dashCount; ++i) {
            if (i > 0)
                dashStr += ",";
            dashStr += QString("%1").arg(KisDomUtils::toString(dashes[i] * dashFactor));
        }
        context.shapeWriter().addAttribute("stroke-dasharray", dashStr);
    }
}

References saveSvgGradient(), SvgSavingContext::shapeWriter, KisDomUtils::toString(), and SvgUtil::toUserSpace().

saveSvgStyle()

void SvgStyleWriter::saveSvgStyle ( KoShape * shape, SvgSavingContext & context )

static

Saves the style of the specified shape.

Definition at line 52 of file SvgStyleWriter.cpp.

{
    saveSvgBasicStyle(shape->isVisible(false), shape->transparency(false), shape->paintOrder(), shape->inheritPaintOrder(), context);
 
    KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
    bool fillRule = pathShape && pathShape->background() && pathShape->fillRule() == Qt::OddEvenFill? true: false;
    if (!shape->inheritBackground()) {
        saveSvgFill(shape->background(), fillRule, shape->outlineRect(), shape->size(), shape->absoluteTransformation(), context);
    }
    if (!shape->inheritStroke()) {
        saveSvgStroke(shape->stroke(), context);
    }
 
    saveSvgClipping(shape, context);
    saveSvgMasking(shape, context);
    saveSvgMarkers(shape, context);
}

References KoShape::absoluteTransformation(), KoShape::background(), KoPathShape::fillRule(), KoShape::inheritBackground(), KoShape::inheritPaintOrder(), KoShape::inheritStroke(), KoShape::isVisible(), KoShape::outlineRect(), KoShape::paintOrder(), saveSvgBasicStyle(), saveSvgClipping(), saveSvgFill(), saveSvgMarkers(), saveSvgMasking(), saveSvgStroke(), KoShape::size(), KoShape::stroke(), and KoShape::transparency().

saveSvgVectorPattern()

QString SvgStyleWriter::saveSvgVectorPattern ( QSharedPointer< KoVectorPatternBackground > pattern, const QRectF outlineRect, SvgSavingContext & context )

staticprotected

Definition at line 610 of file SvgStyleWriter.cpp.

{
    const QString uid = context.createUID("pattern");
 
    context.styleWriter().startElement("pattern");
    context.styleWriter().addAttribute("id", uid);
 
    context.styleWriter().addAttribute("patternUnits", KoFlake::coordinateToString(pattern->referenceCoordinates()));
    context.styleWriter().addAttribute("patternContentUnits", KoFlake::coordinateToString(pattern->contentCoordinates()));
 
    const QRectF rect = pattern->referenceRect();
 
    context.styleWriter().addAttribute("x", rect.x());
    context.styleWriter().addAttribute("y", rect.y());
    context.styleWriter().addAttribute("width", rect.width());
    context.styleWriter().addAttribute("height", rect.height());
 
    SvgUtil::writeTransformAttributeLazy("patternTransform", pattern->patternTransform(), context.styleWriter());
 
    if (pattern->contentCoordinates() == KoFlake::ObjectBoundingBox) {
        // TODO: move this normalization into the KoVectorPatternBackground itself
 
        QList<KoShape*> shapes = pattern->shapes();
        QList<KoShape*> clonedShapes;
 
        const QTransform relativeToShape = KisAlgebra2D::mapToRect(outlineRect);
        const QTransform shapeToRelative = relativeToShape.inverted();
 
        Q_FOREACH (KoShape *shape, shapes) {
            KoShape *clone = shape->cloneShape();
            clone->applyAbsoluteTransformation(shapeToRelative);
            clonedShapes.append(clone);
        }
 
        embedShapes(clonedShapes, context.styleWriter());
        qDeleteAll(clonedShapes);
 
    } else {
        QList<KoShape*> shapes = pattern->shapes();
        embedShapes(shapes, context.styleWriter());
    }
 
    context.styleWriter().endElement(); // pattern
 
    return uid;
}

References KoShape::applyAbsoluteTransformation(), KoShape::cloneShape(), KoFlake::coordinateToString(), SvgSavingContext::createUID(), embedShapes(), KisAlgebra2D::mapToRect(), KoFlake::ObjectBoundingBox, SvgSavingContext::styleWriter, and SvgUtil::writeTransformAttributeLazy().

---

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

• libs/flake/svg/SvgStyleWriter.h
• libs/flake/svg/SvgStyleWriter.cpp