KoSvgTextContentElement Struct Reference

The KoSvgTextContentElement struct. More...

#include <KoSvgTextContentElement.h>

Public Member Functions
QString	getTransformedString (QVector< QPair< int, int > > &positions, KoSvgTextProperties resolvedProps=KoSvgTextProperties()) const
void	insertText (int start, QString insertText)
	insertText
	KoSvgTextContentElement ()
	KoSvgTextContentElement (const KoSvgTextContentElement &rhs)
bool	loadSvg (const QDomElement &element, SvgLoadingContext &context, bool rootNode=false)
	loadSvg load SVG style data into the current content element.
bool	loadSvgTextNode (const QDomText &text, SvgLoadingContext &context)
int	numChars (bool withControls=false, KoSvgTextProperties resolvedProps=KoSvgTextProperties()) const
void	removeText (int &start, int length)
	removeText removes text,
bool	saveSvg (SvgSavingContext &context, bool rootText, bool saveText, QMap< QString, QString > shapeSpecificAttributes)
	~KoSvgTextContentElement ()=default

Public Attributes
QPainterPath	associatedOutline
	The associated outline. Currently only a bounding box.
int	finalResultIndex = -1
KoSvgText::LengthAdjust	lengthAdjust = KoSvgText::LengthAdjustSpacing
	the value 'lengthAdjust' attribute of the associated dom element
QVector< KoSvgText::CharTransformation >	localTransformations
	Local SVG char transforms.
KoSvgTextProperties	properties
	The textProperties. This includes.
QString	text
	Plain text of the current node. Use insertText and removeText to manipulate it.
QMap< KoSvgText::TextDecoration, QPainterPath >	textDecorations
	Cached text decorations to be used by the painting function.
KoSvgText::AutoValue	textLength
	the value 'textLength' attribute of the associated dom element
QScopedPointer< KoShape >	textPath {nullptr}
	The textpath, if any. Defaults to null.
KoSvgText::TextOnPathInfo	textPathInfo
	Text path info for the text-on-path algorithm.

Detailed Description

The KoSvgTextContentElement struct.

Replacing KoSvgTextChunkShape, KoSvgTextContentElement represents a formatted span of text. This can be a SVG <text >, <tspan > or <textPath > node. This struct is used to represent the internal data of KoSvgTextShape.

Definition at line 27 of file KoSvgTextContentElement.h.

Constructor & Destructor Documentation

KoSvgTextContentElement() [1/2]

KoSvgTextContentElement::KoSvgTextContentElement

(

)

Definition at line 20 of file KoSvgTextContentElement.cpp.

{
 
}

KoSvgTextContentElement() [2/2]

KoSvgTextContentElement::KoSvgTextContentElement ( const KoSvgTextContentElement & rhs )

inline

Definition at line 31 of file KoSvgTextContentElement.h.

        : properties(rhs.properties)
        , localTransformations(rhs.localTransformations)
        , textPathInfo(rhs.textPathInfo)
        , textLength(rhs.textLength)
        , lengthAdjust(rhs.lengthAdjust)
        , textDecorations(rhs.textDecorations)
        , text(rhs.text)
        , finalResultIndex(rhs.finalResultIndex)
        , associatedOutline(rhs.associatedOutline)
    {
        if (rhs.textPath) {
        textPath.reset(rhs.textPath.data()->cloneShape());
        }
    }

References textPath.

~KoSvgTextContentElement()

KoSvgTextContentElement::~KoSvgTextContentElement ( )

default

Member Function Documentation

getTransformedString()

QString KoSvgTextContentElement::getTransformedString	(	QVector< QPair< int, int > > &	positions,
		KoSvgTextProperties	resolvedProps = KoSvgTextProperties() ) const

Get the text with transformations applied.

Parameters

positions

the text positions which may have changed due the uppercase transform.

Definition at line 435 of file KoSvgTextContentElement.cpp.

{
    KoSvgText::TextTransformInfo textTransformInfo =
        resolvedProps.propertyOrDefault(KoSvgTextProperties::TextTransformId).value<KoSvgText::TextTransformInfo>();
    QString lang = resolvedProps.property(KoSvgTextProperties::TextLanguage).toString().toUtf8();
    return transformText(text, textTransformInfo, lang, positions);
}

References KoSvgTextProperties::property(), KoSvgTextProperties::propertyOrDefault(), text, KoSvgTextProperties::TextLanguage, KoSvgTextProperties::TextTransformId, and transformText().

insertText()

void KoSvgTextContentElement::insertText	(	int	start,
		QString	insertText )

insertText

Parameters

start	– start index.
insertText	– text to insert.

Definition at line 425 of file KoSvgTextContentElement.cpp.

{
    if (start >= text.size()) {
        text.append(insertText);
    } else {
        text.insert(start, insertText);
    }
}

References insertText(), and text.

loadSvg()

bool KoSvgTextContentElement::loadSvg	(	const QDomElement &	element,
		SvgLoadingContext &	context,
		bool	rootNode = false )

loadSvg load SVG style data into the current content element.

Parameters

element	– xml element to load the data from.
context	– loading context.
rootNode	– whether this content element is a <text > node. During text layout, text properties are inherited dynamically. However, we can only start at the root text node, while SVG can have properties that are set on the document root and inherit. Therefore, when loading we inherit and resolve those properties dynamically for the root node only.

Returns

whether successful.

Definition at line 163 of file KoSvgTextContentElement.cpp.

{
    SvgGraphicsContext *gc = context.currentGC();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(gc, false);
 
    KoSvgTextProperties props = rootNode? context.resolvedProperties(): gc->textProperties;
 
 
    QVector<KoSvgTextProperties::PropertyId> generic = {KoSvgTextProperties::FillId,
                                                        KoSvgTextProperties::StrokeId,
                                                        KoSvgTextProperties::PaintOrder,
                                                        KoSvgTextProperties::Opacity,
                                                        KoSvgTextProperties::Visiblity};
    for (int i = 0; i < generic.size(); i++) {
        auto id = generic[i];
        if (properties.hasProperty(id)) {
            props.setProperty(id, properties.property(id));
        }
    }
    properties = props;
 
    textLength = KoSvgText::parseAutoValueXY(e.attribute("textLength", ""), context, "");
    lengthAdjust = KoSvgText::parseLengthAdjust(e.attribute("lengthAdjust", "spacing"));
 
    QVector<qreal> xPos = parseListAttributeX(e.attribute("x", ""), context);
    QVector<qreal> yPos = parseListAttributeY(e.attribute("y", ""), context);
    QVector<qreal> dxPos = parseListAttributeX(e.attribute("dx", ""), context);
    QVector<qreal> dyPos = parseListAttributeY(e.attribute("dy", ""), context);
    QVector<qreal> rotate = parseListAttributeAngular(e.attribute("rotate", ""), context);
 
    const int numLocalTransformations =
        std::max({xPos.size(), yPos.size(),
                  dxPos.size(), dyPos.size(),
                  rotate.size()});
 
    localTransformations.resize(numLocalTransformations);
    for (int i = 0; i < numLocalTransformations; i++) {
        if (i < xPos.size()) {
            localTransformations[i].xPos = xPos[i];
        }
        if (i < yPos.size()) {
            localTransformations[i].yPos = yPos[i];
        }
        if (i < dxPos.size() && dxPos[i] != 0.0) {
            localTransformations[i].dxPos = dxPos[i];
        }
        if (i < dyPos.size() && dyPos[i] != 0.0) {
            localTransformations[i].dyPos = dyPos[i];
        }
        if (i < rotate.size()) {
            localTransformations[i].rotate = rotate[i];
        }
    }
 
    if (e.tagName() == "textPath") {
        // we'll read the value 'path' later.
 
        textPathInfo.side = KoSvgText::parseTextPathSide(e.attribute("side", "left"));
        textPathInfo.method = KoSvgText::parseTextPathMethod(e.attribute("method", "align"));
        textPathInfo.spacing = KoSvgText::parseTextPathSpacing(e.attribute("spacing", "auto"));
        // This depends on pathLength;
        if (e.hasAttribute("startOffset")) {
            QString offset = e.attribute("startOffset", "0");
            if (offset.endsWith("%")) {
                textPathInfo.startOffset = SvgUtil::parseNumber(offset.left(offset.size() - 1));
                textPathInfo.startOffsetIsPercentage = true;
            } else {
                textPathInfo.startOffset = SvgUtil::parseUnit(context.currentGC(), context.resolvedProperties(), offset);
            }
        }
    }
 
    if (e.hasAttribute(TEXT_STYLE_TYPE.toLatin1().data())) {
        properties.setProperty(KoSvgTextProperties::KraTextStyleType, e.attribute(TEXT_STYLE_TYPE.toLatin1().data()));
        if (e.hasAttribute(TEXT_STYLE_RES.toLatin1().data())) {
            QString resolution = e.attribute(TEXT_STYLE_RES.toLatin1().data()).toLower();
            if (resolution.endsWith("dpi")) {
                resolution.chop(3);
            }
            properties.setProperty(KoSvgTextProperties::KraTextStyleResolution, KisDomUtils::toInt(resolution));
        }
    }
 
    return true;
}

References SvgLoadingContext::currentGC(), KoSvgTextProperties::FillId, KoSvgTextProperties::hasProperty(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KoSvgTextProperties::KraTextStyleResolution, KoSvgTextProperties::KraTextStyleType, lengthAdjust, localTransformations, KoSvgText::TextOnPathInfo::method, KoSvgTextProperties::Opacity, KoSvgTextProperties::PaintOrder, KoSvgText::parseAutoValueXY(), KoSvgText::parseLengthAdjust(), SvgUtil::parseNumber(), KoSvgText::parseTextPathMethod(), KoSvgText::parseTextPathSide(), KoSvgText::parseTextPathSpacing(), SvgUtil::parseUnit(), properties, KoSvgTextProperties::property(), SvgLoadingContext::resolvedProperties(), KoSvgTextProperties::setProperty(), KoSvgText::TextOnPathInfo::side, KoSvgText::TextOnPathInfo::spacing, KoSvgText::TextOnPathInfo::startOffset, KoSvgText::TextOnPathInfo::startOffsetIsPercentage, KoSvgTextProperties::StrokeId, TEXT_STYLE_RES, TEXT_STYLE_TYPE, textLength, textPathInfo, SvgGraphicsContext::textProperties, KisDomUtils::toInt(), and KoSvgTextProperties::Visiblity.

loadSvgTextNode()

bool KoSvgTextContentElement::loadSvgTextNode	(	const QDomText &	text,
		SvgLoadingContext &	context )

Definition at line 249 of file KoSvgTextContentElement.cpp.

{
    SvgGraphicsContext *gc = context.currentGC();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(gc, false);
 
    // In theory, the XML spec requires XML parsers to normalize line endings to
    // LF. However, QXmlInputSource + QXmlSimpleReader do not do this, so we can
    // end up with CR in the text. The SVG spec explicitly calls out that all
    // newlines in SVG are to be represented by a single LF (U+000A) character,
    // so we can replace all CRLF and CR into LF here for simplicity.
    static const QRegularExpression s_regexCrlf(R"==((?:\r\n|\r(?!\n)))==");
    QString content = text.data();
    content.replace(s_regexCrlf, QStringLiteral("\n"));
 
    this->text = std::move(content);
 
    return true;
}

References SvgLoadingContext::currentGC(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and text.

numChars()

int KoSvgTextContentElement::numChars	(	bool	withControls = false,
		KoSvgTextProperties	resolvedProps = KoSvgTextProperties() ) const

The number of characters contained in the currentChunk.

Parameters

withControls

this will enable the bidi controls to be counted as well.

Definition at line 405 of file KoSvgTextContentElement.cpp.

{
    int result = 0;
    if (withControls) {
        KoSvgText::UnicodeBidi bidi = KoSvgText::UnicodeBidi(resolvedProps.propertyOrDefault(KoSvgTextProperties::UnicodeBidiId).toInt());
        KoSvgText::Direction direction = KoSvgText::Direction(resolvedProps.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
        KoSvgText::TextTransformInfo textTransformInfo =
            resolvedProps.propertyOrDefault(KoSvgTextProperties::TextTransformId).value<KoSvgText::TextTransformInfo>();
        QString lang = resolvedProps.property(KoSvgTextProperties::TextLanguage).toString().toUtf8();
        QVector<QPair<int, int>> positions;
 
        result = KoCssTextUtils::getBidiOpening(direction == KoSvgText::DirectionLeftToRight, bidi).size();
        result += transformText(text, textTransformInfo, lang, positions).size();
        result += KoCssTextUtils::getBidiClosing(bidi).size();
    } else {
        result = text.size();
    }
    return result;
}

References KoSvgTextProperties::DirectionId, KoSvgText::DirectionLeftToRight, KoCssTextUtils::getBidiClosing(), KoCssTextUtils::getBidiOpening(), KoSvgTextProperties::property(), KoSvgTextProperties::propertyOrDefault(), text, KoSvgTextProperties::TextLanguage, KoSvgTextProperties::TextTransformId, transformText(), and KoSvgTextProperties::UnicodeBidiId.

removeText()

void KoSvgTextContentElement::removeText	(	int &	start,
		int	length )

removeText removes text,

See also

KoSvgTextShape::removeText and CssUtils::removeText

Parameters

start	– start index, may be modified.
length	– length of text to remove.

Definition at line 443 of file KoSvgTextContentElement.cpp.

{
    KoCssTextUtils::removeText(text, start, length);
}

References length(), KoCssTextUtils::removeText(), and text.

saveSvg()

bool KoSvgTextContentElement::saveSvg	(	SvgSavingContext &	context,
		bool	rootText,
		bool	saveText,
		QMap< QString, QString >	shapeSpecificAttributes )

Definition at line 268 of file KoSvgTextContentElement.cpp.

{
    if (textPath) {
        if (textPath) {
            // we'll always save as an embedded shape as "path" is an svg 2.0
            // feature.
            QString id = SvgStyleWriter::embedShape(textPath.data(), context);
            // inkscape can only read 'xlink:href'
            if (!id.isEmpty()) {
                context.shapeWriter().addAttribute("xlink:href", "#" + id);
            }
        }
        if (textPathInfo.startOffset != 0) {
            QString offset = KisDomUtils::toString(textPathInfo.startOffset);
            if (textPathInfo.startOffsetIsPercentage) {
                offset += "%";
            }
            context.shapeWriter().addAttribute("startOffset", offset);
        }
        if (textPathInfo.method != KoSvgText::TextPathAlign) {
            context.shapeWriter().addAttribute("method", KoSvgText::writeTextPathMethod(textPathInfo.method));
        }
        if (textPathInfo.side != KoSvgText::TextPathSideLeft) {
            context.shapeWriter().addAttribute("side", KoSvgText::writeTextPathSide(textPathInfo.side));
        }
        if (textPathInfo.spacing != KoSvgText::TextPathAuto) {
            context.shapeWriter().addAttribute("spacing", KoSvgText::writeTextPathSpacing(textPathInfo.spacing));
        }
    }
 
    if (!localTransformations.isEmpty()) {
 
        QVector<qreal> xPos;
        QVector<qreal> yPos;
        QVector<qreal> dxPos;
        QVector<qreal> dyPos;
        QVector<qreal> rotate;
 
        fillTransforms(&xPos, &yPos, &dxPos, &dyPos, &rotate, localTransformations);
 
        for (int i = 0; i < rotate.size(); i++) {
            rotate[i] = kisRadiansToDegrees(rotate[i]);
        }
 
        writeTextListAttribute("x", xPos, context.shapeWriter());
        writeTextListAttribute("y", yPos, context.shapeWriter());
        writeTextListAttribute("dx", dxPos, context.shapeWriter());
        writeTextListAttribute("dy", dyPos, context.shapeWriter());
        writeTextListAttribute("rotate", rotate, context.shapeWriter());
    }
 
    if (!textLength.isAuto) {
        context.shapeWriter().addAttribute("textLength", KisDomUtils::toString(textLength.customValue));
 
        if (lengthAdjust == KoSvgText::LengthAdjustSpacingAndGlyphs) {
            context.shapeWriter().addAttribute("lengthAdjust", "spacingAndGlyphs");
        }
    }
 
    KoSvgTextProperties ownProperties = rootText? properties.ownProperties(KoSvgTextProperties::defaultProperties(), true): properties;
 
    ownProperties = adjustPropertiesForFontSizeWorkaround(ownProperties);
 
    // we write down stroke/fill if they are different from the parent's value
    if (!rootText) {
        if (ownProperties.hasProperty(KoSvgTextProperties::FillId)) {
            SvgStyleWriter::saveSvgFill(properties.background(),
                                        false,
                                        this->associatedOutline.boundingRect(),
                                        associatedOutline.boundingRect().size(),
                                        QTransform(),
                                        context);
        }
 
        if (ownProperties.hasProperty(KoSvgTextProperties::StrokeId)) {
            SvgStyleWriter::saveSvgStroke(properties.stroke(), context);
        }
    }
 
    QMap<QString, QString> attributes = ownProperties.convertToSvgTextAttributes();
    QStringList allowedAttributes = properties.supportedXmlAttributes();
    QString styleString;
 
    for (auto it = shapeSpecificAttributes.constBegin(); it != shapeSpecificAttributes.constEnd(); ++it) {
        styleString.append(it.key().toLatin1().data()).append(": ").append(it.value()).append(";");
    }
    for (auto it = attributes.constBegin(); it != attributes.constEnd(); ++it) {
        if (allowedAttributes.contains(it.key())) {
            context.shapeWriter().addAttribute(it.key().toLatin1().data(), it.value());
        } else {
            styleString.append(it.key().toLatin1().data()).append(": ").append(it.value()).append(";");
        }
    }
    if (!styleString.isEmpty()) {
        context.shapeWriter().addAttribute("style", styleString);
    }
 
    if (properties.hasProperty(KoSvgTextProperties::KraTextStyleType)) {
        context.shapeWriter().addAttribute(TEXT_STYLE_TYPE.toLatin1().data(), properties.property(KoSvgTextProperties::KraTextStyleType).toString());
        if (properties.hasProperty(KoSvgTextProperties::KraTextStyleResolution)) {
            context.shapeWriter().addAttribute(TEXT_STYLE_RES.toLatin1().data(), QString::number(properties.property(KoSvgTextProperties::KraTextStyleResolution).toInt())+"dpi");
        }
    }
 
    if (saveText) {
        context.shapeWriter().addTextNode(text);
    }
    return true;
}

References associatedOutline, KoSvgTextProperties::background(), KoSvgTextProperties::convertToSvgTextAttributes(), KoSvgText::AutoValue::customValue, KoSvgTextProperties::defaultProperties(), SvgStyleWriter::embedShape(), KoSvgTextProperties::FillId, KoSvgTextProperties::hasProperty(), KoSvgText::AutoValue::isAuto, kisRadiansToDegrees(), KoSvgTextProperties::KraTextStyleResolution, KoSvgTextProperties::KraTextStyleType, lengthAdjust, KoSvgText::LengthAdjustSpacingAndGlyphs, localTransformations, KoSvgText::TextOnPathInfo::method, KoSvgTextProperties::ownProperties(), properties, KoSvgTextProperties::property(), SvgStyleWriter::saveSvgFill(), SvgStyleWriter::saveSvgStroke(), SvgSavingContext::shapeWriter, KoSvgText::TextOnPathInfo::side, KoSvgText::TextOnPathInfo::spacing, KoSvgText::TextOnPathInfo::startOffset, KoSvgText::TextOnPathInfo::startOffsetIsPercentage, KoSvgTextProperties::stroke(), KoSvgTextProperties::StrokeId, KoSvgTextProperties::supportedXmlAttributes(), text, TEXT_STYLE_RES, TEXT_STYLE_TYPE, textLength, textPath, KoSvgText::TextPathAlign, KoSvgText::TextPathAuto, textPathInfo, KoSvgText::TextPathSideLeft, KisDomUtils::toString(), KoSvgText::writeTextPathMethod(), KoSvgText::writeTextPathSide(), and KoSvgText::writeTextPathSpacing().

Member Data Documentation

associatedOutline

QPainterPath KoSvgTextContentElement::associatedOutline

The associated outline. Currently only a bounding box.

Definition at line 78 of file KoSvgTextContentElement.h.

finalResultIndex

int KoSvgTextContentElement::finalResultIndex = -1

Set during layout, finalResultIndex determines the size of the iterator on result after going over this contentElement. Once layout has been set this is less fiddly than using numChars which requires resolving properties.

Definition at line 75 of file KoSvgTextContentElement.h.

lengthAdjust

KoSvgText::LengthAdjust KoSvgTextContentElement::lengthAdjust = KoSvgText::LengthAdjustSpacing

the value 'lengthAdjust' attribute of the associated dom element

Definition at line 64 of file KoSvgTextContentElement.h.

localTransformations

QVector<KoSvgText::CharTransformation> KoSvgTextContentElement::localTransformations

Local SVG char transforms.

Definition at line 53 of file KoSvgTextContentElement.h.

properties

KoSvgTextProperties KoSvgTextContentElement::properties

The textProperties. This includes.

Definition at line 50 of file KoSvgTextContentElement.h.

text

QString KoSvgTextContentElement::text

Plain text of the current node. Use insertText and removeText to manipulate it.

Definition at line 70 of file KoSvgTextContentElement.h.

textDecorations

QMap<KoSvgText::TextDecoration, QPainterPath> KoSvgTextContentElement::textDecorations

Cached text decorations to be used by the painting function.

Definition at line 67 of file KoSvgTextContentElement.h.

textLength

KoSvgText::AutoValue KoSvgTextContentElement::textLength

the value 'textLength' attribute of the associated dom element

Definition at line 62 of file KoSvgTextContentElement.h.

textPath

QScopedPointer<KoShape> KoSvgTextContentElement::textPath {nullptr}

The textpath, if any. Defaults to null.

Definition at line 59 of file KoSvgTextContentElement.h.

{nullptr};

textPathInfo

KoSvgText::TextOnPathInfo KoSvgTextContentElement::textPathInfo

Text path info for the text-on-path algorithm.

Definition at line 56 of file KoSvgTextContentElement.h.

---

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

• libs/flake/text/KoSvgTextContentElement.h
• libs/flake/text/KoSvgTextContentElement.cpp