#include <KoSvgTextShape.h>

Inheritance diagram for KoSvgTextShape:

Classes
struct	BulkActionState

struct	TextCursorChangeListener
	ShapeChangeListener so we can inform any text cursors that the cursor needs updating. More...

Public Types
enum class	DebugElement { CharBbox = 1 << 0 , LineBox = 1 << 1 }

enum	InternalShapeState { Decorative , ShapeInside , ShapeSubtract , TextPath }

enum	TextType { PrePositionedText = 0 , PreformattedText , InlineWrap , TextInShape }

Public Types inherited from KoShape
enum	ChangeType { PositionChanged , RotationChanged , ScaleChanged , ShearChanged , SizeChanged , GenericMatrixChange , KeepAspectRatioChange , ParentChanged , Deleted , StrokeChanged , BackgroundChanged , BorderChanged , ParameterChanged , ContentChanged , TextContourMarginChanged , ChildChanged , ConnectionPointChanged , ClipPathChanged , ClipMaskChanged , TransparencyChanged }
	Used by shapeChanged() to select which change was made. More...

enum	ChildZOrderPolicy { ChildZDefault , ChildZParentChild = ChildZDefault , ChildZPassThrough }
	Used by compareShapeZIndex() to order shapes. More...

enum	PaintOrder { Fill , Stroke , Markers }

Public Member Functions
void	addShapeContours (QList< KoShape * > shapes, const bool inside=true)
	addShapesContours Add shapes to the contours that make up the wrapping area.

void	addTextPathAtEnd (KoShape *textPath)
	addTextPathAtEnd add a textpath node at the end of the text.

void	applyTextLength (KisForest< KoSvgTextContentElement >::child_iterator currentTextElement, QVector< CharacterResult > &result, int &currentIndex, int &resolvedDescendentNodes, bool isHorizontal, const KoSvgTextProperties resolvedProps, const KoSvgText::ResolutionHandler &resHandler)

void	applyWhiteSpace (KisForest< KoSvgTextContentElement > &tree, const bool convertToPreWrapped=false)
	applyWhiteSpace CSS Whitespace processes whitespaces so that duplicate white spaces and unnecessary hard breaks get removed from the text. Within the text layout we avoid removing the white spaces. However, when converting between text types it can be useful to remove these spaces. This function actually applies the white space rule to the active text.

void	applyWhiteSpaceImpl (std::reverse_iterator< KisForest< KoSvgTextContentElement >::child_iterator > current, QVector< bool > &collapsed, QString &allText, const bool convertToPreWrapped)

QSharedPointer< KoShapeBackground >	background () const override

QRectF	boundingRect () const override
	Get the bounding box of the shape.

void	cleanUp ()
	Cleans up the internal text data. Used by undo commands.

void	clearAssociatedOutlines ()

KoShape *	cloneShape () const override
	creates a deep copy of the shape or shape's subtree

KoShape *	collectPaths (const KoSvgTextShape *rootShape, QVector< CharacterResult > &result, int &currentIndex)

void	computeTextDecorations (KisForest< KoSvgTextContentElement >::child_iterator currentTextElement, const QVector< CharacterResult > &result, const QMap< int, int > &logicalToVisual, const KoSvgText::ResolutionHandler resHandler, KoPathShape textPath, qreal textPathoffset, bool side, int &currentIndex, bool isHorizontal, bool ltr, bool wrapping, const KoSvgTextProperties resolvedProps, QList< KoShape > textPaths)

void	convertCharTransformsToPreformatted (bool makeInlineSize=false)
	convertCharTransformsToPreformatted Converts the text to a preformatted SVG 2.0 text. This changes the textType();

std::unique_ptr< KoSvgTextShape >	copyRange (int index, int length) const
	copyRange Copy the rich text for the given range.

KoSvgTextNodeIndex	createTextNodeIndex (KisForest< KoSvgTextContentElement >::child_iterator textElement) const

QPainterPath	cursorForPos (int pos, QLineF &caret, QColor &color, double bidiFlagSize=1.0)
	cursorForPos returns the QPainterPath associated with this cursorPosition.

void	debugParsing ()
	Outputs debug with the current textData tree.

KoSvgText::Direction	direction () const
	direction Whether the text is left to right or right to left.

QRectF	endBulkAction () override

void	enterNodeSubtree ()
	Set the current node to its first child, entering the subtree.

KoSvgTextNodeIndex	findNodeIndexForPropertyId (KoSvgTextProperties::PropertyId propertyId)
	findNodeIndexForPropertyId

QPair< int, int >	findRangeForNodeIndex (const KoSvgTextNodeIndex &node) const
	findRangeForNodeIndex Find the start and end cursor position for a given nodeIndex.

bool	fontMatchingDisabled () const
	fontMatchingDisabled

QMap< KoSvgText::TextDecoration, QPainterPath >	generateDecorationPaths (const int &start, const int &end, const KoSvgText::ResolutionHandler resHandler, const QVector< CharacterResult > &result, const bool isHorizontal, const KoSvgText::TextDecorations &decor, const KoSvgText::TextDecorationStyle style=KoSvgText::TextDecorationStyle::Solid, const bool textDecorationSkipInset=false, const KoPathShape *currentTextPath=nullptr, const qreal currentTextPathOffset=0.0, const bool textPathSide=false, const KoSvgText::TextDecorationUnderlinePosition underlinePosH=KoSvgText::TextDecorationUnderlinePosition::UnderlineAuto, const KoSvgText::TextDecorationUnderlinePosition underlinePosV=KoSvgText::TextDecorationUnderlinePosition::UnderlineAuto)

CursorPos	getCursorPos (int pos)

KoSvgTextShapeMementoSP	getMemento ()
	Get a memento holding the current textdata and layout info.

QList< KoSvgTextCharacterInfo >	getPositionsAndRotationsForRange (const int startPos, const int endPos) const
	getPositionsAndRotationsForRange

void	handleShapes (const QList< KoShape * > &sourceShapeList, const QList< KoShape * > referenceList2, const QList< KoShape * > referenceShapeList, QList< KoShape * > &destinationShapeList)

int	indexForPos (int pos) const
	indexForPos get the string index for a given cursor position.

QPointF	initialTextPosition () const
	initialTextPosition Returns the initial text position as per SVG algorithm. The eventual result of this can include transforms or repositioning due to text shapes.

bool	insertRichText (int pos, const KoSvgTextShape *richText, bool inheritPropertiesIfPossible=false)
	insertRichText Insert rich text at the given cursor pos. This will first split contents at the given pos before inserting the new rich text.

bool	insertText (int pos, QString text)
	insertText Insert a text somewhere in the KoTextShape.

KoShapeManager *	internalShapeManager () const
	internalShapeManager

QList< KoShape * >	internalShapes () const

	KoSvgTextShape ()

	KoSvgTextShape (const KoSvgTextShape &rhs)

void	leaveNodeSubtree ()
	Set the current node to its parent, leaving the subtree.

int	lineEnd (int pos)
	lineEnd return the 'line end' for this pos. This uses anchored chunks, so each absolute x, y posititioning will be considered a line-start.

int	lineStart (int pos)
	lineStart return the 'line start' for this pos. This uses anchored chunks, so each absolute x, y posititioning will be considered a line-start.

void	mergePropertiesIntoRange (const int startPos, const int endPos, const KoSvgTextProperties properties, const QSet< KoSvgTextProperties::PropertyId > removeProperties=QSet< KoSvgTextProperties::PropertyId >())
	mergePropertiesIntoRange Merge given properties into the given range. This will first split the nodes at the two range ends, and then merge in the properties into each leaf node. Won't do anything when startPos == endPos

void	moveShapeInsideToIndex (KoShape *shapeInside, const int index)
	moveShapeInsideToIndex Because the order of shapes inside shape-inside affects the text layout, it can be useful to be able to reorder them.

int	nextIndex (int pos)
	nextIndex Return the first cursor position with a higher string index.

int	nextLine (int pos)
	nextLine get a position on the next line for this position.

KoSvgTextNodeIndex	nodeForTextPath (KoShape *textPath) const
	nodeForTextPath TextPaths are set on toplevel content elements. This function allows for searching which node has said textPath, which should be less clunky than running topLevelNodeForPos for every pos.

void	notifyCursorPosChanged (int pos, int anchor)
	Notify that the cursor position has changed.

void	notifyMarkupChanged ()
	Notify that the markup has changed.

QPainterPath	outline () const override

QRectF	outlineRect () const override

void	paint (QPainter &painter) const override
	Paint the shape fill The class extending this one is responsible for painting itself. `painter` is expected to be preconfigured to work in "document" pixels.

void	paintDebug (QPainter &painter, const QVector< CharacterResult > &result, int &currentIndex)

void	paintDebug (QPainter &painter, DebugElements elements) const

QVector< PaintOrder >	paintOrder () const override
	paintOrder

void	paintPaths (QPainter &painter, const QPainterPath &outlineRect, const KoShape *rootShape, const QVector< CharacterResult > &result, const KoSvgText::TextRendering rendering, QPainterPath &chunk, int &currentIndex)

void	paintStroke (QPainter &painter) const override
	paintStroke paints the shape's stroked outline

void	paintTextDecoration (QPainter &painter, const QPainterPath &outlineRect, const KoShape *rootShape, const KoSvgText::TextDecoration type, const KoSvgText::TextRendering rendering)

QString	plainText ()
	plainText plain text of all text inside this text shape, without the bidi controls or any transforms.

int	posDown (int pos, bool visual=false)
	return position below.

int	posForIndex (int index, bool firstIndex=false, bool skipSynthetic=false) const
	posForIndex Get the cursor position for a given index in a string.

int	posForPoint (QPointF point, int start=-1, int end=-1, bool *overlaps=nullptr)
	posForPoint Finds the closest cursor position for the given point in shape coordinates.

int	posForPointLineSensitive (QPointF point)
	posForPointLineSensitive When clicking on an empty space in a wrapped text, it is preferable to have the caret be at the end of the line visually associated with that empty space than the positions above or below that might be closer.

int	posLeft (int pos, bool visual=false)

int	posRight (int pos, bool visual=false)

int	posUp (int pos, bool visual=false)
	return position above.

int	previousIndex (int pos)
	previousIndex Return the first pos which has a lower string index.

int	previousLine (int pos)
	previousLine get a position on the previous line for this position.

	Private ()

	Private (const Private &rhs)

KoSvgTextProperties	propertiesForPos (const int pos, bool inherited=false) const
	Return the properties at a given position.

QList< KoSvgTextProperties >	propertiesForRange (const int startPos, const int endPos, bool inherited=false) const
	propertiesForRange get the properties for a range.

	Q_DECLARE_FLAGS (DebugElements, DebugElement)

void	relayout ()

void	relayout () const

bool	relayoutIsBlocked () const
	relayoutIsBlocked

void	removeShapesFromContours (QList< KoShape * > shapes, bool callUpdate=true, bool cleanup=true)
	removeShapesFromContours Remove list of shapes from any of the internal lists.

bool	removeText (int &index, int &length)
	removeText Where insert text explicitly uses a cursorposition, remove text uses a string index. It will modify these values so that...

void	removeTransformsFromRange (const int startPos, const int endPos)

bool	saveHtml (HtmlSavingContext &context)

bool	saveSvg (SvgSavingContext &context) override
	Saves SVG data.

QPainterPath	selectionBoxes (int pos, int anchor)
	selectionBoxes returns all selection boxes for a given range. Range will be normalized internally.

void	setBackground (QSharedPointer< KoShapeBackground > background) override

void	setCharacterTransformsFromLayout ()
	setCharacterTransformsFromLayout Converts the text to a prepositioned SVG 1.1 text. This changes the textType();

bool	setCharacterTransformsOnRange (const int startPos, const int endPos, const QVector< QPointF > positions, const QVector< qreal > rotateDegrees, const bool deltaPosition=true)
	setCharacterTransformsOnRange Set SVG 1.1 style character transforms on the given range. Will not work when the shape is auto wrapping.

void	setFontMatchingDisabled (const bool disable)
	setDisableFontMatching

void	setMemento (const KoSvgTextShapeMementoSP memento)
	Set the text data and layout info, reset listening cursors to 0.

void	setMemento (const KoSvgTextShapeMementoSP memento, int pos, int anchor)
	Set the text data, layout info and also adjust any listening cursors.

void	setPaintOrder (PaintOrder first, PaintOrder second) override
	setPaintOrder set the paint order. As there's only three entries in any given paintorder, you only need to have the first and second entry to set it.

void	setPropertiesAtPos (int pos, KoSvgTextProperties properties)
	setPropertiesAtPos will set the properties at pos.

void	setRelayoutBlocked (const bool disable)

void	setResolution (qreal xRes, qreal yRes) override

void	setShapesInside (QList< KoShape * > shapesInside)
	setShapesInside

void	setShapesSubtract (QList< KoShape * > shapesSubtract)
	setShapesSubtract

void	setSize (const QSizeF &size) override
	Resize the shape.

void	setStroke (KoShapeStrokeModelSP stroke) override

bool	setTextPathOnRange (KoShape *textPath, const int startPos=-1, const int endPos=-1)
	setTextPathOnRange Set a text path on the specified range. In SVG text paths are always at the first child.

void	setTransformsFromLayout (KisForest< KoSvgTextContentElement > &tree, const QVector< CharacterResult > layout)

void	setTransformsFromLayoutImpl (KisForest< KoSvgTextContentElement >::child_iterator current, const KoSvgTextProperties parentProps, const QVector< CharacterResult > layout, int &globalIndex, bool isHorizontal)

bool	shapeInContours (KoShape *shape)
	shapeInContours

QList< KoShape * >	shapesInside () const
	shapesInside

QList< KoShape * >	shapesSubtract () const
	shapesSubtract

QMap< QString, QString >	shapeTypeSpecificStyles (SvgSavingContext &context) const

bool	singleNode () const
	singleNode Sometimes it is useful to know whether there's only a single text node for UX purposes.

QSizeF	size () const override
	Get the size of the shape in pt.

void	startBulkAction () override

KoShapeStrokeModelSP	stroke () const override

KoShape *	textOutline () const
	textOutline This turns the text object into non-text KoShape(s) to the best of its abilities.

QList< KoShape * >	textPathsAtRange (const int startPos=-1, const int endPos=-1)
	textPathsAtRange Get a list of textPaths at the given range. This includes textPaths whose node is only partially overlapped by the range.

KoSvgTextProperties	textProperties () const

TextType	textType () const
	textType This enum gives an indication of what kind of text this shape is. The different text types are a bit blurry as SVG allows a mixutre to provide fallback information. When such fallback is in place, this will only return the primary text type, that is, TextInShape before InlineWrap and InlineWrap before PrePositioned/Preformatted. This primarily exists to give UI feedback.

QList< QPainterPath >	textWrappingAreas () const
	textWrappingAreas The text wrapping areas are computed from shapesInside() and shapesSubtract(), as well as the text properties ShapeMargin and ShapePadding. This returns the computed wrapping areas, in the local coordinates of the shape.

KoSvgTextNodeIndex	topLevelNodeForPos (int pos) const
	topLevelNodeForPos Get, if possible, an index for the child element of the root at pos. If not possible, returns an index for the root. This is used primarily for text-on-path.

QPainterPath	underlines (int pos, int anchor, KoSvgText::TextDecorations decor, KoSvgText::TextDecorationStyle style, qreal minimum, bool thick)

void	updateInternalShapesList ()

void	updateShapeGroup ()

void	updateTextWrappingAreas ()
	updateShapeContours The current shape contours can be slow to compute, so this function calls computing them, and then calls relayout();

int	wordEnd (int pos)
	wordEnd return the pos of the first wordbreak.

int	wordLeft (int pos, bool visual=false)
	wordLeft return the cursorpos for the word left or the extreme of the line.

int	wordRight (int pos, bool visual=false)
	wordRight return the cursorpos for the word right or the extreme of the line.

int	wordStart (int pos)
	wordStart return the first pos before a wordbreak in the start direction.

KoSvgText::WritingMode	writingMode () const
	writingMode There's a number of places we need to check the writing mode to provide proper controls.

	~KoSvgTextShape () override

	~Private ()

Public Member Functions inherited from KoShape
QRectF	absoluteOutlineRect () const

QPointF	absolutePosition (KoFlake::AnchorPosition anchor=KoFlake::Center) const

QTransform	absoluteTransformation () const

bool	addDependee (KoShape *shape)

QString	additionalAttribute (const QString &name) const

void	addShapeChangeListener (ShapeChangeListener *listener)

KoShapeAnchor *	anchor () const

void	applyAbsoluteTransformation (const QTransform &matrix)

void	applyTransformation (const QTransform &matrix)

virtual ChildZOrderPolicy	childZOrderPolicy ()

KoClipMask *	clipMask () const
	Returns the currently set clip mask or 0 if there is no clip mask set.

KoClipPath *	clipPath () const
	Returns the currently set clip path or 0 if there is no clip path set.

KoShape *	cloneShapeAndBakeAbsoluteTransform () const
	creates a deep copy of the shape/shapes tree and bakes the absolute transform of `this` into the resulting shape.

void	copySettings (const KoShape *shape)

QList< KoShape * >	dependees () const
	Returns list of shapes depending on this shape.

QPointF	documentToShape (const QPointF &point) const
	Transforms point from document coordinates to shape coordinates.

QRectF	documentToShape (const QRectF &rect) const
	Transform rect from document coordinates to shape coordinates.

bool	hasAdditionalAttribute (const QString &name) const

bool	hasCommonParent (const KoShape *shape) const

bool	hasDependee (KoShape *shape) const
	Returns if the given shape is dependent on this shape.

virtual bool	hasTransparency () const

virtual bool	hitTest (const QPointF &position) const
	Check if the shape is hit on position.

QString	hyperLink () const

bool	inheritBackground () const
	inheritBackground shows if the shape inherits background from its parent

bool	inheritPaintOrder () const
	inheritPaintOrder

bool	inheritsTransformFromAny (const QList< KoShape * > ancestorsInQuestion) const
	inheritsTransformFromAny checks if the shape inherits transformation from any of the shapes listed in `ancestorsInQuestion`. The inheritance is checked in recursive way.

bool	inheritStroke () const
	inheritStroke shows if the shape inherits the stroke from its parent

bool	isContentProtected () const

bool	isGeometryProtected () const

bool	isPrintable () const

bool	isSelectable () const

virtual bool	isShapeEditable (bool recursive=true) const
	checks recursively if the shape or one of its parents is not visible or locked

bool	isVisible (bool recursive=true) const

bool	keepAspectRatio () const

	KoShape ()
	Constructor.

qreal	minimumHeight () const

QString	name () const

void	notifyChanged ()

virtual void	paintMarkers (QPainter &painter) const
	paintStroke paints the shape's markers

KoShapeContainer *	parent () const

QPointF	position () const
	Get the position of the shape in pt.

void	removeAdditionalAttribute (const QString &name)

void	removeAdditionalStyleAttribute (const char *name)

void	removeDependee (KoShape *shape)

void	removeShapeChangeListener (ShapeChangeListener *listener)

void	rotate (qreal angle)
	Rotate the shape (relative)

qreal	rotation () const

void	scale (qreal sx, qreal sy)
	Scale the shape using the zero-point which is the top-left corner.

void	setAbsolutePosition (const QPointF &newPosition, KoFlake::AnchorPosition anchor=KoFlake::Center)

void	setAdditionalAttribute (const QString &name, const QString &value)

void	setAdditionalStyleAttribute (const char *name, const QString &value)

void	setAnchor (KoShapeAnchor *anchor)

void	setClipMask (KoClipMask *clipMask)
	Sets a new clip mask, removing the old one. The mask is owned by the shape.

void	setClipPath (KoClipPath *clipPath)
	Sets a new clip path, removing the old one.

void	setContentProtected (bool protect)

void	setGeometryProtected (bool on)

void	setHyperLink (const QString &hyperLink)

void	setInheritBackground (bool value)
	setInheritBackground marks a shape as inheriting the background from the parent shape. NOTE: The currently selected background is destroyed.

void	setInheritPaintOrder (bool value)
	setInheritPaintOrder set inherit paint order.

void	setInheritStroke (bool value)
	setInheritStroke marks a shape as inheriting the stroke from the parent shape. NOTE: The currently selected stroke is destroyed.

void	setKeepAspectRatio (bool keepAspect)

void	setMinimumHeight (qreal height)

void	setName (const QString &name)

void	setParent (KoShapeContainer *parent)

virtual void	setPosition (const QPointF &position)
	Set the position of the shape in pt.

void	setPrintable (bool on)

void	setSelectable (bool selectable)

void	setShapeId (const QString &id)

void	setToolDelegates (const QSet< KoShape * > &delegates)

void	setTransformation (const QTransform &matrix)

void	setTransparency (qreal transparency)

void	setUserData (KoShapeUserData *userData)

void	setVisible (bool on)

void	setZIndex (qint16 zIndex)

QString	shapeId () const

QPointF	shapeToDocument (const QPointF &point) const
	Transforms point from shape coordinates to document coordinates.

QRectF	shapeToDocument (const QRectF &rect) const
	Transforms rect from shape coordinates to document coordinates.

void	shear (qreal sx, qreal sy)
	Shear the shape The shape will be sheared using the zero-point which is the top-left corner.

virtual KoSnapData	snapData () const
	Returns additional snap data the shape wants to have snapping to.

KoInsets	strokeInsets () const

QSet< KoShape * >	toolDelegates () const

QTransform	transformation () const
	Returns the shapes local transformation matrix.

qreal	transparency (bool recursive=false) const

virtual void	update () const

virtual void	updateAbsolute (const QRectF &rect) const

KoShapeUserData *	userData () const

virtual void	waitUntilReady (bool asynchronous=true) const

qint16	zIndex () const

virtual	~KoShape ()
	Destructor.

Public Member Functions inherited from SvgShape
virtual bool	loadSvg (const QDomElement &element, SvgLoadingContext &context)
	Loads data from specified svg element.

void	saveMetadata (SvgSavingContext &context)

virtual	~SvgShape ()

Public Member Functions inherited from KoShapeBulkActionInterface
virtual	~KoShapeBulkActionInterface ()=default

Static Public Member Functions
static qreal	anchoredChunkShift (const QVector< CharacterResult > &result, const bool isHorizontal, const int start, int &end)

static void	applyAnchoring (QVector< CharacterResult > &result, bool isHorizontal, const KoSvgText::ResolutionHandler resHandler)

static void	applyTextPath (KisForest< KoSvgTextContentElement >::child_iterator parent, QVector< CharacterResult > &result, bool isHorizontal, QPointF &startPos, const KoSvgTextProperties resolvedProps, QList< KoShape * > textPaths)

static QRectF	boundingBoxFromTree (KisForest< KoSvgTextContentElement > tree, const KoSvgTextShape *rootShape, bool includeStrokeInset)
	boundingBoxFromTree get the bounding box of the current textdata tree. We need the bounding box for a variety of things, primarily KoShape::boundingRect(), but also the calculation of the gradient painting rect.

static qreal	characterResultOnPath (CharacterResult &cr, qreal length, qreal offset, bool isHorizontal, bool isClosed)

static int	childCount (KisForest< KoSvgTextContentElement >::child_iterator it)
	Get the child count of the current node. A node without children is a text node.

static void	cleanUp (KisForest< KoSvgTextContentElement > &tree)
	cleanUp This cleans up the tree by...

static bool	cleanUpImpl (KisForest< KoSvgTextContentElement > &tree, KisForest< KoSvgTextContentElement >::child_iterator current)
	cleanUpImpl implementation of recursive function for cleanup. This goes over a child and decides whether it should be removed. If the child has more than one child of its own, it'll call this function over the children, and then handle the removal of children marked as deletable.

static QVector< bool >	collapsedWhiteSpacesForText (KisForest< KoSvgTextContentElement > &tree, QString &allText, const bool alsoCollapseLowSurrogate=false, bool includeBidiControls=false)
	collapsedWhiteSpacesForText This returns the collapsed spaces for a given piece of text, without transforms.

static QVector< SubChunk >	collectSubChunks (KisForest< KoSvgTextContentElement >::child_iterator it, KoSvgTextProperties parent, bool textInPath, bool &firstTextInPath)

static void	computeFontMetrics (KisForest< KoSvgTextContentElement >::child_iterator parent, const KoSvgTextProperties &parentProps, const KoSvgText::FontMetrics &parentBaselineTable, const KoSvgText::Baseline parentBaseline, QVector< CharacterResult > &result, int &currentIndex, const KoSvgText::ResolutionHandler resHandler, const bool isHorizontal, const bool disableFontMatching)

static const QString &	defaultPlaceholderText ()

static void	finalizeDecoration (QPainterPath decorationPath, const QPointF offset, const QPainterPathStroker &stroker, const KoSvgText::TextDecoration type, QMap< KoSvgText::TextDecoration, QPainterPath > &decorationPaths, const KoPathShape *currentTextPath, const bool isHorizontal, const qreal currentTextPathOffset, const bool textPathSide)

static KisForest< KoSvgTextContentElement >::depth_first_tail_iterator	findTextContentElementForIndex (KisForest< KoSvgTextContentElement > &tree, int &currentIndex, int sought, bool skipZeroWidth=false)
	findTextContentElementForIndex Finds the given leaf of the current tree-wide string index.

static KisForest< KoSvgTextContentElement >::child_iterator	findTopLevelParent (KisForest< KoSvgTextContentElement >::child_iterator root, KisForest< KoSvgTextContentElement >::child_iterator child)
	findTopLevelParent Returns the toplevel parent of child that is not root.

static QList< QPainterPath >	generateShapes (const QList< KoShape * > shapesInside, const QList< KoShape * > shapesSubtract, const KoSvgTextProperties &properties)

static QList< QPainterPath >	generateTextAreas (const QList< KoShape * > shapesInside, const QList< KoShape * > shapesSubtract, const KoSvgTextProperties &props)
	generateTextAreas Generates text areas with the given shapes and properties. This is used to paint previews in the PaddingMargin strategy.

static QVector< QPointF >	getLigatureCarets (const KoSvgText::ResolutionHandler &resHandler, const bool isHorizontal, raqm_glyph_t &currentGlyph)

static void	handleLineBoxAlignment (KisForest< KoSvgTextContentElement >::child_iterator parent, QVector< CharacterResult > &result, const QVector< LineBox > lineBoxes, int &currentIndex, const bool isHorizontal, const KoSvgTextProperties resolvedProps)

static void	insertNewLinesAtAnchors (KisForest< KoSvgTextContentElement > &tree, bool shapesInside=false)
	insertNewLinesAtAnchors Resolves character transforms and then inserts new lines at each transform that creates a new chunk.

static void	insertNewLinesAtAnchorsImpl (std::reverse_iterator< KisForest< KoSvgTextContentElement >::child_iterator > current, QVector< KoSvgText::CharTransformation > &resolvedTransforms, bool &inTextPath)

static void	insertTransforms (KisForest< KoSvgTextContentElement > &tree, const int start, const int length, const bool allowSkipFirst)
	insertTransforms Inserts empty transforms into tree recursively.

static int	insertTransformsImpl (KisForest< KoSvgTextContentElement >::child_iterator currentTextElement, const int globalIndex, const int start, const int length, const QVector< bool > collapsedCharacters, const bool allowSkipFirst)
	insertTransformsImpl Recursive function that handles inserting empty transforms into a given range. Used by insertTransforms.

static KisForest< KoSvgTextContentElement >::child_iterator	iteratorForTreeIndex (const QVector< int > treeIndex, KisForest< KoSvgTextContentElement >::child_iterator parent)

static bool	loadGlyph (const KoSvgText::ResolutionHandler &resHandler, const FT_Int32 faceLoadFlags, const bool isHorizontal, const char32_t firstCodepoint, const KoSvgText::TextRendering rendering, raqm_glyph_t &currentGlyph, CharacterResult &charResult, QPointF &totalAdvanceFTFontCoordinates)

static std::pair< QTransform, qreal >	loadGlyphOnly (const QTransform &ftTF, FT_Int32 faceLoadFlags, bool isHorizontal, raqm_glyph_t &currentGlyph, CharacterResult &charResult, const KoSvgText::TextRendering rendering)

static void	makeTextPathNameUnique (QList< KoShape * > textPaths, KoShape *textPath)

static int	numChars (KisForest< KoSvgTextContentElement >::child_iterator parent, bool withControls=false, KoSvgTextProperties resolvedProps=KoSvgTextProperties::defaultProperties())
	Get the number of characters for the whole subtree of this node.

static void	removeTextPathId (KisForest< KoSvgTextContentElement >::child_iterator parent, const QString &name)
	removeTextPathId Remove the text path id with the given name from the toplevel elements.

static void	removeTransforms (KisForest< KoSvgTextContentElement > &tree, const int start, const int length)
	removeTransforms Remove all local SVG character transforms in a certain range. Local transforms are influenced by whitespace collapse and whether they are set to unicode codepoints, and they also accumulate from parent to child. This function removes all local transforms in a certain section.

static int	removeTransformsImpl (KisForest< KoSvgTextContentElement >::child_iterator currentTextElement, const int globalIndex, const int start, const int length, const QVector< bool > collapsedCharacters)
	removeTransformsImpl recursive function that handles removing local transforms in a certain range. Used by removeTransform.

static QVector< KoSvgText::CharTransformation >	resolvedTransformsForTree (KisForest< KoSvgTextContentElement > &tree, bool shapesInside=false, bool includeBidiControls=false)

static void	resolveTransforms (KisForest< KoSvgTextContentElement >::child_iterator currentTextElement, QString text, QVector< CharacterResult > &result, int &currentIndex, bool isHorizontal, bool wrapped, bool textInPath, QVector< KoSvgText::CharTransformation > &resolved, QVector< bool > collapsedChars, const KoSvgTextProperties resolvedProps, bool withControls=true)

static bool	splitContentElement (KisForest< KoSvgTextContentElement > &tree, int index, bool allowEmptyText=true)
	splitContentElement split the contentElement in tree at index into two nodes.

static void	splitTree (KisForest< KoSvgTextContentElement > &tree, int index, bool textPathAfterSplit)
	splitTree Split the whole hierarchy of nodes at the given index.

static bool	startIndexOfIterator (KisForest< KoSvgTextContentElement >::child_iterator parent, KisForest< KoSvgTextContentElement >::child_iterator target, int &currentIndex)

static QPainterPath	stretchGlyphOnPath (const QPainterPath &glyph, const QPainterPath &path, bool isHorizontal, qreal offset, bool isClosed)

static KoShape *	textPathByName (QString name, QList< KoShape * > textPaths)

Static Public Member Functions inherited from KoShape
static QRectF	absoluteOutlineRect (const QList< KoShape * > &shapes)

static QRectF	boundingRect (const QList< KoShape * > &shapes)

static bool	compareShapeZIndex (KoShape s1, KoShape s2)

static KisHandlePainterHelper	createHandlePainterHelperDocument (QPainter painter, KoShape shape, qreal handleRadius, int decorationThickness)

static KisHandlePainterHelper	createHandlePainterHelperView (QPainter painter, KoShape shape, const KoViewConverter &converter, qreal handleRadius=0.0, int decorationThickness=1)

static QVector< PaintOrder >	defaultPaintOrder ()
	default paint order as per SVG specification

static QList< KoShape * >	linearizeSubtree (const QList< KoShape * > &shapes)

static QList< KoShape * >	linearizeSubtreeSorted (const QList< KoShape * > &shapes)

Public Attributes
std::optional< BulkActionState >	bulkActionState

QList< QPainterPath >	currentTextWrappingAreas

QVector< CursorPos >	cursorPos

bool	disableFontMatching = false
	Turn off font matching, which should speed up relayout slightly.

QPointF	initialTextPosition = QPointF()

QScopedPointer< KoShapePainter >	internalShapesPainter

bool	isBidi = false

bool	isLoading = false
	Turned on when loading in text data, blocks updates to shape listeners.

QVector< LineBox >	lineBoxes

QMap< int, int >	logicalToVisualCursorPos

QString	plainText

QVector< CharacterResult >	result

QScopedPointer< KoShapeGroup >	shapeGroup

QList< KoShape * >	shapesInside

QList< KoShape * >	shapesSubtract

KisForest< KoSvgTextContentElement >	textData

QList< KoShape * >	textPaths

int	xRes = 72

int	yRes = 72

Protected Member Functions
void	shapeChanged (ChangeType type, KoShape *shape) override

Protected Member Functions inherited from KoShape
	KoShape (const KoShape &rhs)

QList< ShapeChangeListener * >	listeners () const

void	setSizeImpl (const QSizeF &size) const

void	shapeChangedPriv (KoShape::ChangeType type)

QTransform	transform () const
	return the current matrix that contains the rotation/scale/position of this shape

Private Member Functions
QPainterPath	defaultCursorShape ()
	defaultCursorShape This returns a default cursor shape for when there's no text inside the text shape.

int	nextPos (int pos, bool visual)
	nextPos get the next position.

int	previousPos (int pos, bool visual)
	previousPos get the previous position.

void	setMementoImpl (const KoSvgTextShapeMementoSP memento)

Private Member Functions inherited from KoShape::Private
	Private ()

	Private (const Private &rhs)=delete

Private Attributes
QScopedPointer< Private >	d

Private Attributes inherited from KoShape::Private
QList< KoShape * >	dependees
	list of shape dependent on this shape

DependeesLifetimeListener	dependeesLifetimeListener

QList< KoShape::ShapeChangeListener * >	listeners

KoShapeContainer *	parent = nullptr

QSet< KoShapeManager * >	shapeManagers

QSet< KoShape * >	toolDelegates

Friends
class	KoSvgTextLoader

class	TestSvgText

Additional Inherited Members
Static Public Attributes inherited from KoShape
static const qint16	maxZIndex = std::numeric_limits<qint16>::max()

static const qint16	minZIndex = std::numeric_limits<qint16>::min()

Detailed Description

KoSvgTextShape is a root chunk of the <text> element subtree.

Definition at line 32 of file KoSvgTextShape.h.

Member Enumeration Documentation

◆ DebugElement

enum class KoSvgTextShape::DebugElement

strong

Enumerator
CharBbox
LineBox

Definition at line 53 of file KoSvgTextShape.h.

                            {
        CharBbox = 1 << 0,
        LineBox = 1 << 1,
    };

◆ InternalShapeState

enum KoSvgTextShape::InternalShapeState

Enumerator
Decorative
ShapeInside
ShapeSubtract
TextPath

Definition at line 452 of file KoSvgTextShape_p.h.

                            {
        Decorative,
        ShapeInside,
        ShapeSubtract,
        TextPath
    };

◆ TextType

enum KoSvgTextShape::TextType

Enumerator
PrePositionedText	SVG 1.1 text, white spaces are collapsed or only spaces are preserved. Identical to PreformattedText otherwise.
PreformattedText	Text-on-Path falls under this or PrePositionedText depending on collapse of lines. No wrapping, but preserves spaces and linebreaks.
InlineWrap	Uses inline size to wrap and preserves spaces.
TextInShape	Uses shape-inside to wrap and preserves spaces.

Definition at line 76 of file KoSvgTextShape.h.

                  {
        PrePositionedText = 0, 
        PreformattedText, 
        InlineWrap, 
        TextInShape 
    };

Constructor & Destructor Documentation

◆ KoSvgTextShape() [1/2]

KoSvgTextShape::KoSvgTextShape ( )

Definition at line 138 of file KoSvgTextShape.cpp.

    : KoShape()
    , d(new Private)
{
    setShapeId(KoSvgTextShape_SHAPEID);
    d->shapeGroup->setTransformation(this->transformation());
    d->textData.insert(d->textData.childBegin(), KoSvgTextContentElement());
    d->internalShapesPainter->setUpdateFunction(std::bind(&KoSvgTextShape::updateAbsolute, this, std::placeholders::_1));
}

References d, KoSvgTextShape_SHAPEID, KoShape::setShapeId(), KoShape::transformation(), and KoShape::updateAbsolute().

◆ KoSvgTextShape() [2/2]

KoSvgTextShape::KoSvgTextShape ( const KoSvgTextShape & rhs )

Definition at line 148 of file KoSvgTextShape.cpp.

    : KoShape(rhs)
    , d(new Private(*rhs.d))
{
    setShapeId(KoSvgTextShape_SHAPEID);
    d->shapeGroup->setTransformation(this->transformation());
    d->internalShapesPainter->setUpdateFunction(std::bind(&KoSvgTextShape::updateAbsolute, this, std::placeholders::_1));
    Q_FOREACH(KoShape *shape, d->shapeGroup->shapes()) {
        shape->addDependee(this);
    }
}

References KoShape::addDependee(), d, KoSvgTextShape_SHAPEID, KoShape::setShapeId(), KoShape::transformation(), and KoShape::updateAbsolute().

◆ ~KoSvgTextShape()

KoSvgTextShape::~KoSvgTextShape ( )

override

Definition at line 160 of file KoSvgTextShape.cpp.

{
    Q_FOREACH(KoShape *shape, internalShapeManager()->shapes()) {
        shape->removeDependee(this);
    }
}

References internalShapeManager(), and KoShape::removeDependee().

◆ ~Private()

KoSvgTextShape::~Private ( )

inline

Definition at line 497 of file KoSvgTextShape_p.h.

               {
 
        internalShapesPainter.reset();
        Q_FOREACH(KoShape *shape, shapeGroup->shapes()) {
            shapeGroup->removeShape(shape);
        }
        shapeGroup.reset();
        qDeleteAll(shapesInside);
        shapesInside.clear();
        qDeleteAll(shapesSubtract);
        shapesSubtract.clear();
        qDeleteAll(textPaths);
        textPaths.clear();
    }

Member Function Documentation

◆ addShapeContours()

void KoSvgTextShape::addShapeContours	(	QList< KoShape * >	shapes,
		const bool	inside = true )

addShapesContours Add shapes to the contours that make up the wrapping area.

Parameters

shapes	– shapes to add.
inside	– whether to add to shapesInside or shapesSubtract. If a shape is already in one list, adding them will cause them to be moved to the other list.

Definition at line 2352 of file KoSvgTextShape.cpp.

{
    Q_FOREACH(KoShape *shape, shapes) {
        if (d->textPaths.contains(shape)) {
            d->removeTextPathId(d->textData.childBegin(), shape->name());
            d->cleanUp(d->textData);
            d->textPaths.removeAll(shape);
        }
 
        if (inside) {
            if (d->shapesSubtract.contains(shape)) {
                d->shapesSubtract.removeAll(shape);
            }
            d->shapesInside.append(shape);
        } else {
            if (d->shapesInside.contains(shape)) {
                d->shapesInside.removeAll(shape);
            }
            d->shapesSubtract.append(shape);
        }
        if (!d->shapeGroup->shapes().contains(shape)) {
            d->shapeGroup->addShape(shape);
            shape->addDependee(this);
        }
    }
 
    notifyChanged(); // notify shape manager that our geometry has changed
 
    if (!d->isLoading) {
        d->updateTextWrappingAreas();
    }
 
    d->updateInternalShapesList();
    shapeChangedPriv(ContentChanged);
    update();
}

References KoShape::addDependee(), KoShape::ContentChanged, d, KoShape::name(), KoShape::notifyChanged(), KoShape::shapeChangedPriv(), and KoShape::update().

◆ addTextPathAtEnd()

void KoSvgTextShape::addTextPathAtEnd ( KoShape * textPath )

addTextPathAtEnd add a textpath node at the end of the text.

Parameters

textPath – text path to add.

Definition at line 2541 of file KoSvgTextShape.cpp.

{
    auto root = d->textData.childBegin();
    if (root == d->textData.childEnd()) return;
    if (d->textPaths.contains(textPath)) return;
 
    Private::makeTextPathNameUnique(d->textPaths, textPath);
    KoSvgTextContentElement textPathElement;
    textPathElement.textPathId = textPath->name();
    d->shapeGroup->addShape(textPath);
    d->textPaths.append(textPath);
    textPath->addDependee(this);
 
    d->textData.insert(childEnd(root), textPathElement);
}

References KoShape::addDependee(), d, KoShape::name(), and KoSvgTextContentElement::textPathId.

◆ anchoredChunkShift()

static qreal KoSvgTextShape::anchoredChunkShift	(	const QVector< CharacterResult > &	result,
		const bool	isHorizontal,
		const int	start,
		int &	end )

static

◆ applyAnchoring()

static void KoSvgTextShape::applyAnchoring	(	QVector< CharacterResult > &	result,
		bool	isHorizontal,
		const KoSvgText::ResolutionHandler	resHandler )

static

◆ applyTextLength()

void KoSvgTextShape::applyTextLength	(	KisForest< KoSvgTextContentElement >::child_iterator	currentTextElement,
		QVector< CharacterResult > &	result,
		int &	currentIndex,
		int &	resolvedDescendentNodes,
		bool	isHorizontal,
		const KoSvgTextProperties	resolvedProps,
		const KoSvgText::ResolutionHandler &	resHandler )

◆ applyTextPath()

static void KoSvgTextShape::applyTextPath	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		QVector< CharacterResult > &	result,
		bool	isHorizontal,
		QPointF &	startPos,
		const KoSvgTextProperties	resolvedProps,
		QList< KoShape * >	textPaths )

static

◆ applyWhiteSpace()

void KoSvgTextShape::applyWhiteSpace	(	KisForest< KoSvgTextContentElement > &	tree,
		const bool	convertToPreWrapped = false )

inline

applyWhiteSpace CSS Whitespace processes whitespaces so that duplicate white spaces and unnecessary hard breaks get removed from the text. Within the text layout we avoid removing the white spaces. However, when converting between text types it can be useful to remove these spaces. This function actually applies the white space rule to the active text.

Parameters

tree	– tree to apply the whitespace rule onto.
convertToPreWrapped	– switch all whitespace rules to pre-wrapped.

Definition at line 1064 of file KoSvgTextShape_p.h.

                                                                                                           {
        QString allText;
        QVector<bool> collapsed = collapsedWhiteSpacesForText(tree, allText, false);
 
        auto end = std::make_reverse_iterator(tree.childBegin());
        auto begin = std::make_reverse_iterator(tree.childEnd());
 
        for (; begin != end; begin++) {
            applyWhiteSpaceImpl(begin, collapsed, allText, convertToPreWrapped);
        }
        if (convertToPreWrapped) {
            tree.childBegin()->properties.setProperty(KoSvgTextProperties::TextCollapseId, QVariant::fromValue(KoSvgText::Preserve));
            tree.childBegin()->properties.setProperty(KoSvgTextProperties::TextWrapId, QVariant::fromValue(KoSvgText::Wrap));
        }
    }

References KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::childEnd(), KoSvgText::Preserve, KoSvgTextProperties::TextCollapseId, KoSvgTextProperties::TextWrapId, and KoSvgText::Wrap.

◆ applyWhiteSpaceImpl()

void KoSvgTextShape::applyWhiteSpaceImpl	(	std::reverse_iterator< KisForest< KoSvgTextContentElement >::child_iterator >	current,
		QVector< bool > &	collapsed,
		QString &	allText,
		const bool	convertToPreWrapped )

inline

Definition at line 1080 of file KoSvgTextShape_p.h.

                                                                                                                                                                                        {
        auto base = current.base();
        // It seems that .base() refers to the next entry instead of the pointer,
        // which is coherent with the template implementation of "operator*" here:
        // https://en.cppreference.com/w/cpp/iterator/reverse_iterator.html
        base--;
        if(base != siblingEnd(base)) {
            auto end = std::make_reverse_iterator(childBegin(base));
            auto begin = std::make_reverse_iterator(childEnd(base));
            for (; begin != end; begin++) {
                applyWhiteSpaceImpl(begin, collapsed, allText, convertToPreWrapped);
            }
        }
 
        if (!current->text.isEmpty()) {
            const int total = current->text.size();
            QString currentText = allText.right(total);
 
            for (int i = 0; i < total; i++) {
                const int j = total - (i+1);
                const bool col = collapsed.takeLast();
                if (col) {
                    currentText.remove(j, 1);
                }
 
            }
            current->text = currentText;
            allText.chop(total);
        }
        if (convertToPreWrapped) {
            current->properties.removeProperty(KoSvgTextProperties::TextCollapseId);
            current->properties.removeProperty(KoSvgTextProperties::TextWrapId);
        }
    }

References KoSvgTextProperties::TextCollapseId, and KoSvgTextProperties::TextWrapId.

◆ background()

QSharedPointer< KoShapeBackground > KoSvgTextShape::background ( ) const

overridevirtual

Return the brush used to paint the background of this shape with. A QBrush can have a plain color, be fully transparent or have a complex fill. setting such a brush will allow the shape to fill itself using that brush and will be able to tell if its transparent or not.

Returns: the background-brush

Reimplemented from KoShape.

Definition at line 1567 of file KoSvgTextShape.cpp.

{
    KoSvgTextProperties props = KisForestDetail::size(d->textData)? d->textData.childBegin()->properties: KoSvgTextProperties();
    if (props.hasProperty(KoSvgTextProperties::FillId)) {
        return props.property(KoSvgTextProperties::FillId).value<KoSvgText::BackgroundProperty>().property;
    }
    return QSharedPointer<KoShapeBackground>(new KoColorBackground(Qt::black));
}

References d, KoSvgTextProperties::FillId, KoSvgTextProperties::hasProperty(), KoSvgTextProperties::properties(), KoSvgTextProperties::property(), and KisForestDetail::size().

◆ boundingBoxFromTree()

static QRectF KoSvgTextShape::boundingBoxFromTree	(	KisForest< KoSvgTextContentElement >	tree,
		const KoSvgTextShape *	rootShape,
		bool	includeStrokeInset )

inlinestatic

boundingBoxFromTree get the bounding box of the current textdata tree. We need the bounding box for a variety of things, primarily KoShape::boundingRect(), but also the calculation of the gradient painting rect.

Parameters

tree	– tree to perform this on.
includeStrokeInset	– whether to include stroke insets.

Returns: a bounding rect.

Definition at line 1433 of file KoSvgTextShape_p.h.

                                                                                                                                         {
        QRectF result;
        QList<KoShapeStrokeModelSP> parentStrokes;
        for (auto it = tree.compositionBegin(); it != tree.compositionEnd(); it++) {
            if (it.state() == KisForestDetail::Enter) {
                if (it->properties.hasProperty(KoSvgTextProperties::StrokeId)) {
                    parentStrokes.append(it->properties.property(KoSvgTextProperties::StrokeId).value<KoSvgText::StrokeProperty>().property);
                }
            } else {
                KoShapeStrokeModelSP stroke = parentStrokes.size() > 0? parentStrokes.last(): nullptr;
                QRectF bb = it->associatedOutline.boundingRect();
                QMap<KoSvgText::TextDecoration, QPainterPath> decorations = it->textDecorations;
                for (int i = 0; i < decorations.values().size(); ++i) {
                    bb |= decorations.values().at(i).boundingRect();
                }
                if (!bb.isEmpty()) {
                    if (stroke && includeStrokeInset) {
                        KoInsets insets;
                        stroke->strokeInsets(rootShape, insets);
                        result |= bb.adjusted(-insets.left, -insets.top, insets.right, insets.bottom);
                    } else {
                        result |= bb;
                    }
                }
                if (it->properties.hasProperty(KoSvgTextProperties::StrokeId)) {
                    // reset stroke to use parent stroke.
                    parentStrokes.pop_back();
                }
            }
        }
        return result;
    }

References KoInsets::bottom, KisForestDetail::Forest< T >::compositionBegin(), KisForestDetail::Forest< T >::compositionEnd(), KisForestDetail::Enter, KoInsets::left, KoInsets::right, KoSvgTextProperties::StrokeId, and KoInsets::top.

◆ boundingRect()

QRectF KoSvgTextShape::boundingRect ( ) const

overridevirtual

Get the bounding box of the shape.

This includes the line width of the shape

Returns: the bounding box of the shape

Reimplemented from KoShape.

Definition at line 2120 of file KoSvgTextShape.cpp.

{
    QRectF shapesRect;
    if (d->internalShapesPainter->contentRect().isValid()) {
        shapesRect = d->internalShapesPainter->contentRect();
        if (!(d->shapesInside.isEmpty() && d->shapesSubtract.isEmpty())) {
            return shapesRect;
        }
    }
    QRectF result = Private::boundingBoxFromTree(d->textData, this, true);
 
    return (this->absoluteTransformation().mapRect(result) | shapesRect);
}

References KoShape::absoluteTransformation(), d, and result.

◆ characterResultOnPath()

static qreal KoSvgTextShape::characterResultOnPath	(	CharacterResult &	cr,
		qreal	length,
		qreal	offset,
		bool	isHorizontal,
		bool	isClosed )

static

◆ childCount()

static int KoSvgTextShape::childCount ( KisForest< KoSvgTextContentElement >::child_iterator it )

inlinestatic

Get the child count of the current node. A node without children is a text node.

Definition at line 713 of file KoSvgTextShape_p.h.

                                                                               {
        return std::distance(KisForestDetail::childBegin(it), KisForestDetail::childEnd(it));
    }

References KisForestDetail::childBegin(), and KisForestDetail::childEnd().

◆ cleanUp() [1/2]

void KoSvgTextShape::cleanUp ( )

Cleans up the internal text data. Used by undo commands.

Definition at line 1245 of file KoSvgTextShape.cpp.

{
    KoSvgTextShape::Private::cleanUp(d->textData);
    notifyChanged();
    shapeChangedPriv(ContentChanged);
}

References KoShape::ContentChanged, d, KoShape::notifyChanged(), and KoShape::shapeChangedPriv().

◆ cleanUp() [2/2]

static void KoSvgTextShape::cleanUp ( KisForest< KoSvgTextContentElement > & tree )

inlinestatic

cleanUp This cleans up the tree by...

Removing empty text elements that are not the root or text paths.
Merging sibling elements with similar properties.
Merging single children with parent if possible.
Parameters

tree – tree to clean up

Definition at line 1349 of file KoSvgTextShape_p.h.

                                                                  {
        if (tree.childBegin() != tree.childEnd()) {
            cleanUpImpl(tree, tree.childBegin());
        }
    }

References KisForestDetail::Forest< T >::childBegin(), and KisForestDetail::Forest< T >::childEnd().

◆ cleanUpImpl()

static bool KoSvgTextShape::cleanUpImpl	(	KisForest< KoSvgTextContentElement > &	tree,
		KisForest< KoSvgTextContentElement >::child_iterator	current )

inlinestatic

cleanUpImpl implementation of recursive function for cleanup. This goes over a child and decides whether it should be removed. If the child has more than one child of its own, it'll call this function over the children, and then handle the removal of children marked as deletable.

Returns: whether the given child should be removed from the tree.

Definition at line 1273 of file KoSvgTextShape_p.h.

                                                                                                                                {
        const int children = childCount(current);
        if (children == 0) {
            const int length = current->numChars(false);
            if (length == 0 && current != tree.childBegin() && current->textPathId.isEmpty()) {
                return true;
            } else {
                // check if siblings are similar.
                auto siblingPrev = current;
                KoSvgText::UnicodeBidi bidi = KoSvgText::UnicodeBidi(current->properties.property(KoSvgTextProperties::UnicodeBidiId,
                                                                                             QVariant(KoSvgText::BidiNormal)).toInt());
                siblingPrev--;
                while (!isEnd(siblingPrev) && siblingPrev->text.isEmpty()) {
                    // By checking whether the text is empty, we can skip previous
                    // siblings that are already marked for deletion.
                    siblingPrev--;
                }
                if (!isEnd(siblingPrev)
                        && siblingPrev != current
                        && (siblingPrev->localTransformations.isEmpty() && current->localTransformations.isEmpty())
                        && (siblingPrev->textPathId.isEmpty() && current->textPathId.isEmpty())
                        && (siblingPrev->textLength.isAuto && current->textLength.isAuto)
                        && (siblingPrev->properties == current->properties)
                        && (bidi != KoSvgText::BidiIsolate && bidi != KoSvgText::BidiIsolateOverride)
                        && childCount(siblingPrev) == 0) {
                    // TODO: handle localtransforms better; annoyingly, this requires whitespace handling
                    siblingPrev->text += current->text;
                    current->text = QString();
                    return true;
                }
            }
        } else if (children == 1) {
            // merge single children into parents if possible.
            auto child = childBegin(current);
            if ((child->localTransformations.isEmpty() && current->localTransformations.isEmpty())
                    && (child->textPathId.isEmpty() && current->textPathId.isEmpty())
                    && (child->textLength.isAuto && current->textLength.isAuto)
                    && (!child->properties.hasNonInheritableProperties() || !current->properties.hasNonInheritableProperties())) {
                if (current->properties.hasNonInheritableProperties()) {
                    KoSvgTextProperties props = current->properties;
                    props.setAllButNonInheritableProperties(child->properties);
                    child->properties = props;
                } else {
                    child->properties.inheritFrom(current->properties);
                }
                *current = *child;
                tree.erase(child);
            }
        } else {
            QVector<KisForest<KoSvgTextContentElement>::child_iterator> deleteList;
            for (auto child = childBegin(current); child != childEnd(current); child++) {
                if (cleanUpImpl(tree, child)) {
                    deleteList.append(child);
                }
            }
            while (!deleteList.isEmpty()) {
                auto child = deleteList.takeFirst();
                KIS_ASSERT_RECOVER_NOOP(childBegin(child) == childEnd(child));
                tree.erase(child);
            }
            if (childCount(current) <= 1) {
                // This checks if, when there's only 0 or 1 children, this node can be cleaned up as well.
                return cleanUpImpl(tree, current);
            }
        }
        return false;
    }

References KoSvgText::BidiIsolate, KoSvgText::BidiIsolateOverride, KoSvgText::BidiNormal, KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::erase(), KIS_ASSERT_RECOVER_NOOP, length(), KoSvgTextProperties::properties(), KoSvgTextProperties::setAllButNonInheritableProperties(), and KoSvgTextProperties::UnicodeBidiId.

◆ clearAssociatedOutlines()

void KoSvgTextShape::clearAssociatedOutlines ( )

◆ cloneShape()

KoShape * KoSvgTextShape::cloneShape ( ) const

overridevirtual

creates a deep copy of the shape or shape's subtree

Returns: a cloned shape

Reimplemented from KoShape.

Definition at line 173 of file KoSvgTextShape.cpp.

{
    return new KoSvgTextShape(*this);
}

References KoSvgTextShape().

◆ collapsedWhiteSpacesForText()

static QVector< bool > KoSvgTextShape::collapsedWhiteSpacesForText	(	KisForest< KoSvgTextContentElement > &	tree,
		QString &	allText,
		const bool	alsoCollapseLowSurrogate = false,
		bool	includeBidiControls = false )

inlinestatic

collapsedWhiteSpacesForText This returns the collapsed spaces for a given piece of text, without transforms.

Parameters

tree	– text data tree.
allText	– some collapseMethods modify the text. This is a pointer that sets the modified text.
alsoCollapseLowSurrogate	– whether to mark utf16 surrogates as collapsed too.

Returns: list of collapsed characters

Definition at line 891 of file KoSvgTextShape_p.h.

                                                                                                                                                                                                {
        QMap<int, KoSvgText::TextSpaceCollapse> collapseModes;
 
        QList<KoSvgTextProperties> parentProps = {KoSvgTextProperties::defaultProperties()};
        for (auto it = tree.compositionBegin(); it != tree.compositionEnd(); it++) {
            if (it.state() == KisForestDetail::Enter) {
                KoSvgTextProperties ownProperties = it->properties;
                ownProperties.inheritFrom(parentProps.last());
                parentProps.append(ownProperties);
 
                const int children = childCount(siblingCurrent(it));
                if (children == 0) {
                    QString text = it->text;
                    if (includeBidiControls) {
                        KoSvgText::UnicodeBidi bidi = KoSvgText::UnicodeBidi(parentProps.last().propertyOrDefault(KoSvgTextProperties::UnicodeBidiId).toInt());
                        KoSvgText::Direction direction = KoSvgText::Direction(parentProps.last().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
                        QVector<QPair<int, int>> positions;
                        QString text = KoCssTextUtils::getBidiOpening(direction, bidi);
                        text += it->getTransformedString(positions, parentProps.last());
                        text += KoCssTextUtils::getBidiClosing(bidi);
                    }
                    KoSvgText::TextSpaceCollapse collapse = KoSvgText::TextSpaceCollapse(parentProps.last().propertyOrDefault(KoSvgTextProperties::TextCollapseId).toInt());
                    collapseModes.insert(allText.size(), collapse);
                    allText += text;
                }
            } else {
                parentProps.pop_back();
            }
        }
        QVector<bool> collapsed = KoCssTextUtils::collapseSpaces(&allText, collapseModes);
 
        if (alsoCollapseLowSurrogate) {
            for (int i = 0; i < allText.size(); i++) {
                if (i > 0 && allText.at(i).isLowSurrogate() && allText.at(i-1).isHighSurrogate()) {
                    collapsed[i] = true;
                }
            }
        }
        return collapsed;
    }

References KoCssTextUtils::collapseSpaces(), KisForestDetail::Forest< T >::compositionBegin(), KisForestDetail::Forest< T >::compositionEnd(), KoSvgTextProperties::defaultProperties(), KoSvgTextProperties::DirectionId, KisForestDetail::Enter, KoCssTextUtils::getBidiClosing(), KoCssTextUtils::getBidiOpening(), KoSvgTextProperties::inheritFrom(), KoSvgTextProperties::properties(), KoSvgTextProperties::TextCollapseId, and KoSvgTextProperties::UnicodeBidiId.

◆ collectPaths()

KoShape * KoSvgTextShape::collectPaths	(	const KoSvgTextShape *	rootShape,
		QVector< CharacterResult > &	result,
		int &	currentIndex )

◆ collectSubChunks()

static QVector< SubChunk > KoSvgTextShape::collectSubChunks	(	KisForest< KoSvgTextContentElement >::child_iterator	it,
		KoSvgTextProperties	parent,
		bool	textInPath,
		bool &	firstTextInPath )

static

Return a linearized representation of a subtree of text "subchunks".

◆ computeFontMetrics()

static void KoSvgTextShape::computeFontMetrics	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		const KoSvgTextProperties &	parentProps,
		const KoSvgText::FontMetrics &	parentBaselineTable,
		const KoSvgText::Baseline	parentBaseline,
		QVector< CharacterResult > &	result,
		int &	currentIndex,
		const KoSvgText::ResolutionHandler	resHandler,
		const bool	isHorizontal,
		const bool	disableFontMatching )

static

◆ computeTextDecorations()

void KoSvgTextShape::computeTextDecorations	(	KisForest< KoSvgTextContentElement >::child_iterator	currentTextElement,
		const QVector< CharacterResult > &	result,
		const QMap< int, int > &	logicalToVisual,
		const KoSvgText::ResolutionHandler	resHandler,
		KoPathShape *	textPath,
		qreal	textPathoffset,
		bool	side,
		int &	currentIndex,
		bool	isHorizontal,
		bool	ltr,
		bool	wrapping,
		const KoSvgTextProperties	resolvedProps,
		QList< KoShape * >	textPaths )

◆ convertCharTransformsToPreformatted()

void KoSvgTextShape::convertCharTransformsToPreformatted ( bool makeInlineSize = false )

convertCharTransformsToPreformatted Converts the text to a preformatted SVG 2.0 text. This changes the textType();

Parameters

makeInlineSize – whether to have inline size applied.

Definition at line 1689 of file KoSvgTextShape.cpp.

{
    const int inlineSize = writingMode() == KoSvgText::HorizontalTB? outlineRect().width(): outlineRect().height();
    d->applyWhiteSpace(d->textData, true);
    d->insertNewLinesAtAnchors(d->textData, !d->shapesInside.isEmpty());
    d->cleanUp(d->textData);
 
    KoSvgTextProperties props = this->propertiesForPos(-1);
    if (makeInlineSize) {
        KoSvgText::AutoValue val;
        // Using QCeil here because otherwise the text will layout too tight.
        val.customValue = qCeil(inlineSize);
        val.isAuto = false;
        if (!props.hasProperty(KoSvgTextProperties::InlineSizeId)) {
            props.setProperty(KoSvgTextProperties::InlineSizeId, QVariant::fromValue(val));
        }
    } else {
        props.removeProperty(KoSvgTextProperties::InlineSizeId);
    }
    // NOTE: applyWhiteSpace and insertNewLines don't notify changes,
    // so setProperties is the only thing triggering relayout();
    setPropertiesAtPos(-1, props);
}

References KoSvgText::AutoValue::customValue, d, KoSvgTextProperties::hasProperty(), KoSvgText::HorizontalTB, KoSvgTextProperties::InlineSizeId, KoSvgText::AutoValue::isAuto, outlineRect(), propertiesForPos(), KoSvgTextProperties::removeProperty(), setPropertiesAtPos(), KoSvgTextProperties::setProperty(), and writingMode().

◆ copyRange()

std::unique_ptr< KoSvgTextShape > KoSvgTextShape::copyRange	(	int	index,
		int	length ) const

copyRange Copy the rich text for the given range.

Parameters

index	– start string index of the range.
length	– length of the range.

Returns: a KoSvgTextShape with only the content elements inside the range.

Definition at line 1170 of file KoSvgTextShape.cpp.

{
    KoSvgTextShape *clone = new KoSvgTextShape(*this);
    int zero = 0;
    int endRange = index + length;
    int size = KoSvgTextShape::Private::numChars(clone->d->textData.childBegin(), false) - endRange;
    clone->removeText(endRange, size);
    clone->removeText(zero, index);
    KoSvgTextShape::Private::cleanUp(clone->d->textData);
    return std::unique_ptr<KoSvgTextShape>(clone);
}

References d, KoSvgTextShape(), length(), removeText(), and size().

◆ createTextNodeIndex()

KoSvgTextNodeIndex KoSvgTextShape::createTextNodeIndex ( KisForest< KoSvgTextContentElement >::child_iterator textElement ) const

◆ cursorForPos()

QPainterPath KoSvgTextShape::cursorForPos	(	int	pos,
		QLineF &	caret,
		QColor &	color,
		double	bidiFlagSize = 1.0 )

cursorForPos returns the QPainterPath associated with this cursorPosition.

Parameters

pos	the cursor Position
bidiFlagSize	– size of the bidirectional indicator.

Returns: a path to draw a cursor with.

Definition at line 653 of file KoSvgTextShape.cpp.

{
    if (d->result.isEmpty() || d->cursorPos.isEmpty() || pos < 0 || pos >= d->cursorPos.size()) {
        return defaultCursorShape();
    }
    QPainterPath p;
 
    CursorPos cursorPos = d->getCursorPos(pos);
 
    CharacterResult res = d->result.at(cursorPos.cluster);
 
    const QTransform tf = res.finalTransform();
    color = res.cursorInfo.color;
    caret = res.cursorInfo.caret;
    caret.translate(res.cursorInfo.offsets.value(cursorPos.offset, QPointF()));
 
    p.moveTo(tf.map(caret.p1()));
    p.lineTo(tf.map(caret.p2()));
    if (d->isBidi && bidiFlagSize > 0) {
        int sign = res.cursorInfo.rtl ? -1 : 1;
        double bidiFlagHalf = bidiFlagSize * 0.5;
        QPointF point3;
        QPointF point4;
        if (writingMode() == KoSvgText::HorizontalTB) {
            qreal slope = bidiFlagHalf * (caret.dx()/ caret.dy());
            point3 = QPointF(caret.p2().x() + slope + (sign * bidiFlagHalf), caret.p2().y() + bidiFlagHalf);
            point4 = QPointF(point3.x() + slope - (sign * bidiFlagHalf),point3.y() + bidiFlagHalf);
        } else {
            qreal slope = bidiFlagHalf * (caret.dy()/ caret.dx());
            point3 = QPointF(caret.p2().x() - bidiFlagHalf, caret.p2().y() - slope + (sign * bidiFlagHalf));
            point4 = QPointF(point3.x() - bidiFlagHalf, point3.y() - slope - (sign * bidiFlagHalf));
        }
        p.lineTo(tf.map(point3));
        p.lineTo(tf.map(point4));
    }
    caret = tf.map(caret);
 
    return p;
}

References CursorInfo::caret, CursorInfo::color, CharacterResult::cursorInfo, cursorPos, d, defaultCursorShape(), CharacterResult::finalTransform(), KoSvgText::HorizontalTB, CursorInfo::offsets, p, CursorInfo::rtl, sign(), and writingMode().

◆ debugParsing()

void KoSvgTextShape::debugParsing ( )

Outputs debug with the current textData tree.

Definition at line 1978 of file KoSvgTextShape.cpp.

{
    qDebug() << "Tree size:" << KisForestDetail::size(d->textData);
    QString spaces;
    for (auto it = compositionBegin(d->textData); it != compositionEnd(d->textData); it++) {
        if (it.state() == KisForestDetail::Enter) {
 
            qDebug() << QString(spaces + "+") << it->text;
            qDebug() << QString(spaces + "|") << it->properties.convertToSvgTextAttributes();
            qDebug() << QString(spaces + "| PropertyType:") << it->properties.property(KoSvgTextProperties::KraTextStyleType).toString();
            qDebug() << QString(spaces + "| Fill set: ") << it->properties.hasProperty(KoSvgTextProperties::FillId);
            qDebug() << QString(spaces + "| Stroke set: ") << it->properties.hasProperty(KoSvgTextProperties::StrokeId);
            qDebug() << QString(spaces + "| Opacity: ") << it->properties.property(KoSvgTextProperties::Opacity);
            qDebug() << QString(spaces + "| PaintOrder: ") << it->properties.hasProperty(KoSvgTextProperties::PaintOrder);
            qDebug() << QString(spaces + "| Visibility set: ") << it->properties.hasProperty(KoSvgTextProperties::Visibility);
            qDebug() << QString(spaces + "| TextPath set: ") << it->textPathId;
            qDebug() << QString(spaces + "| Transforms set: ") << it->localTransformations;
            spaces.append(" ");
        }
 
        if (it.state() == KisForestDetail::Leave) {
            spaces.chop(1);
        }
    }
}

References d, KisForestDetail::Enter, KoSvgTextProperties::FillId, KoSvgTextProperties::KraTextStyleType, KisForestDetail::Leave, KoSvgTextProperties::Opacity, KoSvgTextProperties::PaintOrder, KisForestDetail::size(), KoSvgTextProperties::StrokeId, and KoSvgTextProperties::Visibility.

◆ defaultCursorShape()

QPainterPath KoSvgTextShape::defaultCursorShape ( )

private

defaultCursorShape This returns a default cursor shape for when there's no text inside the text shape.

Returns: a QPainterPath for a cursor.

Definition at line 636 of file KoSvgTextShape.cpp.

{
    KoSvgText::WritingMode mode = writingMode();
    double fontSize = this->textProperties().fontSize().value;
    QPainterPath p;
    if (mode == KoSvgText::HorizontalTB) {
        p.moveTo(0, fontSize*0.2);
        p.lineTo(0, -fontSize);
    } else {
        p.moveTo(-fontSize * 0.5, 0);
        p.lineTo(fontSize, 0);
    }
    p.translate(d->initialTextPosition);
 
    return p;
}

References d, KoSvgTextProperties::fontSize(), KoSvgText::HorizontalTB, p, textProperties(), KoSvgText::CssLengthPercentage::value, and writingMode().

◆ defaultPlaceholderText()

const QString & KoSvgTextShape::defaultPlaceholderText ( )

static

Definition at line 167 of file KoSvgTextShape.cpp.

{
    static const QString s_placeholderText = i18nc("Default text for the text shape", "Placeholder Text");
    return s_placeholderText;
}

◆ direction()

KoSvgText::Direction KoSvgTextShape::direction ( ) const

direction Whether the text is left to right or right to left.

Returns: the paragraph-direction of this text.

Definition at line 1652 of file KoSvgTextShape.cpp.

{
    return KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
}

References KoSvgTextProperties::DirectionId, and textProperties().

◆ endBulkAction()

QRectF KoSvgTextShape::endBulkAction ( )

overridevirtual

Ends bulk action state and performs all calculation-heavy operations over the new state. Returns a rectangle in absolute coordinates that should be updated to make these changes visible to the user.

Implements KoShapeBulkActionInterface.

Definition at line 2035 of file KoSvgTextShape.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(d->bulkActionState, boundingRect());
 
    QRectF updateRect;
 
    if (d->bulkActionState->changed()) {
        if (d->bulkActionState->contourHasChanged) {
            d->updateTextWrappingAreas();
        } else if (d->bulkActionState->layoutHasChanged) {
            // updateTextWrappingAreas() already includes a call to relayout()
            relayout();
        }
        // otherwise, it's an update from a memento.
 
        updateRect = d->bulkActionState->originalBoundingRect | boundingRect();
    }
 
    d->bulkActionState = std::nullopt;
    return updateRect;
}

References boundingRect(), d, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and relayout().

◆ enterNodeSubtree()

void KoSvgTextShape::enterNodeSubtree ( )

Set the current node to its first child, entering the subtree.

Definition at line 1892 of file KoSvgTextShape.cpp.

{
 
}

◆ finalizeDecoration()

static void KoSvgTextShape::finalizeDecoration	(	QPainterPath	decorationPath,
		const QPointF	offset,
		const QPainterPathStroker &	stroker,
		const KoSvgText::TextDecoration	type,
		QMap< KoSvgText::TextDecoration, QPainterPath > &	decorationPaths,
		const KoPathShape *	currentTextPath,
		const bool	isHorizontal,
		const qreal	currentTextPathOffset,
		const bool	textPathSide )

static

◆ findNodeIndexForPropertyId()

KoSvgTextNodeIndex KoSvgTextShape::findNodeIndexForPropertyId ( KoSvgTextProperties::PropertyId propertyId )

findNodeIndexForPropertyId

Returns: the nodeIndex of the first content element found with a given property id. @propertyId -- id to search for.

Definition at line 1500 of file KoSvgTextShape.cpp.

{
    for (auto it = d->textData.childBegin(); it != d->textData.childEnd(); it++) {
        if (it->properties.hasProperty(propertyId)) {
            return d->createTextNodeIndex(it);
        } else if (KisForestDetail::childBegin(it) != KisForestDetail::childEnd(it)) {
            auto found = findNodeIndexForPropertyIdImpl(it, propertyId);
            if (found != it) {
                return d->createTextNodeIndex(found);
            }
        }
    }
    return d->createTextNodeIndex(d->textData.childBegin());
}

References KisForestDetail::childBegin(), KisForestDetail::childEnd(), d, and findNodeIndexForPropertyIdImpl().

◆ findRangeForNodeIndex()

QPair< int, int > KoSvgTextShape::findRangeForNodeIndex ( const KoSvgTextNodeIndex & node ) const

findRangeForNodeIndex Find the start and end cursor position for a given nodeIndex.

Parameters

node	the tree index to find the range for.

Returns: A QPair<int,int> describing cursor position range encompassed by the tree index and it's children. Will return {-1, -1} when the tree index is invalid.

Definition at line 1515 of file KoSvgTextShape.cpp.

{
    int startIndex = 0;
    int endIndex = 0;
    for (auto child = d->textData.childBegin(); child != d->textData.childEnd(); child++) {
        // count children
        d->startIndexOfIterator(child, node.d->textElement, startIndex);
        endIndex = d->numChars(node.d->textElement) + startIndex;
    }
    return qMakePair(posForIndex(startIndex), posForIndex(endIndex));
}

References d, KoSvgTextNodeIndex::d, and posForIndex().

◆ findTextContentElementForIndex()

static KisForest< KoSvgTextContentElement >::depth_first_tail_iterator KoSvgTextShape::findTextContentElementForIndex	(	KisForest< KoSvgTextContentElement > &	tree,
		int &	currentIndex,
		int	sought,
		bool	skipZeroWidth = false )

inlinestatic

findTextContentElementForIndex Finds the given leaf of the current tree-wide string index.

Parameters

tree	– tree to search in.
currentIndex	– currentIndex, will always be set to the start index of the found element.
sought	– index sought.
skipZeroWidth	– whether to explicitly skip zero-width chunks. Remove text may set this to true, while inserting text into empty chunks requires this to be false.

Returns: iterator – found iterator. Will default to tree end if nothing is found.

Definition at line 730 of file KoSvgTextShape_p.h.

    {
        auto it = tree.depthFirstTailBegin();
        for (; it != tree.depthFirstTailEnd(); it++) {
            if (childCount(siblingCurrent(it)) > 0) {
                continue;
            }
            int length = it->numChars(false);
            if (length == 0 && skipZeroWidth) {
                continue;
            }
 
            if (sought == currentIndex || (sought > currentIndex && sought < currentIndex + length)) {
                break;
            } else {
                currentIndex += length;
            }
        }
        return it;
    }

References KisForestDetail::Forest< T >::depthFirstTailBegin(), KisForestDetail::Forest< T >::depthFirstTailEnd(), and length().

◆ findTopLevelParent()

static KisForest< KoSvgTextContentElement >::child_iterator KoSvgTextShape::findTopLevelParent	(	KisForest< KoSvgTextContentElement >::child_iterator	root,
		KisForest< KoSvgTextContentElement >::child_iterator	child )

inlinestatic

findTopLevelParent Returns the toplevel parent of child that is not root.

Parameters

root	– root under which the toplevel item is.
child	– child for which to search the parent for.

Returns: toplevel parent of child that is itself a child of root, will return childEnd(root) if the child isn't inside root.

Definition at line 866 of file KoSvgTextShape_p.h.

                                                                                                                                         {
        // An earlier version of the code used Hierarchy iterator,
        // but that had too many exceptions when the child was not in the root.
        if (!child.node()) return childEnd(root);
        if (KisForestDetail::parent(child) == root) return child;
        for (auto rootChild = childBegin(root); rootChild != childEnd(root); rootChild++) {
            for (auto leaf = KisForestDetail::tailSubtreeBegin(rootChild);
                 leaf != KisForestDetail::tailSubtreeEnd(rootChild); leaf++) {
                if (siblingCurrent(leaf) == child) {
                    return rootChild;
                }
            }
        }
        return childEnd(root);
    }

References KisForestDetail::BaseIterator< BaseClass, T, Tag, is_const >::node(), KisForestDetail::parent(), KisForestDetail::tailSubtreeBegin(), and KisForestDetail::tailSubtreeEnd().

◆ fontMatchingDisabled()

bool KoSvgTextShape::fontMatchingDisabled ( ) const

fontMatchingDisabled

Returns: whether font matching is disabled for this shape.

Definition at line 2019 of file KoSvgTextShape.cpp.

{
    return d->disableFontMatching;
}

References d.

◆ generateDecorationPaths()

QMap< KoSvgText::TextDecoration, QPainterPath > KoSvgTextShape::generateDecorationPaths	(	const int &	start,
		const int &	end,
		const KoSvgText::ResolutionHandler	resHandler,
		const QVector< CharacterResult > &	result,
		const bool	isHorizontal,
		const KoSvgText::TextDecorations &	decor,
		const KoSvgText::TextDecorationStyle	style = KoSvgText::TextDecorationStyle::Solid,
		const bool	textDecorationSkipInset = false,
		const KoPathShape *	currentTextPath = nullptr,
		const qreal	currentTextPathOffset = 0.0,
		const bool	textPathSide = false,
		const KoSvgText::TextDecorationUnderlinePosition	underlinePosH = KoSvgText::TextDecorationUnderlinePosition::UnderlineAuto,
		const KoSvgText::TextDecorationUnderlinePosition	underlinePosV = KoSvgText::TextDecorationUnderlinePosition::UnderlineAuto )

◆ generateShapes()

static QList< QPainterPath > KoSvgTextShape::generateShapes	(	const QList< KoShape * >	shapesInside,
		const QList< KoShape * >	shapesSubtract,
		const KoSvgTextProperties &	properties )

static

◆ generateTextAreas()

QList< QPainterPath > KoSvgTextShape::generateTextAreas	(	const QList< KoShape * >	shapesInside,
		const QList< KoShape * >	shapesSubtract,
		const KoSvgTextProperties &	props )

static

generateTextAreas Generates text areas with the given shapes and properties. This is used to paint previews in the PaddingMargin strategy.

Parameters

shapesInside	– the shapes inside to compute the text areas from.
shapesSubtract	– the subtract shapes to remove from the text areas.
props	– the properties to use. ShapePadding and ShapeMargin id will be taken from this.

Returns: list of QPainterPaths.

Definition at line 2024 of file KoSvgTextShape.cpp.

{
    return Private::generateShapes(shapesInside, shapesSubtract, props);
}

References shapesInside, and shapesSubtract.

◆ getCursorPos()

CursorPos KoSvgTextShape::getCursorPos ( int pos )

inline

Definition at line 579 of file KoSvgTextShape_p.h.

                                    {
        return cursorPos.at(qBound(0, pos, cursorPos.size()-1));
    }

◆ getLigatureCarets()

static QVector< QPointF > KoSvgTextShape::getLigatureCarets	(	const KoSvgText::ResolutionHandler &	resHandler,
		const bool	isHorizontal,
		raqm_glyph_t &	currentGlyph )

static

◆ getMemento()

KoSvgTextShapeMementoSP KoSvgTextShape::getMemento ( )

Get a memento holding the current textdata and layout info.

Definition at line 1902 of file KoSvgTextShape.cpp.

{
    return KoSvgTextShapeMementoSP(new KoSvgTextShapeMementoImpl(d->textData,
                                                                 d->result,
                                                                 d->lineBoxes,
                                                                 d->cursorPos,
                                                                 d->logicalToVisualCursorPos,
                                                                 d->plainText,
                                                                 d->isBidi,
                                                                 d->initialTextPosition));
}

References d.

◆ getPositionsAndRotationsForRange()

QList< KoSvgTextCharacterInfo > KoSvgTextShape::getPositionsAndRotationsForRange	(	const int	startPos,
		const int	endPos ) const

getPositionsAndRotationsForRange

Parameters

startPos	– start of range.
endPos	– end of range, not inclusive.
includeLastAdvance	– include a transform at the end that represents the last transform+advance.

Returns: list of qpairs, with the first value being the final position, and the second the final rotation.

Definition at line 1444 of file KoSvgTextShape.cpp.

{
    QList<KoSvgTextCharacterInfo> infos;
    if ((startPos < 0 && startPos == endPos) || d->cursorPos.isEmpty()) {
        return infos;
    }
    const int finalPos = d->cursorPos.size()-1;
    const int startIndex = d->getCursorPos(qMin(startPos, endPos)).index;
    const int endIndex = d->getCursorPos(qMax(startPos, endPos)).index;
 
    for (int i = startIndex; i < endIndex; i++) {
        CharacterResult res = d->result.value(i);
        if (!res.addressable) continue;
        infos << infoFromCharacterResult(res, i);
    }
 
    if (endIndex == startIndex) {
        bool final = qMax(startPos, endPos) == finalPos;
        CharacterResult resFinal = final? d->result.last(): d->result.value(startIndex);
        if (resFinal.addressable) {
            infos << infoFromCharacterResult(resFinal, startIndex);
        }
    }
 
    return infos;
}

References CharacterResult::addressable, d, and infoFromCharacterResult().

◆ handleLineBoxAlignment()

static void KoSvgTextShape::handleLineBoxAlignment	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		QVector< CharacterResult > &	result,
		const QVector< LineBox >	lineBoxes,
		int &	currentIndex,
		const bool	isHorizontal,
		const KoSvgTextProperties	resolvedProps )

static

◆ handleShapes()

void KoSvgTextShape::handleShapes	(	const QList< KoShape * > &	sourceShapeList,
		const QList< KoShape * >	referenceList2,
		const QList< KoShape * >	referenceShapeList,
		QList< KoShape * > &	destinationShapeList )

inline

Definition at line 489 of file KoSvgTextShape_p.h.

                                                                                                                                                                                     {
        for (int i = 0; i<sourceShapeList.size(); i++) {
            if (referenceShapeList.contains(referenceList2.at(i))) {
                destinationShapeList.append(sourceShapeList.at(i));
            }
        }
    }

◆ indexForPos()

int KoSvgTextShape::indexForPos ( int pos ) const

indexForPos get the string index for a given cursor position.

Parameters

pos	the cursor position.

Returns: the index in the string.

Definition at line 908 of file KoSvgTextShape.cpp.

{
    if (d->cursorPos.isEmpty() || pos < 0) {
        return -1;
    }
 
    return d->getCursorPos(pos).index;
}

References d.

◆ initialTextPosition()

QPointF KoSvgTextShape::initialTextPosition ( ) const

initialTextPosition Returns the initial text position as per SVG algorithm. The eventual result of this can include transforms or repositioning due to text shapes.

Returns: the initial text position in shape coordinates.

◆ insertNewLinesAtAnchors()

static void KoSvgTextShape::insertNewLinesAtAnchors	(	KisForest< KoSvgTextContentElement > &	tree,
		bool	shapesInside = false )

inlinestatic

insertNewLinesAtAnchors Resolves character transforms and then inserts new lines at each transform that creates a new chunk.

Parameters

tree	– tree to apply to.
shapesInside	– whether we're wrapping in shape.

Definition at line 1142 of file KoSvgTextShape_p.h.

                                                                                                             {
        QVector<KoSvgText::CharTransformation> resolvedTransforms = resolvedTransformsForTree(tree, shapesInside);
 
        auto end = std::make_reverse_iterator(tree.childBegin());
        auto begin = std::make_reverse_iterator(tree.childEnd());
 
        bool inTextPath = false;
        for (; begin != end; begin++) {
            insertNewLinesAtAnchorsImpl(begin, resolvedTransforms, inTextPath);
        }
    }

References KisForestDetail::Forest< T >::childBegin(), and KisForestDetail::Forest< T >::childEnd().

◆ insertNewLinesAtAnchorsImpl()

static void KoSvgTextShape::insertNewLinesAtAnchorsImpl	(	std::reverse_iterator< KisForest< KoSvgTextContentElement >::child_iterator >	current,
		QVector< KoSvgText::CharTransformation > &	resolvedTransforms,
		bool &	inTextPath )

inlinestatic

Because sometimes we have to deal with multiple transforms on a span we only really want to insert newlines when at a content element start. In theory the other transforms can be tested, but this is hard, and semantically it doesn't make sense if a svg text does this.

Definition at line 1154 of file KoSvgTextShape_p.h.

                                                              {
 
        inTextPath = (!current->textPathId.isEmpty());
        auto base = current.base();
        base--;
        if(base != siblingEnd(base)) {
            auto end = std::make_reverse_iterator(childBegin(base));
            auto begin = std::make_reverse_iterator(childEnd(base));
            for (; begin != end; begin++) {
                insertNewLinesAtAnchorsImpl(begin,
                                            resolvedTransforms,
                                            inTextPath);
            }
        }
 
        if (!current->text.isEmpty()) {
            const int total = current->text.size();
 
            for (int i = 0; i < total; i++) {
                const int j = total - (i+1);
                KoSvgText::CharTransformation transform = resolvedTransforms.takeLast();
                bool startsNewChunk = transform.startsNewChunk() && j == 0;
 
                if (inTextPath) {
                    // First transform in path is always absolute, so we don't insert a newline.
                    startsNewChunk = false;
                    inTextPath = false;
                }
                // When there's no new chunk, we're not at the start of the text and there isn't already a line feed, insert a line feed.
                if (startsNewChunk && !resolvedTransforms.isEmpty() && current->text.at(j) != QChar::LineFeed) {
                    current->text.insert(j, "\n");
                }
            }
        }
        current->localTransformations.clear();
    }

◆ insertRichText()

bool KoSvgTextShape::insertRichText	(	int	pos,
		const KoSvgTextShape *	richText,
		bool	inheritPropertiesIfPossible = false )

insertRichText Insert rich text at the given cursor pos. This will first split contents at the given pos before inserting the new rich text.

Parameters

pos	– cursor pos to insert at.
richText	– KoSvgTextShape with rich text data.
inheritPropertiesIfPossible	– toggle whether to inherit rich text if possible.

Returns: whether insertion happened successfully.

Definition at line 1182 of file KoSvgTextShape.cpp.

{
    bool success = false;
    int currentIndex = 0;
    int elementIndex = 0;
    int insertionIndex = 0;
 
    if (isEnd(richText->d->textData.childBegin())) {
        // rich text is empty.
        return success;
    }
 
    if (pos > -1 && !d->cursorPos.isEmpty()) {
        CursorPos cursorPos = d->getCursorPos(pos);
        CharacterResult res = d->result.at(cursorPos.cluster);
        elementIndex = res.plaintTextIndex;
        insertionIndex = cursorPos.index;
        elementIndex = qMin(elementIndex, d->result.size()-1);
    }
 
    KoSvgTextShape::Private::splitContentElement(this->d->textData, insertionIndex);
 
    auto it = d->findTextContentElementForIndex(d->textData, currentIndex, insertionIndex);
    auto richTextIt = d->textData.childEnd();
    if (it != d->textData.depthFirstTailEnd()) {
        richTextIt = d->textData.move(richText->d->textData.childBegin(), siblingCurrent(it));
        success = true;
    } else {
        currentIndex = 0;
        it = d->findTextContentElementForIndex(d->textData, currentIndex, elementIndex);
        if (it != d->textData.depthFirstTailEnd()) {
            richTextIt = d->textData.move(richText->d->textData.childBegin(), siblingEnd(siblingCurrent(it)));
            success = true;
        }
    }
 
    if (richTextIt != d->textData.childEnd()) {
        Q_FOREACH (const KoSvgTextProperties::PropertyId p, richTextIt->properties.properties()) {
            if (KoSvgTextProperties::propertyIsBlockOnly(p)) {
                richTextIt->properties.removeProperty(p);
            }
        }
        auto parentIt = KisForestDetail::hierarchyBegin(richTextIt);
        auto parentEnd = KisForestDetail::hierarchyEnd(richTextIt);
        if (parentIt != parentEnd) {
            parentIt++;
            if (inheritPropertiesIfPossible && parentIt != parentEnd) {
                Q_FOREACH (const KoSvgTextProperties::PropertyId p, richTextIt->properties.properties()) {
                    if (richTextIt->properties.inheritsProperty(p, parentIt->properties)) {
                        richTextIt->properties.removeProperty(p);
                    }
                }
            }
        }
    }
 
    if (success) {
        notifyChanged();
        shapeChangedPriv(ContentChanged);
    }
    return success;
}

References KoShape::ContentChanged, cursorPos, d, KisForestDetail::hierarchyBegin(), KisForestDetail::hierarchyEnd(), KoShape::notifyChanged(), p, CharacterResult::plaintTextIndex, KoSvgTextProperties::propertyIsBlockOnly(), and KoShape::shapeChangedPriv().

◆ insertText()

bool KoSvgTextShape::insertText	(	int	pos,
		QString	text )

insertText Insert a text somewhere in the KoTextShape.

Parameters

pos	the cursor position.
text	the text to insert.

Returns: whether it was successful in inserting text.

< Current position of the search.

The distinction between element and insertion index allows us to insert text at the start or end of a content element, without ambiguity on whether we're inserting into the next element.

Definition at line 922 of file KoSvgTextShape.cpp.

{
    bool success = false;
    int currentIndex = 0; 
 
    int elementIndex = 0;
    int insertionIndex = 0;
    if (pos > -1 && !d->cursorPos.isEmpty()) {
        CursorPos cursorPos = d->getCursorPos(pos);
        CharacterResult res = d->result.at(cursorPos.cluster);
        elementIndex = res.plaintTextIndex;
        insertionIndex = cursorPos.index;
        elementIndex = qMin(elementIndex, d->result.size()-1);
    }
    auto it = d->findTextContentElementForIndex(d->textData, currentIndex, elementIndex);
    if (it != d->textData.depthFirstTailEnd()) {
        const int offset = insertionIndex - currentIndex;
        it->insertText(offset, text);
 
        d->insertTransforms(d->textData, insertionIndex, text.size(), (elementIndex == insertionIndex));
        notifyChanged();
        shapeChangedPriv(ContentChanged);
        success = true;
    }
    return success;
}

References KoShape::ContentChanged, cursorPos, d, KoShape::notifyChanged(), CharacterResult::plaintTextIndex, and KoShape::shapeChangedPriv().

◆ insertTransforms()

static void KoSvgTextShape::insertTransforms	(	KisForest< KoSvgTextContentElement > &	tree,
		const int	start,
		const int	length,
		const bool	allowSkipFirst )

inlinestatic

insertTransforms Inserts empty transforms into tree recursively.

Parameters

tree	– tree to insert transforms on.
start	– start index.
length	– amount of transforms to insert.
allowSkipFirst	– whether we're allowed to skip the first transform because it is at the start of a text element.

Definition at line 1001 of file KoSvgTextShape_p.h.

                                                                                                                                         {
        QString all;
        QVector<bool> collapsedCharacters = collapsedWhiteSpacesForText(tree, all, true);
 
        auto root = tree.childBegin();
        insertTransformsImpl(root, 0, start, length, collapsedCharacters, allowSkipFirst);
    }

References KisForestDetail::Forest< T >::childBegin(), and length().

◆ insertTransformsImpl()

static int KoSvgTextShape::insertTransformsImpl	(	KisForest< KoSvgTextContentElement >::child_iterator	currentTextElement,
		const int	globalIndex,
		const int	start,
		const int	length,
		const QVector< bool >	collapsedCharacters,
		const bool	allowSkipFirst )

inlinestatic

insertTransformsImpl Recursive function that handles inserting empty transforms into a given range. Used by insertTransforms.

Definition at line 1013 of file KoSvgTextShape_p.h.

                                                                                                                                                                                                                                       {
        int currentLength = 0;
        auto it = childBegin(currentTextElement);
        if (it != childEnd(currentTextElement)) {
            for (; it != childEnd(currentTextElement); it++) {
                currentLength += insertTransformsImpl(it, globalIndex + currentLength, start, length, collapsedCharacters, allowSkipFirst);
            }
        } else {
            currentLength = currentTextElement->text.size();
        }
 
        if (!currentTextElement->localTransformations.isEmpty()) {
            int transformOffset = 0;
            int transformOffsetEnd = 0;
 
            for (int i = globalIndex; i < globalIndex + currentLength; i++) {
                if (i < start) {
                    transformOffset += collapsedCharacters.at(i)? 0: 1;
                }
                if (i < start + length) {
                    transformOffsetEnd += collapsedCharacters.at(i)? 0: 1;
                } else {
                    break;
                }
            }
 
            // When at the start, skip the first transform.
            if (transformOffset == 0 && allowSkipFirst && currentTextElement->localTransformations.at(0).startsNewChunk()) {
                transformOffset += 1;
            }
 
            if (transformOffset < currentTextElement->localTransformations.size()) {
                for (int i = transformOffset; i < transformOffsetEnd; i++) {
                    currentTextElement->localTransformations.insert(i, KoSvgText::CharTransformation());
                }
            }
 
        }
        return currentLength;
    }

References length().

◆ internalShapeManager()

KoShapeManager * KoSvgTextShape::internalShapeManager ( ) const

internalShapeManager

Returns: access the internal shapes manager for the contour shapes.

Definition at line 2578 of file KoSvgTextShape.cpp.

{
    return d->internalShapesPainter->internalShapeManager();
}

References d.

◆ internalShapes()

QList< KoShape * > KoSvgTextShape::internalShapes ( ) const

inline

Definition at line 518 of file KoSvgTextShape_p.h.

                                           {
        return internalShapesPainter->internalShapeManager()->shapes();
    }

◆ iteratorForTreeIndex()

static KisForest< KoSvgTextContentElement >::child_iterator KoSvgTextShape::iteratorForTreeIndex	(	const QVector< int >	treeIndex,
		KisForest< KoSvgTextContentElement >::child_iterator	parent )

inlinestatic

Definition at line 1355 of file KoSvgTextShape_p.h.

                                                                                                                                                                        {
        if (treeIndex.isEmpty()) return parent;
        QVector<int> idx = treeIndex;
        int count = idx.takeFirst();
        for (auto child = KisForestDetail::childBegin(parent); child != KisForestDetail::childEnd(parent); child++) {
            if (count == 0) {
                if ((KisForestDetail::childBegin(child) != KisForestDetail::childEnd(child))) {
                    return iteratorForTreeIndex(idx, child);
                } else {
                    return child;
                }
            }
            count -= 1;
        }
        return KisForestDetail::childEnd(parent);
    }

References KisForestDetail::childBegin(), and KisForestDetail::childEnd().

◆ leaveNodeSubtree()

void KoSvgTextShape::leaveNodeSubtree ( )

Set the current node to its parent, leaving the subtree.

Definition at line 1897 of file KoSvgTextShape.cpp.

{
 
}

◆ lineEnd()

int KoSvgTextShape::lineEnd ( int pos )

lineEnd return the 'line end' for this pos. This uses anchored chunks, so each absolute x, y posititioning will be considered a line-start.

Parameters

pos	– the cursor pos for which to find the line end.

Returns: the line end.

Definition at line 342 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || d->cursorPos.isEmpty() || d->result.isEmpty()) {
        return pos;
    }
    if (pos > d->cursorPos.size() - 1) {
        return d->cursorPos.size() - 1;
    }
    int candidate = 0;
    int posCluster = d->getCursorPos(pos).cluster;
    for (int i = pos; i < d->cursorPos.size(); i++) {
        CursorPos p = d->cursorPos.at(i);
        if (d->result.at(p.cluster).anchored_chunk && i > pos && posCluster != p.cluster) {
            break;
        }
        candidate = i;
    }
    return candidate;
}

References cursorPos, d, and p.

◆ lineStart()

int KoSvgTextShape::lineStart ( int pos )

lineStart return the 'line start' for this pos. This uses anchored chunks, so each absolute x, y posititioning will be considered a line-start.

Parameters

pos	– the cursor pos for which to find the line start.

Returns: the line start.

Definition at line 323 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || d->cursorPos.isEmpty() || d->result.isEmpty()) {
        return pos;
    }
    CursorPos p = d->getCursorPos(pos);
    if (d->result.at(p.cluster).anchored_chunk && p.offset == 0) {
        return pos;
    }
    int candidate = 0;
    for (int i = 0; i < pos; i++) {
        CursorPos p2 = d->getCursorPos(i);
        if (d->result.at(p2.cluster).anchored_chunk && p2.offset == 0) {
            candidate = i;
        }
    }
    return candidate;
}

References cursorPos, d, p, and p2.

◆ loadGlyph()

static bool KoSvgTextShape::loadGlyph	(	const KoSvgText::ResolutionHandler &	resHandler,
		const FT_Int32	faceLoadFlags,
		const bool	isHorizontal,
		const char32_t	firstCodepoint,
		const KoSvgText::TextRendering	rendering,
		raqm_glyph_t &	currentGlyph,
		CharacterResult &	charResult,
		QPointF &	totalAdvanceFTFontCoordinates )

static

◆ loadGlyphOnly()

static std::pair< QTransform, qreal > KoSvgTextShape::loadGlyphOnly	(	const QTransform &	ftTF,
		FT_Int32	faceLoadFlags,
		bool	isHorizontal,
		raqm_glyph_t &	currentGlyph,
		CharacterResult &	charResult,
		const KoSvgText::TextRendering	rendering )

static

◆ makeTextPathNameUnique()

static void KoSvgTextShape::makeTextPathNameUnique	(	QList< KoShape * >	textPaths,
		KoShape *	textPath )

inlinestatic

Definition at line 1402 of file KoSvgTextShape_p.h.

                                                                                     {
        bool textPathNameUnique = false;
        int textPathNumber = textPaths.size();
        QString newTextPathName = textPath->name();
        while(!textPathNameUnique) {
            textPathNameUnique = true;
            Q_FOREACH(KoShape *shape, textPaths) {
                if (shape->name() == newTextPathName) {
                    textPathNameUnique = false;
                    textPathNumber += 1;
                    break;
                }
            }
            if (textPathNameUnique && !newTextPathName.isEmpty()) {
                textPath->setName(newTextPathName);
            } else {
                textPathNameUnique = false;
            }
            newTextPathName = QString("textPath"+QString::number(textPathNumber));
        }
    }

References KoShape::name(), and KoShape::setName().

◆ mergePropertiesIntoRange()

void KoSvgTextShape::mergePropertiesIntoRange	(	const int	startPos,
		const int	endPos,
		const KoSvgTextProperties	properties,
		const QSet< KoSvgTextProperties::PropertyId >	removeProperties = QSet<KoSvgTextProperties::PropertyId>() )

mergePropertiesIntoRange Merge given properties into the given range. This will first split the nodes at the two range ends, and then merge in the properties into each leaf node. Won't do anything when startPos == endPos

First, the properties in removeProperties list will be removed, then properties in properties will be applied. If the property is present in both lists, then the value from properties will be used.

Parameters

startPos	– cursor pos start.
endPos	– cursor pos end.
properties	– properties to merge in.
removeProperties	– optional list of properties to remove, these will always apply after merging.

Definition at line 1090 of file KoSvgTextShape.cpp.

{
    if ((startPos < 0 && startPos == endPos) || d->cursorPos.isEmpty()) {
        if (KisForestDetail::size(d->textData)) {
            Q_FOREACH(KoSvgTextProperties::PropertyId p, properties.properties()) {
                d->textData.childBegin()->properties.setProperty(p, properties.property(p));
            }
            Q_FOREACH(KoSvgTextProperties::PropertyId p, removeProperties) {
                d->textData.childBegin()->properties.removeProperty(p);
            }
        }
        notifyChanged();
        if (properties.hasProperty(KoSvgTextProperties::ShapePaddingId)
                || properties.hasProperty(KoSvgTextProperties::ShapeMarginId)
                || removeProperties.contains(KoSvgTextProperties::ShapePaddingId)
                || removeProperties.contains(KoSvgTextProperties::ShapeMarginId)) {
            shapeChangedPriv(TextContourMarginChanged);
        } else {
            shapeChangedPriv(ContentChanged);
        }
        if (properties.hasProperty(KoSvgTextProperties::FillId)) {
            shapeChangedPriv(BackgroundChanged);
        }
        if (properties.hasProperty(KoSvgTextProperties::StrokeId)) {
            shapeChangedPriv(StrokeChanged);
        }
        return;
    }
    const int startIndex =d->getCursorPos(startPos).index;
    const int endIndex = d->getCursorPos(endPos).index;
    if (startIndex != endIndex) {
        KoSvgTextShape::Private::splitContentElement(d->textData, startIndex);
        KoSvgTextShape::Private::splitContentElement(d->textData, endIndex);
    }
    bool changed = false;
    int currentIndex = 0;
    KoSvgText::AutoValue inlineSize = d->textData.childBegin()->properties.propertyOrDefault(KoSvgTextProperties::InlineSizeId).value<KoSvgText::AutoValue>();
    bool isWrapping = !d->shapesInside.isEmpty() || !inlineSize.isAuto;
    for (auto it = d->textData.depthFirstTailBegin(); it != d->textData.depthFirstTailEnd(); it++) {
        if (KoSvgTextShape::Private::childCount(siblingCurrent(it)) > 0) {
            continue;
        }
 
        if (currentIndex >= startIndex && currentIndex < endIndex) {
            Q_FOREACH(KoSvgTextProperties::PropertyId p, removeProperties) {
                if (KoSvgTextProperties::propertyIsBlockOnly(p)) {
                    d->textData.childBegin()->properties.removeProperty(p);
                } else {
                    it->properties.removeProperty(p);
                }
            }
            Q_FOREACH(KoSvgTextProperties::PropertyId p, properties.properties()) {
                if (KoSvgTextProperties::propertyIsBlockOnly(p) || (p == KoSvgTextProperties::TextAnchorId && isWrapping)) {
                    d->textData.childBegin()->properties.setProperty(p, properties.property(p));
                } else {
                    it->properties.setProperty(p, properties.property(p));
                }
            }
 
            changed = true;
        }
        currentIndex += it->numChars(false);
    }
 
    if (changed){
        KoSvgTextShape::Private::cleanUp(d->textData);
        notifyChanged();
        shapeChangedPriv(ContentChanged);
        if (properties.hasProperty(KoSvgTextProperties::FillId)) {
            shapeChangedPriv(BackgroundChanged);
        }
        if (properties.hasProperty(KoSvgTextProperties::StrokeId)) {
            shapeChangedPriv(StrokeChanged);
        }
    }
}

◆ moveShapeInsideToIndex()

void KoSvgTextShape::moveShapeInsideToIndex	(	KoShape *	shapeInside,
		const int	index )

moveShapeInsideToIndex Because the order of shapes inside shape-inside affects the text layout, it can be useful to be able to reorder them.

Parameters

shapeInside	– shape from the shapesInside list. This function will do nothing
index	– new index to move the shape inside to. Will be bound to the list size.

@seealso shapesInside();

Definition at line 2421 of file KoSvgTextShape.cpp.

{
    const int oldIndex = d->shapesInside.indexOf(shapeInside);
    if (oldIndex < 0) return;
 
    // Update.
    d->shapesInside.move(oldIndex, index);
    if (!d->isLoading) {
        d->updateTextWrappingAreas();
    }
    d->updateInternalShapesList();
    shapeChangedPriv(ContentChanged);
    update();
}

References KoShape::ContentChanged, d, KoShape::shapeChangedPriv(), and KoShape::update().

◆ nextIndex()

int KoSvgTextShape::nextIndex ( int pos )

nextIndex Return the first cursor position with a higher string index.

Parameters

pos	the cursor position.

Returns: the first pos with a higher cluster or same cluster and higher offset.

Definition at line 389 of file KoSvgTextShape.cpp.

{
    if (d->cursorPos.isEmpty()) {
        return pos;
    }
    int currentIndex = d->getCursorPos(pos).index;
 
    for (int i = pos; i < d->cursorPos.size(); i++) {
        if (d->cursorPos.at(i).index > currentIndex) {
            return i;
        }
    }
    return pos;
}

References d.

◆ nextLine()

int KoSvgTextShape::nextLine ( int pos )

nextLine get a position on the next line for this position.

Parameters

pos	– cursor position.

Returns: the pos on the next line;

Definition at line 447 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || pos > d->cursorPos.size()-1 || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
 
    int nextLineStart = lineEnd(pos)+1;
    int nextLineEnd = lineEnd(nextLineStart);
    CursorPos cursorPos = d->getCursorPos(pos);
    if (!this->shapesInside().isEmpty()) {
        LineBox nextLineBox;
        for (int i = 0; i < d->lineBoxes.size(); ++i) {
            for (int j = 0; j < d->lineBoxes.at(i).chunks.size(); ++j) {
                if (d->lineBoxes.at(i).chunks.at(j).chunkIndices.contains(cursorPos.cluster)) {
                    nextLineBox = d->lineBoxes.at(qMin(i + 1, d->lineBoxes.size()-1));
                }
            }
        }
        if (nextLineBox.chunks.size()>0) {
            int first = -1;
            int last = -1;
            Q_FOREACH(LineChunk chunk, nextLineBox.chunks) {
                Q_FOREACH (int i, chunk.chunkIndices) {
                    if (d->result.at(i).addressable) {
                        if (first < 0) {
                            first = d->result.at(i).cursorInfo.graphemeIndices.first();
                        }
                        last = d->result.at(i).cursorInfo.graphemeIndices.last();
                    }
                }
            }
            if (first > -1 && last > -1) {
                nextLineStart = posForIndex(first);
                nextLineEnd = posForIndex(last);
            }
        }
    }
 
 
    if (nextLineStart > d->cursorPos.size()-1) {
        return d->cursorPos.size()-1;
    }
 
    CharacterResult res = d->result.at(cursorPos.cluster);
    QPointF currentPoint = res.finalPosition;
    currentPoint += res.cursorInfo.offsets.value(cursorPos.offset, res.advance);
    int candidate = posForPoint(currentPoint, nextLineStart, nextLineEnd+1);
    if (candidate < 0) {
        return pos;
    }
 
    return candidate;
}

References CharacterResult::advance, LineChunk::chunkIndices, LineBox::chunks, CharacterResult::cursorInfo, cursorPos, d, CharacterResult::finalPosition, lineEnd(), CursorInfo::offsets, posForIndex(), posForPoint(), and shapesInside.

◆ nextPos()

int KoSvgTextShape::nextPos	(	int	pos,
		bool	visual )

private

nextPos get the next position.

Parameters

pos	– cursor position.

Returns: the next pos;

Definition at line 419 of file KoSvgTextShape.cpp.

{
    if (d->cursorPos.isEmpty()) {
        return -1;
    }
 
    if(visual) {
        int visualIndex = d->logicalToVisualCursorPos.value(pos);
        return d->logicalToVisualCursorPos.key(qMin(visualIndex + 1, d->cursorPos.size() - 1), d->cursorPos.size() - 1);
    }
 
    return qMin(pos + 1, d->cursorPos.size() - 1);
}

References d.

◆ nodeForTextPath()

KoSvgTextNodeIndex KoSvgTextShape::nodeForTextPath ( KoShape * textPath ) const

nodeForTextPath TextPaths are set on toplevel content elements. This function allows for searching which node has said textPath, which should be less clunky than running topLevelNodeForPos for every pos.

Parameters

textPath – the text path to find the node for.

Returns: toplevel node that has the given shape set at it's text path. Returns the root node when none is found.

Definition at line 1549 of file KoSvgTextShape.cpp.

{
    auto root = d->textData.childBegin();
    if (d->isLoading || d->cursorPos.isEmpty()) return d->createTextNodeIndex(root);
 
    for (auto child = childBegin(root); child != childEnd(root); child++) {
        if (child->textPathId == textPath->name()) {
            return d->createTextNodeIndex(child);
        }
    }
    return d->createTextNodeIndex(root);
}

References d, and KoShape::name().

◆ notifyCursorPosChanged()

void KoSvgTextShape::notifyCursorPosChanged	(	int	pos,
		int	anchor )

Notify that the cursor position has changed.

Definition at line 1663 of file KoSvgTextShape.cpp.

{
    if (d->isLoading) {
        return;
    }
    Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
        TextCursorChangeListener *cursorListener = dynamic_cast<TextCursorChangeListener*>(listener);
        if (cursorListener) {
            cursorListener->notifyCursorPosChanged(pos, anchor);
        }
    }
}

References KoShape::anchor(), d, KoShape::Private::listeners, and KoSvgTextShape::TextCursorChangeListener::notifyCursorPosChanged().

◆ notifyMarkupChanged()

void KoSvgTextShape::notifyMarkupChanged ( )

Notify that the markup has changed.

Definition at line 1676 of file KoSvgTextShape.cpp.

{
    if (d->isLoading) {
        return;
    }
    Q_FOREACH (KoShape::ShapeChangeListener *listener, listeners()) {
        TextCursorChangeListener *cursorListener = dynamic_cast<TextCursorChangeListener*>(listener);
        if (cursorListener) {
            cursorListener->notifyMarkupChanged();
        }
    }
}

References d, KoShape::Private::listeners, and KoSvgTextShape::TextCursorChangeListener::notifyMarkupChanged().

◆ numChars()

static int KoSvgTextShape::numChars	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		bool	withControls = false,
		KoSvgTextProperties	resolvedProps = KoSvgTextProperties::defaultProperties() )

inlinestatic

Get the number of characters for the whole subtree of this node.

Definition at line 702 of file KoSvgTextShape_p.h.

                                                                                                                                                                                        {
        KoSvgTextProperties props = parent->properties;
        props.inheritFrom(resolvedProps, true);
        int count = parent->numChars(withControls, props);
        for (auto it = KisForestDetail::childBegin(parent); it != KisForestDetail::childEnd(parent); it++) {
            count += numChars(it, withControls, props);
        }
        return count;
    }

References KisForestDetail::childBegin(), KisForestDetail::childEnd(), and KoSvgTextProperties::inheritFrom().

◆ outline()

QPainterPath KoSvgTextShape::outline ( ) const

overridevirtual

returns the outline of the shape in the form of a path. The outline returned will always be relative to the position() of the shape, so moving the shape will not alter the result. The outline is used to draw the stroke on, for example.

Returns: the outline of the shape in the form of a path.

Reimplemented from KoShape.

Definition at line 2096 of file KoSvgTextShape.cpp.

                                           {
    QPainterPath result;
    if (!d->internalShapes().isEmpty()) {
        Q_FOREACH(KoShape *shape, d->internalShapes()) {
            result.addPath(shape->transformation().map(shape->outline()));
        }
    }
 
    if ((d->shapesInside.isEmpty() && d->shapesSubtract.isEmpty())) {
        for (auto it = d->textData.depthFirstTailBegin(); it != d->textData.depthFirstTailEnd(); it++) {
            result.addPath(it->associatedOutline);
            for (int i = 0; i < it->textDecorations.values().size(); ++i) {
                result.addPath(it->textDecorations.values().at(i));
            }
        }
    }
 
    return result;
}

References d, KoShape::outline(), result, and KoShape::transformation().

◆ outlineRect()

QRectF KoSvgTextShape::outlineRect ( ) const

overridevirtual

returns the outline of the shape in the form of a rect. The outlineRect returned will always be relative to the position() of the shape, so moving the shape will not alter the result. The outline is used to calculate the boundingRect.

Returns: the outline of the shape in the form of a rect.

Reimplemented from KoShape.

Definition at line 2115 of file KoSvgTextShape.cpp.

{
    return outline().boundingRect();
}

References outline().

◆ paint()

void KoSvgTextShape::paint ( QPainter & painter ) const

overridevirtual

Paint the shape fill The class extending this one is responsible for painting itself. painter is expected to be preconfigured to work in "document" pixels.

Parameters

painter used for painting the shape

Implements KoShape.

Definition at line 2057 of file KoSvgTextShape.cpp.

{
    painter.save();
 
    painter.setTransform(d->shapeGroup->absoluteTransformation().inverted()*painter.transform());
    d->internalShapesPainter->paint(painter);
    painter.restore();
 
    painter.save();
    KoSvgText::TextRendering textRendering = KoSvgText::TextRendering(textProperties().propertyOrDefault(KoSvgTextProperties::TextRenderingId).toInt());
    if (textRendering == KoSvgText::RenderingOptimizeSpeed || !painter.testRenderHint(QPainter::Antialiasing)) {
        // also apply antialiasing only if antialiasing is active on provided target QPainter
        painter.setRenderHint(QPainter::Antialiasing, false);
        painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
    } else {
        painter.setRenderHint(QPainter::Antialiasing, true);
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    }
 
    QPainterPath chunk;
    int currentIndex = 0;
    if (!d->result.isEmpty()) {
        QPainterPath rootBounds;
        rootBounds.addRect(Private::boundingBoxFromTree(d->textData, this, false));
        d->paintTextDecoration(painter, rootBounds, this, KoSvgText::DecorationUnderline, textRendering);
        d->paintTextDecoration(painter, rootBounds, this, KoSvgText::DecorationOverline, textRendering);
        d->paintPaths(painter, rootBounds, this, d->result, textRendering, chunk, currentIndex);
        d->paintTextDecoration(painter, rootBounds, this, KoSvgText::DecorationLineThrough, textRendering);
    }
 
    painter.restore();
}

References d, KoSvgText::DecorationLineThrough, KoSvgText::DecorationOverline, KoSvgText::DecorationUnderline, KoSvgText::RenderingOptimizeSpeed, textProperties(), and KoSvgTextProperties::TextRenderingId.

◆ paintDebug() [1/2]

void KoSvgTextShape::paintDebug	(	QPainter &	painter,
		const QVector< CharacterResult > &	result,
		int &	currentIndex )

◆ paintDebug() [2/2]

void KoSvgTextShape::paintDebug	(	QPainter &	painter,
		DebugElements	elements ) const

Definition at line 2260 of file KoSvgTextShape.cpp.

{
    if (elements & DebugElement::CharBbox) {
        int currentIndex = 0;
        if (!d->result.isEmpty()) {
            QPainterPath rootBounds;
            rootBounds.addRect(this->outline().boundingRect());
            d->paintDebug(painter, d->result, currentIndex);
        }
 
        //Debug shape outlines.
        Q_FOREACH (KoShape *shapeInside, d->shapesInside) {
            QPainterPath p = shapeInside->outline();
            p = shapeInside->transformation().map(p);
            painter.strokePath(p, QPen(Qt::green));
        }
        Q_FOREACH (KoShape *shapeInside, d->shapesSubtract) {
            QPainterPath p = shapeInside->outline();
            p = shapeInside->transformation().map(p);
            painter.strokePath(p, QPen(Qt::red));
        }
    }
 
    if (elements & DebugElement::LineBox) {
        Q_FOREACH (LineBox lineBox, d->lineBoxes) {
            Q_FOREACH (const LineChunk &chunk, lineBox.chunks) {
                QPen pen;
                pen.setCosmetic(true);
                pen.setWidth(2);
                painter.setBrush(QBrush(Qt::transparent));
                pen.setColor(QColor(0, 128, 255, 128));
                painter.setPen(pen);
                painter.drawLine(chunk.length);
                pen.setColor(QColor(255, 128, 0, 128));
                painter.setPen(pen);
                painter.drawRect(chunk.boundingBox);
 
                pen.setColor(QColor(255, 0, 0, 128));
                pen.setStyle(Qt::DashDotDotLine);
                painter.setPen(pen);
                painter.drawLine(chunk.length.translated(lineBox.baselineTop));
                pen.setColor(QColor(0, 128, 0, 128));
                pen.setStyle(Qt::DashDotLine);
                painter.setPen(pen);
                painter.drawLine(chunk.length.translated(lineBox.baselineBottom));
            }
        }
    }
}

References LineBox::baselineBottom, LineBox::baselineTop, LineChunk::boundingBox, boundingRect(), CharBbox, LineBox::chunks, d, LineChunk::length, LineBox, KoShape::outline(), outline(), p, and KoShape::transformation().

◆ paintOrder()

QVector< KoShape::PaintOrder > KoSvgTextShape::paintOrder ( ) const

overridevirtual

paintOrder

Returns: vector of paint orders, will always be 3 big and contain a fill, stroke and marker entry.

Reimplemented from KoShape.

Definition at line 1605 of file KoSvgTextShape.cpp.

{
    KoSvgTextProperties props = KisForestDetail::size(d->textData)? d->textData.childBegin()->properties: KoSvgTextProperties();
    if (props.hasProperty(KoSvgTextProperties::PaintOrder)) {
        return props.property(KoSvgTextProperties::PaintOrder).value<QVector<KoShape::PaintOrder>>();
    }
    return KoShape::paintOrder();
}

References d, KoSvgTextProperties::hasProperty(), KoShape::paintOrder(), KoSvgTextProperties::PaintOrder, KoSvgTextProperties::properties(), KoSvgTextProperties::property(), and KisForestDetail::size().

◆ paintPaths()

void KoSvgTextShape::paintPaths	(	QPainter &	painter,
		const QPainterPath &	outlineRect,
		const KoShape *	rootShape,
		const QVector< CharacterResult > &	result,
		const KoSvgText::TextRendering	rendering,
		QPainterPath &	chunk,
		int &	currentIndex )

◆ paintStroke()

void KoSvgTextShape::paintStroke ( QPainter & painter ) const

overridevirtual

paintStroke paints the shape's stroked outline

Parameters

painter used for painting the shape

See also: applyConversion()

Reimplemented from KoShape.

Definition at line 2090 of file KoSvgTextShape.cpp.

{
    Q_UNUSED(painter);
    // do nothing! everything is painted in paint()
}

◆ paintTextDecoration()

void KoSvgTextShape::paintTextDecoration	(	QPainter &	painter,
		const QPainterPath &	outlineRect,
		const KoShape *	rootShape,
		const KoSvgText::TextDecoration	type,
		const KoSvgText::TextRendering	rendering )

◆ plainText()

QString KoSvgTextShape::plainText ( )

plainText plain text of all text inside this text shape, without the bidi controls or any transforms.

Returns: a string of plain text.

◆ posDown()

int KoSvgTextShape::posDown	(	int	pos,
		bool	visual = false )

return position below.

Definition at line 308 of file KoSvgTextShape.cpp.

{
    KoSvgText::WritingMode mode = writingMode();
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    if (mode == KoSvgText::VerticalRL || mode == KoSvgText::VerticalLR) {
        if (direction == KoSvgText::DirectionRightToLeft) {
            return previousPos(pos, visual);
        } else {
            return nextPos(pos, visual);
        }
    } else {
        return nextLine(pos);
    }
}

References direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, nextLine(), nextPos(), previousPos(), textProperties(), KoSvgText::VerticalLR, KoSvgText::VerticalRL, and writingMode().

◆ posForIndex()

int KoSvgTextShape::posForIndex	(	int	index,
		bool	firstIndex = false,
		bool	skipSynthetic = false ) const

posForIndex Get the cursor position for a given index in a string.

Parameters

index	– index in the string.
firstIndex	– whether to return for the first instance of the index.
skipSynthetic	– whether to skip over synthetic cursorPositions.

Returns: the cursor – position for an index.

Definition at line 885 of file KoSvgTextShape.cpp.

{
    int pos = -1;
    if (d->cursorPos.isEmpty() || index < 0) {
        return pos;
    }
    for (int i = 0; i< d->cursorPos.size(); i++) {
        if (skipSynthetic && d->cursorPos.at(i).synthetic) {
            continue;
        }
        if (d->cursorPos.at(i).index <= index) {
            pos = i;
            if (d->cursorPos.at(i).index == index && firstIndex) {
                break;
            }
        } else if (d->cursorPos.at(i).index > index) {
            break;
        }
    }
 
    return pos;
}

References d.

◆ posForPoint()

int KoSvgTextShape::posForPoint	(	QPointF	point,
		int	start = -1,
		int	end = -1,
		bool *	overlaps = nullptr )

posForPoint Finds the closest cursor position for the given point in shape coordinates.

Parameters

point
start	– optional start position;
end	– optional end position;
overlaps	– optional bool that is set if the point overlaps any glyph box.

Returns: the closest cursor position.

Definition at line 814 of file KoSvgTextShape.cpp.

{
    int a = 0;
    int b = d->cursorPos.size();
    if (start >= 0 && end >= 0) {
        a = qMax(start, a);
        b = qMin(end, b);
    }
    double closest = std::numeric_limits<double>::max();
    int candidate = 0;
    for (int i = a; i < b; i++) {
        CursorPos pos = d->getCursorPos(i);
        CharacterResult res = d->result.at(pos.cluster);
        QPointF cursorStart = res.finalPosition;
        cursorStart += res.cursorInfo.offsets.value(pos.offset, res.advance);
        double distance = kisDistance(cursorStart, point);
        if (distance < closest) {
            candidate = i;
            closest = distance;
            if (overlaps) {
               *overlaps = res.finalTransform().map(res.layoutBox()).containsPoint(point, Qt::WindingFill);
            }
        }
    }
    return candidate;
}

References CharacterResult::advance, CursorPos::cluster, CharacterResult::cursorInfo, d, distance(), CharacterResult::finalPosition, CharacterResult::finalTransform(), kisDistance(), CharacterResult::layoutBox(), CursorPos::offset, and CursorInfo::offsets.

◆ posForPointLineSensitive()

int KoSvgTextShape::posForPointLineSensitive ( QPointF point )

posForPointLineSensitive When clicking on an empty space in a wrapped text, it is preferable to have the caret be at the end of the line visually associated with that empty space than the positions above or below that might be closer.

Because SVG has several situations where there's no real lines, we first test for the closest cursorpos and also whether there's an actual overlap with a glyph. If there's no such overlap, we test against whether there's an anchored chunk in the inline direction, and if so search the line resulting from that. If not, we return the closest pos.

Parameters

point the point in shape coordinates.

Returns: the closest pos, taking into account any line starts or ends.

Definition at line 841 of file KoSvgTextShape.cpp.

{
    bool overlaps = false;
    int initialPos = posForPoint(point, -1, -1, &overlaps);
 
    if (overlaps) {
        return initialPos;
    }
 
    KoSvgText::WritingMode mode = writingMode();
 
    int candidateLineStart = 0;
    double closest = std::numeric_limits<double>::max();
    for (int i = 0; i < d->cursorPos.size(); i++) {
        CursorPos pos = d->cursorPos.at(i);
        CharacterResult res = d->result.at(pos.cluster);
        if (res.anchored_chunk) {
            QLineF caret = res.cursorInfo.caret;
            caret.translate(res.finalPosition);
            QPointF cursorStart = res.finalPosition;
            cursorStart += res.cursorInfo.offsets.value(pos.offset, res.advance);
            double distance = kisDistance(cursorStart, point);
            if (mode == KoSvgText::HorizontalTB) {
                if (caret.p1().y() > point.y() && caret.p2().y() <= point.y() && closest > distance) {
                    candidateLineStart = i;
                    closest = distance;
                }
            } else {
                if (caret.p2().x() > point.x() && caret.p1().x() <= point.x() && closest > distance) {
                    candidateLineStart = i;
                    closest = distance;
                }
            }
        }
    }
 
    if (candidateLineStart > -1) {
        int end = lineEnd(candidateLineStart);
        initialPos = posForPoint(point, candidateLineStart, qMin(end + 1, d->cursorPos.size()));
    }
 
    return initialPos;
}

References CharacterResult::advance, CharacterResult::anchored_chunk, CursorInfo::caret, CursorPos::cluster, CharacterResult::cursorInfo, d, distance(), CharacterResult::finalPosition, KoSvgText::HorizontalTB, kisDistance(), lineEnd(), CursorPos::offset, CursorInfo::offsets, posForPoint(), and writingMode().

◆ posLeft()

int KoSvgTextShape::posLeft	(	int	pos,
		bool	visual = false )

return position to the left; visual indicates whether to use logical ('previous') or visual left (depending on direction).

Definition at line 258 of file KoSvgTextShape.cpp.

{
    KoSvgText::WritingMode mode = writingMode();
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    if (mode == KoSvgText::VerticalRL) {
        return nextLine(pos);
    } else if (mode == KoSvgText::VerticalLR) {
        return previousLine(pos);
    } else {
        if (direction == KoSvgText::DirectionRightToLeft) {
            return nextPos(pos, visual);
        } else {
            return previousPos(pos, visual);
        }
    }
}

References direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, nextLine(), nextPos(), previousLine(), previousPos(), textProperties(), KoSvgText::VerticalLR, KoSvgText::VerticalRL, and writingMode().

◆ posRight()

int KoSvgTextShape::posRight	(	int	pos,
		bool	visual = false )

return position to the right; visual indicates whether to use logical ('next') or visual right (depending on direction).

Definition at line 275 of file KoSvgTextShape.cpp.

{
    KoSvgText::WritingMode mode = writingMode();
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
 
    if (mode == KoSvgText::VerticalRL) {
        return previousLine(pos);
    } else if (mode == KoSvgText::VerticalLR) {
        return nextLine(pos);
    } else {
        if (direction == KoSvgText::DirectionRightToLeft) {
            return previousPos(pos, visual);
        } else {
            return nextPos(pos, visual);
        }
    }
}

References direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, nextLine(), nextPos(), previousLine(), previousPos(), textProperties(), KoSvgText::VerticalLR, KoSvgText::VerticalRL, and writingMode().

◆ posUp()

int KoSvgTextShape::posUp	(	int	pos,
		bool	visual = false )

return position above.

Definition at line 293 of file KoSvgTextShape.cpp.

{
    KoSvgText::WritingMode mode = writingMode();
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    if (mode == KoSvgText::VerticalRL || mode == KoSvgText::VerticalLR) {
        if (direction == KoSvgText::DirectionRightToLeft) {
            return nextPos(pos, visual);
        } else {
            return previousPos(pos, visual);
        }
    } else {
        return previousLine(pos);
    }
}

References direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, nextPos(), previousLine(), previousPos(), textProperties(), KoSvgText::VerticalLR, KoSvgText::VerticalRL, and writingMode().

◆ previousIndex()

int KoSvgTextShape::previousIndex ( int pos )

previousIndex Return the first pos which has a lower string index.

Parameters

pos	the cursor position.

Returns: the first cursor position with a lower index.

Definition at line 404 of file KoSvgTextShape.cpp.

{
    if (d->cursorPos.isEmpty()) {
        return pos;
    }
    const int currentIndex = d->getCursorPos(pos).index;
 
    for (int i = pos; i >= 0; i--) {
        if (d->getCursorPos(i).index < currentIndex) {
            return i;
        }
    }
    return pos;
}

References d.

◆ previousLine()

int KoSvgTextShape::previousLine ( int pos )

previousLine get a position on the previous line for this position.

Parameters

pos	– cursor position.

Returns: the pos on the previous line;

Definition at line 501 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || pos > d->cursorPos.size()-1 || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
    int currentLineStart = lineStart(pos);
    if (currentLineStart - 1 < 0) {
        return 0;
    }
    int previousLineStart = lineStart(currentLineStart-1);
 
    CursorPos cursorPos = d->getCursorPos(pos);
    if (!this->shapesInside().isEmpty()) {
        LineBox previousLineBox;
        for (int i = 0; i < d->lineBoxes.size(); ++i) {
            for (int j = 0; j < d->lineBoxes.at(i).chunks.size(); ++j) {
                if (d->lineBoxes.at(i).chunks.at(j).chunkIndices.contains(cursorPos.cluster)) {
                    previousLineBox = d->lineBoxes.at(qMax(i - 1, 0));
                }
            }
        }
        if (previousLineBox.chunks.size()>0) {
            int first = -1;
            int last = -1;
            Q_FOREACH(LineChunk chunk, previousLineBox.chunks) {
                Q_FOREACH (int i, chunk.chunkIndices) {
                    if (d->result.at(i).addressable) {
                        if (first < 0) {
                            first = d->result.at(i).cursorInfo.graphemeIndices.first();
                        }
                        last = d->result.at(i).cursorInfo.graphemeIndices.last();
                    }
                }
            }
            if (first > -1 && last > -1) {
                previousLineStart = posForIndex(first);
                currentLineStart = posForIndex(last);
            }
        }
    }
 
    CharacterResult res = d->result.at(cursorPos.cluster);
    QPointF currentPoint = res.finalPosition;
    currentPoint += res.cursorInfo.offsets.value(cursorPos.offset, res.advance);
    int candidate = posForPoint(currentPoint, previousLineStart, currentLineStart);
    if (candidate < 0) {
        return pos;
    }
 
    return candidate;
}

References CharacterResult::advance, LineChunk::chunkIndices, LineBox::chunks, CharacterResult::cursorInfo, cursorPos, d, CharacterResult::finalPosition, lineStart(), CursorInfo::offsets, posForIndex(), posForPoint(), and shapesInside.

◆ previousPos()

int KoSvgTextShape::previousPos	(	int	pos,
		bool	visual )

private

previousPos get the previous position.

Parameters

pos	– cursor position.

Returns: the previous pos;

Definition at line 433 of file KoSvgTextShape.cpp.

{
    if (d->cursorPos.isEmpty()) {
        return -1;
    }
 
    if(visual) {
        int visualIndex = d->logicalToVisualCursorPos.value(pos);
        return d->logicalToVisualCursorPos.key(qMax(visualIndex - 1, 0), 0);
    }
 
    return qMax(pos - 1, 0);
}

References d.

◆ Private() [1/2]

KoSvgTextShape::Private ( )

inline

Definition at line 445 of file KoSvgTextShape_p.h.

        : internalShapesPainter(new KoShapePainter)
        , shapeGroup(new KoShapeGroup)
    {
        shapeGroup->setSelectable(false);
    }

◆ Private() [2/2]

KoSvgTextShape::Private ( const Private & rhs )

inline

Definition at line 459 of file KoSvgTextShape_p.h.

        : internalShapesPainter(new KoShapePainter)
        , textData(rhs.textData)
    {
 
        KoShapeGroup *g = dynamic_cast<KoShapeGroup*>(rhs.shapeGroup.data()->cloneShape());
        shapeGroup.reset(g);
        shapeGroup->setSelectable(false);
        handleShapes(shapeGroup->shapes(), rhs.shapeGroup->shapes(), rhs.shapesInside, shapesInside);
        handleShapes(shapeGroup->shapes(), rhs.shapeGroup->shapes(), rhs.shapesSubtract, shapesSubtract);
        handleShapes(shapeGroup->shapes(), rhs.shapeGroup->shapes(), rhs.textPaths, textPaths);
        updateInternalShapesList();
 
        yRes = rhs.yRes;
        xRes = rhs.xRes;
        result = rhs.result;
        lineBoxes = rhs.lineBoxes;
 
        cursorPos = rhs.cursorPos;
        logicalToVisualCursorPos = rhs.logicalToVisualCursorPos;
        plainText = rhs.plainText;
        isBidi = rhs.isBidi;
        initialTextPosition = rhs.initialTextPosition;
 
        isLoading = rhs.isLoading;
        disableFontMatching = rhs.disableFontMatching;
 
        currentTextWrappingAreas = rhs.currentTextWrappingAreas;
    }

References KoShape::setSelectable().

◆ propertiesForPos()

KoSvgTextProperties KoSvgTextShape::propertiesForPos	(	const int	pos,
		bool	inherited = false ) const

Return the properties at a given position.

Definition at line 991 of file KoSvgTextShape.cpp.

{
    return propertiesForRange(pos, pos, inherited).value(0, KoSvgTextProperties());
}

References propertiesForRange().

◆ propertiesForRange()

QList< KoSvgTextProperties > KoSvgTextShape::propertiesForRange	(	const int	startPos,
		const int	endPos,
		bool	inherited = false ) const

propertiesForRange get the properties for a range.

Parameters

startPos	– range start.
endPos	– range end.

Returns: list of properties.

Sometimes this gets called when xml data is uploaded into the shape, at which point the tree is empty.

Definition at line 1012 of file KoSvgTextShape.cpp.

{
    QList<KoSvgTextProperties> props;
 
    if (d->isLoading) return props;
 
    if (((startPos < 0 || startPos >= d->cursorPos.size()) && startPos == endPos) || d->cursorPos.isEmpty()) {
        props = {KisForestDetail::size(d->textData)? d->textData.childBegin()->properties: KoSvgTextProperties()};
        return props;
    }
    const int startIndex = d->getCursorPos(startPos).index;
    const int endIndex = d->getCursorPos(endPos).index;
    int sought = startIndex;
    if (startIndex == endIndex) {
        int currentIndex = 0;
        auto it = d->findTextContentElementForIndex(d->textData, currentIndex, sought);
        if (it != d->textData.depthFirstTailEnd()) {
            if (inherited) {
                props.append(inheritProperties(it));
            } else {
                props.append(it->properties);
            }
        } else {
            currentIndex = 0;
            it = d->findTextContentElementForIndex(d->textData, currentIndex, sought - 1);
            if (it != d->textData.depthFirstTailEnd()) {
                if (inherited) {
                    props.append(inheritProperties(it));
                } else {
                    props.append(it->properties);
                }
            }
        }
    } else {
        while(sought < endIndex) {
            int currentIndex = 0;
            auto it = d->findTextContentElementForIndex(d->textData, currentIndex, sought);
            if (KisForestDetail::siblingCurrent(it) == d->textData.childBegin()) {
                // If there's a selection and the search algorithm only returns the root, return empty.
                // The root text properties should be retrieved explicitly (either by using -1 as pos, or by calling textProperties()).
                props = {KoSvgTextProperties()};
                return props;
            } else if (it != d->textData.depthFirstTailEnd()) {
                if (inherited) {
                    props.append(inheritProperties(it));
                } else {
                    props.append(it->properties);
                }
            }
            sought = currentIndex + it->numChars(false);
        }
    }
 
    return props;
}

References d, inheritProperties(), KisForestDetail::siblingCurrent(), and KisForestDetail::size().

◆ Q_DECLARE_FLAGS()

KoSvgTextShape::Q_DECLARE_FLAGS	(	DebugElements	,
		DebugElement	)

◆ relayout() [1/2]

void KoSvgTextShape::relayout ( )

◆ relayout() [2/2]

void KoSvgTextShape::relayout ( ) const

Create a new text layout for the current content of the text shape chunks tree. The user should always call relayout() after every change in the text shapes hierarchy.

Definition at line 2609 of file KoSvgTextShape.cpp.

{
    d->relayout();
}

References d.

◆ relayoutIsBlocked()

bool KoSvgTextShape::relayoutIsBlocked ( ) const

relayoutIsBlocked

Returns: whether automatic relayout is blocked, as are updates to shape listeners.

Definition at line 2009 of file KoSvgTextShape.cpp.

{
    return d->isLoading;
}

References d.

◆ removeShapesFromContours()

void KoSvgTextShape::removeShapesFromContours	(	QList< KoShape * >	shapes,
		bool	callUpdate = true,
		bool	cleanup = true )

removeShapesFromContours Remove list of shapes from any of the internal lists.

Parameters

shapes	– shapes to remove.
update	– whether to call an update.
cleanup	– whether to cleanup the textdata.

Definition at line 2394 of file KoSvgTextShape.cpp.

{
    Q_FOREACH(KoShape *shape, shapes) {
        if (shape) {
            d->removeTextPathId(d->textData.childBegin(), shape->name());
            shape->removeDependee(this);
            d->shapesInside.removeAll(shape);
            d->shapesSubtract.removeAll(shape);
            d->textPaths.removeAll(shape);
 
        }
        d->shapeGroup->removeShape(shape);
    }
    if (cleanup) {
        d->cleanUp(d->textData);
    }
    if (callUpdate) {
        notifyChanged(); // notify shape manager that our geometry has changed
        if (!d->isLoading) {
            d->updateTextWrappingAreas();
        }
        d->updateInternalShapesList();
        shapeChangedPriv(ContentChanged);
        update();
    }
}

References KoShape::ContentChanged, d, KoShape::name(), KoShape::notifyChanged(), KoShape::removeDependee(), KoShape::shapeChangedPriv(), and KoShape::update().

◆ removeText()

bool KoSvgTextShape::removeText	(	int &	index,
		int &	length )

removeText Where insert text explicitly uses a cursorposition, remove text uses a string index. It will modify these values so that...

Whole code points are deleted at any time, avoiding no dangling surrogates.
Graphemes don't end with Zero-width-joiners, as that can lead to the grapheme merging with the next.
Variation selectors are deleted along their base.
regional sequences are deleted in pairs.
Parameters

index - index (not cursorpos!) of the start position.

length - total length of text to remove.

Returns
whether it was successful.

Definition at line 952 of file KoSvgTextShape.cpp.

{
    bool success = false;
    if (index < -1) {
        return success;
    }
    int currentLength = length;
    int endLength = 0;
    while (currentLength > 0) {
        int currentIndex = 0;
 
        auto it = d->findTextContentElementForIndex(d->textData, currentIndex, index, true);
        if (it != d->textData.depthFirstTailEnd()) {
            int offset = index > currentIndex? index - currentIndex: 0;
            int size = it->numChars(false);
            it->removeText(offset, currentLength);
            int diff = size - it->numChars(false);
            currentLength -= diff;
            endLength += diff;
 
            if (index >= currentIndex) {
                index = currentIndex + offset;
            }
 
            d->removeTransforms(d->textData, index, endLength);
 
            success = true;
        } else {
            currentLength = -1;
        }
    }
    if (success) {
        length = endLength;
        notifyChanged();
        shapeChangedPriv(ContentChanged);
    }
    return success;
}

References KoShape::ContentChanged, d, length(), KoShape::notifyChanged(), KoShape::shapeChangedPriv(), and size().

◆ removeTextPathId()

static void KoSvgTextShape::removeTextPathId	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		const QString &	name )

inlinestatic

removeTextPathId Remove the text path id with the given name from the toplevel elements.

Definition at line 1393 of file KoSvgTextShape_p.h.

                                                                                                               {
        for (auto it = childBegin(parent); it != childEnd(parent); it++) {
            if (it->textPathId == name) {
                it->textPathId = QString();
                break;
            }
        }
    }

◆ removeTransforms()

static void KoSvgTextShape::removeTransforms	(	KisForest< KoSvgTextContentElement > &	tree,
		const int	start,
		const int	length )

inlinestatic

removeTransforms Remove all local SVG character transforms in a certain range. Local transforms are influenced by whitespace collapse and whether they are set to unicode codepoints, and they also accumulate from parent to child. This function removes all local transforms in a certain section.

Parameters

tree	– tree to remove transforms from.
start	– start at which to remove transforms.
length	– end to remove from.

Definition at line 943 of file KoSvgTextShape_p.h.

                                                                                                              {
        QString all;
        QVector<bool> collapsedCharacters = collapsedWhiteSpacesForText(tree, all, true);
 
        auto root = tree.childBegin();
        removeTransformsImpl(root, 0, start, length, collapsedCharacters);
    }

References KisForestDetail::Forest< T >::childBegin(), and length().

◆ removeTransformsFromRange()

void KoSvgTextShape::removeTransformsFromRange	(	const int	startPos,
		const int	endPos )

Remove local transforms from the given range.

Definition at line 1471 of file KoSvgTextShape.cpp.

{
    if ((startPos < 0 && startPos == endPos) || d->cursorPos.isEmpty()) {
        return;
    }
    const int startIndex = d->getCursorPos(qMin(startPos, endPos)).index;
    const int endIndex = d->getCursorPos(qMax(startPos, endPos)).index;
 
    d->removeTransforms(d->textData, startIndex, endIndex-startIndex);
 
    KoSvgTextShape::Private::cleanUp(d->textData);
    notifyChanged();
    shapeChangedPriv(ContentChanged);
}

References KoShape::ContentChanged, d, KoShape::notifyChanged(), and KoShape::shapeChangedPriv().

◆ removeTransformsImpl()

static int KoSvgTextShape::removeTransformsImpl	(	KisForest< KoSvgTextContentElement >::child_iterator	currentTextElement,
		const int	globalIndex,
		const int	start,
		const int	length,
		const QVector< bool >	collapsedCharacters )

inlinestatic

removeTransformsImpl recursive function that handles removing local transforms in a certain range. Used by removeTransform.

Definition at line 956 of file KoSvgTextShape_p.h.

                                                                                                                                                                                                            {
        int currentLength = 0;
        auto it = childBegin(currentTextElement);
        if (it != childEnd(currentTextElement)) {
            for (; it != childEnd(currentTextElement); it++) {
                currentLength += removeTransformsImpl(it, globalIndex + currentLength, start, length, collapsedCharacters);
            }
        } else {
            currentLength = currentTextElement->text.size();
        }
 
        if (!currentTextElement->localTransformations.isEmpty()) {
            int transformOffset = 0;
            int transformOffsetEnd = 0;
 
            for (int i = globalIndex; i < globalIndex + currentLength; i++) {
                if (i >= collapsedCharacters.size()) break;
                if (i < start) {
                    transformOffset += collapsedCharacters.at(i)? 0: 1;
                }
                if (i < start + length) {
                    transformOffsetEnd += collapsedCharacters.at(i)? 0: 1;
                } else {
                    break;
                }
            }
            if (transformOffset < currentTextElement->localTransformations.size()) {
                int length = qBound(0, transformOffsetEnd-transformOffset, qMax(0, currentTextElement->localTransformations.size()-transformOffset));
                currentTextElement->localTransformations.remove(transformOffset,
                                                                length);
            }
 
        }
        return currentLength;
    }

References length().

◆ resolvedTransformsForTree()

static QVector< KoSvgText::CharTransformation > KoSvgTextShape::resolvedTransformsForTree	(	KisForest< KoSvgTextContentElement > &	tree,
		bool	shapesInside = false,
		bool	includeBidiControls = false )

inlinestatic

Definition at line 1115 of file KoSvgTextShape_p.h.

                                                                                                                                                                                 {
        QString all;
        QVector<bool> collapsed = collapsedWhiteSpacesForText(tree, all, false, includeBidiControls);
        QVector<CharacterResult> result(all.size());
        int globalIndex = 0;
        KoSvgTextProperties props = tree.childBegin()->properties;
        props.inheritFrom(KoSvgTextProperties::defaultProperties(), true);
        KoSvgText::WritingMode mode = KoSvgText::WritingMode(
                    props.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
        bool isHorizontal = mode == KoSvgText::HorizontalTB;
        bool isWrapped = (props.hasProperty(KoSvgTextProperties::InlineSizeId)
                          || shapesInside);
        QVector<KoSvgText::CharTransformation> resolvedTransforms(all.size());
        resolveTransforms(tree.childBegin(), all, result, globalIndex,
                          isHorizontal, isWrapped, false, resolvedTransforms,
                          collapsed, KoSvgTextProperties::defaultProperties(),
                          false);
        return resolvedTransforms;
    }

References KisForestDetail::Forest< T >::childBegin(), KoSvgTextProperties::defaultProperties(), KoSvgTextProperties::hasProperty(), KoSvgText::HorizontalTB, KoSvgTextProperties::inheritFrom(), KoSvgTextProperties::InlineSizeId, KoSvgTextProperties::propertyOrDefault(), and KoSvgTextProperties::WritingModeId.

◆ resolveTransforms()

static void KoSvgTextShape::resolveTransforms	(	KisForest< KoSvgTextContentElement >::child_iterator	currentTextElement,
		QString	text,
		QVector< CharacterResult > &	result,
		int &	currentIndex,
		bool	isHorizontal,
		bool	wrapped,
		bool	textInPath,
		QVector< KoSvgText::CharTransformation > &	resolved,
		QVector< bool >	collapsedChars,
		const KoSvgTextProperties	resolvedProps,
		bool	withControls = true )

static

◆ saveHtml()

bool KoSvgTextShape::saveHtml ( HtmlSavingContext & context )

Definition at line 1812 of file KoSvgTextShape.cpp.

{
    bool success = true;
    QList<KoSvgTextProperties> parentProps = {KoSvgTextProperties::defaultProperties()};
    for (auto it = d->textData.compositionBegin(); it != d->textData.compositionEnd(); it++) {
        if (it.state() == KisForestDetail::Enter) {
            QMap<QString, QString> shapeSpecificStyles;
 
            if (it == d->textData.compositionBegin()) {
                context.shapeWriter().startElement("p", false);
            } else {
                context.shapeWriter().startElement("span", false);
            }
            KoSvgTextProperties ownProperties = it->properties.ownProperties(parentProps.last(),
                                                                             it == d->textData.compositionBegin());
            parentProps.append(ownProperties);
            QMap<QString, QString> attributes = ownProperties.convertToSvgTextAttributes();
            if (it == d->textData.compositionBegin())
                attributes.insert(ownProperties.convertParagraphProperties());
            bool addedFill = false;
            if (attributes.size() > 0) {
                QString styleString;
                for (auto it = attributes.constBegin(); it != attributes.constEnd(); ++it) {
                    if (QString(it.key().toLatin1().data()).contains("text-anchor")) {
                        QString val = it.value();
                        if (it.value()=="middle") {
                            val = "center";
                        } else if (it.value()=="end") {
                            val = "right";
                        } else {
                            val = "left";
                        }
                        styleString.append("text-align")
                                .append(": ")
                                .append(val)
                                .append(";" );
                    } else if (QString(it.key().toLatin1().data()).contains("fill")) {
                        styleString.append("color")
                                .append(": ")
                                .append(it.value())
                                .append(";" );
                        addedFill = true;
                    } else if (QString(it.key().toLatin1().data()).contains("font-size")) {
                        QString val = it.value();
                        styleString.append(it.key().toLatin1().data())
                                .append(": ")
                                .append(val)
                                .append(";" );
                    } else {
                        styleString.append(it.key().toLatin1().data())
                                .append(": ")
                                .append(it.value())
                                .append(";" );
                    }
                }
                if (ownProperties.hasProperty(KoSvgTextProperties::FillId) && !addedFill) {
                    KoColorBackground *b = dynamic_cast<KoColorBackground *>(it->properties.background().data());
                    if (b) {
                        styleString.append("color")
                                .append(": ")
                                .append(b->color().name())
                                .append(";" );
                    }
                }
                context.shapeWriter().addAttribute("style", styleString);
 
                if (d->childCount(siblingCurrent(it)) == 0) {
                    debugFlake << "saveHTML" << this << it->text;
                    // After adding all the styling to the <p> element, add the text
                    context.shapeWriter().addTextNode(it->text);
                }
            }
        } else {
            parentProps.pop_back();
            context.shapeWriter().endElement();
        }
    }
    return success;
}

References KoXmlWriter::addAttribute(), KoXmlWriter::addTextNode(), KoSvgTextProperties::convertParagraphProperties(), KoSvgTextProperties::convertToSvgTextAttributes(), d, debugFlake, KoSvgTextProperties::defaultProperties(), KoXmlWriter::endElement(), KisForestDetail::Enter, KoSvgTextProperties::FillId, KoSvgTextProperties::hasProperty(), KoSvgTextProperties::properties(), HtmlSavingContext::shapeWriter(), and KoXmlWriter::startElement().

◆ saveSvg()

bool KoSvgTextShape::saveSvg ( SvgSavingContext & context )

overridevirtual

Saves SVG data.

Reimplemented from SvgShape.

Definition at line 1729 of file KoSvgTextShape.cpp.

{
    bool success = false;
 
    QList<KoShape*> visibleShapes;
    Q_FOREACH(KoShape *shape, d->internalShapes()) {
        if (shape->isVisible(false)) {
            visibleShapes.append(shape);
        }
    }
    const bool writeGroup = !(visibleShapes.isEmpty() || context.strippedTextMode());
    if (writeGroup) {
        context.shapeWriter().startElement("g", false);
        context.shapeWriter().addAttribute("id", context.createUID("group"));
        context.shapeWriter().addAttribute(KoSvgTextShape_TEXTCONTOURGROUP, "true");
 
        SvgUtil::writeTransformAttributeLazy("transform", transformation(), context.shapeWriter());
        SvgWriter writer(visibleShapes);
        writer.saveDetached(context);
    }
    for (auto it = d->textData.compositionBegin(); it != d->textData.compositionEnd(); it++) {
        if (it.state() == KisForestDetail::Enter) {
            bool isTextPath = false;
            QMap<QString, QString> shapeSpecificStyles;
            if (!it->textPathId.isEmpty()) {
                isTextPath = true;
            }
            if (it == d->textData.compositionBegin()) {
                context.shapeWriter().startElement("text", false);
 
                if (!context.strippedTextMode()) {
                    context.shapeWriter().addAttribute("id", context.getID(this));
 
                    // save the version to distinguish from the buggy Krita version
                    // 2: Wrong font-size.
                    // 3: Wrong font-size-adjust.
                    context.shapeWriter().addAttribute("krita:textVersion", 3);
 
                    if (visibleShapes.isEmpty()) {
                        SvgUtil::writeTransformAttributeLazy("transform", transformation(), context.shapeWriter());
                    }
                    SvgStyleWriter::saveSvgStyle(this, context);
                } else {
                    SvgStyleWriter::saveSvgFill(this->background(), false, this->outlineRect(), this->size(), this->absoluteTransformation(), context);
                    SvgStyleWriter::saveSvgStroke(this->stroke(), context);
                    SvgStyleWriter::saveSvgBasicStyle(true, 0, paintOrder(),
                                                      inheritPaintOrder(), context, true);
                }
                shapeSpecificStyles = this->shapeTypeSpecificStyles(context);
            } else {
                if (isTextPath) {
                    context.shapeWriter().startElement("textPath", false);
                } else {
                    context.shapeWriter().startElement("tspan", false);
                }
                SvgStyleWriter::saveSvgBasicStyle(it->properties.property(KoSvgTextProperties::Visibility, true).toBool(),
                                                  it->properties.property(KoSvgTextProperties::Opacity, 0).toReal(),
                                                  it->properties.property(KoSvgTextProperties::PaintOrder,
                                                                          QVariant::fromValue(paintOrder())
                                                                          ).value<QVector<KoShape::PaintOrder>>(),
                                                  !it->properties.hasProperty(KoSvgTextProperties::PaintOrder), context, true);
 
            }
 
            KoShape *textPath = KoSvgTextShape::Private::textPathByName(it->textPathId, d->textPaths);
            success = it->saveSvg(context,
                                  it == d->textData.compositionBegin(),
                                  d->childCount(siblingCurrent(it)) == 0,
                                  shapeSpecificStyles,
                                  textPath);
        } else {
            if (it == d->textData.compositionBegin()) {
                SvgStyleWriter::saveMetadata(this, context);
            }
            context.shapeWriter().endElement();
        }
    }
    if (writeGroup) {
        context.shapeWriter().endElement();
    }
    return success;
}

References KoShape::absoluteTransformation(), background(), SvgSavingContext::createUID(), d, KisForestDetail::Enter, SvgSavingContext::getID(), KoShape::inheritPaintOrder(), KoShape::isVisible(), KoSvgTextShape_TEXTCONTOURGROUP, KoSvgTextProperties::Opacity, outlineRect(), KoSvgTextProperties::PaintOrder, paintOrder(), SvgWriter::saveDetached(), SvgStyleWriter::saveMetadata(), SvgStyleWriter::saveSvgBasicStyle(), SvgStyleWriter::saveSvgFill(), SvgStyleWriter::saveSvgStroke(), SvgStyleWriter::saveSvgStyle(), shapeTypeSpecificStyles(), SvgSavingContext::shapeWriter, size(), SvgSavingContext::strippedTextMode, stroke(), KoShape::transformation(), value(), KoSvgTextProperties::Visibility, and SvgUtil::writeTransformAttributeLazy().

◆ selectionBoxes()

QPainterPath KoSvgTextShape::selectionBoxes	(	int	pos,
		int	anchor )

selectionBoxes returns all selection boxes for a given range. Range will be normalized internally.

Parameters

pos	– the main cursor pos.
anchor	– the anchor from which the selection is calculated.

Returns: a winding-fill style QPainterPath will all boxes added as subpaths.

Definition at line 693 of file KoSvgTextShape.cpp.

{
    int start = qMin(pos, anchor);
    int end = qMax(pos, anchor);
    end = qMin(d->cursorPos.size()-1, end);
 
    if (start == end || start < 0) {
        return QPainterPath();
    }
 
    QPainterPath p;
    p.setFillRule(Qt::WindingFill);
    for (int i = start+1; i <= end; i++) {
        CursorPos cursorPos = d->getCursorPos(i);
        CharacterResult res = d->result.at(cursorPos.cluster);
        const QTransform tf = res.finalTransform();
        QLineF first = res.cursorInfo.caret;
        QLineF last = first;
        if (res.cursorInfo.rtl) {
            last.translate(res.cursorInfo.offsets.value(cursorPos.offset-1,  res.advance));
            first.translate(res.cursorInfo.offsets.value(cursorPos.offset, QPointF()));
        } else {
            first.translate(res.cursorInfo.offsets.value(cursorPos.offset-1,  QPointF()));
            last.translate(res.cursorInfo.offsets.value(cursorPos.offset, res.advance));
        }
        QPolygonF poly;
        poly << first.p1() << first.p2() << last.p2() << last.p1() << first.p1();
        p.addPolygon(tf.map(poly));
    }
 
    return p;
}

References CharacterResult::advance, KoShape::anchor(), CursorInfo::caret, CharacterResult::cursorInfo, cursorPos, d, CharacterResult::finalTransform(), CursorInfo::offsets, p, and CursorInfo::rtl.

◆ setBackground()

void KoSvgTextShape::setBackground ( QSharedPointer< KoShapeBackground > background )

overridevirtual

Set the background of the shape. A shape background can be a plain color, a gradient, a pattern, be fully transparent or have a complex fill. Setting such a background will allow the shape to be filled and will be able to tell if it is transparent or not.

If the shape inherited the background from its parent, its stops inheriting it, that is inheritBackground property resets to false.

Parameters

background the new shape background.

Reimplemented from KoShape.

Definition at line 1576 of file KoSvgTextShape.cpp.

{
    if (KisForestDetail::size(d->textData) == 0) {
        d->textData.insert(d->textData.childBegin(), KoSvgTextContentElement());
    }
    d->textData.childBegin()->properties.setProperty(KoSvgTextProperties::FillId,
                                                     QVariant::fromValue(KoSvgText::BackgroundProperty(background)));
 
    shapeChangedPriv(BackgroundChanged);
    notifyChanged();
}

References background(), KoShape::BackgroundChanged, d, KoSvgTextProperties::FillId, KoShape::notifyChanged(), KoShape::shapeChangedPriv(), and KisForestDetail::size().

◆ setCharacterTransformsFromLayout()

void KoSvgTextShape::setCharacterTransformsFromLayout ( )

setCharacterTransformsFromLayout Converts the text to a prepositioned SVG 1.1 text. This changes the textType();

Definition at line 1713 of file KoSvgTextShape.cpp.

{
    if (d->result.isEmpty()) return;
    d->setTransformsFromLayout(d->textData, d->result);
    d->cleanUp(d->textData);
    //d->applyWhiteSpace(d->textData, true);
    KoSvgTextProperties props = this->propertiesForPos(-1);
    props.removeProperty(KoSvgTextProperties::InlineSizeId);
    props.removeProperty(KoSvgTextProperties::TextCollapseId);
    props.removeProperty(KoSvgTextProperties::TextWrapId);
 
    setPropertiesAtPos(-1, props);
}

References d, KoSvgTextProperties::InlineSizeId, propertiesForPos(), KoSvgTextProperties::removeProperty(), setPropertiesAtPos(), KoSvgTextProperties::TextCollapseId, and KoSvgTextProperties::TextWrapId.

◆ setCharacterTransformsOnRange()

bool KoSvgTextShape::setCharacterTransformsOnRange	(	const int	startPos,
		const int	endPos,
		const QVector< QPointF >	positions,
		const QVector< qreal >	rotateDegrees,
		const bool	deltaPosition = true )

setCharacterTransformsOnRange Set SVG 1.1 style character transforms on the given range. Will not work when the shape is auto wrapping.

Parameters

startPos	– start of range
endPos	– end of range
positions	– positions, in shape coordinates.
rotations	– rotations, in degrees.
deltaPosition	– whether to calculate and set the delta positions.

Returns: whether successful.

Definition at line 1252 of file KoSvgTextShape.cpp.

{
    if ((startPos < 0 && startPos == endPos) || d->cursorPos.isEmpty()) {
        return false;
    }
    const int startIndex = d->getCursorPos(qMin(startPos, endPos)).index;
    int endIndex = d->getCursorPos(qMax(startPos, endPos)).index;
    if (startIndex == endIndex) {
        endIndex += 1;
        while(d->result.at(endIndex).middle) {
            endIndex += 1;
            if (endIndex > d->result.size()) break;
        }
    }
 
    bool changed = false;
 
    QVector<KoSvgText::CharTransformation> resolvedTransforms = Private::resolvedTransformsForTree(d->textData, !shapesInside().isEmpty(), true);
    Private::removeTransforms(d->textData, startIndex, endIndex-startIndex);
    QPointF totalStartDelta;
    QPointF anchorAbsolute;
    QPointF anchorCssPos;
 
    const KoSvgText::Direction dir = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    const KoSvgText::TextAnchor anchor = KoSvgText::TextAnchor(this->textProperties().propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt());
 
    const CharacterResult startRes = d->result.value(startIndex);
    const QPointF startAdvance = startRes.cursorInfo.rtl? startRes.advance: QPointF();
 
    if (deltaPosition) {
        for (int i = 0; i< startIndex; i++) {
            KoSvgText::CharTransformation tf = resolvedTransforms.value(i);
            if (tf.xPos) {
                totalStartDelta.setX(0);
                anchorAbsolute.setX(*tf.xPos);
            }
            if (tf.yPos) {
                totalStartDelta.setY(0);
                anchorAbsolute.setY(*tf.yPos);
            }
            if (tf.startsNewChunk()) {
                const CharacterResult res = d->result.value(i);
                anchorCssPos = res.cssPosition;
            }
            totalStartDelta += tf.relativeOffset();
        }
    } else {
        bool rtl = (dir == KoSvgText::DirectionRightToLeft);
        QPointF positionAtVisualEnd = (rtl? d->result.first(): d->result.last()).finalPosition;
        if (anchor == KoSvgText::AnchorEnd) {
            anchorAbsolute = positionAtVisualEnd;
        } else if (anchor == KoSvgText::AnchorMiddle) {
            anchorAbsolute = positionAtVisualEnd/2;
        }
    }
 
    int currentIndex = 0;
    QPointF accumulatedOffset;
    for (auto it = d->textData.depthFirstTailBegin(); it != d->textData.depthFirstTailEnd(); it++) {
        if (KoSvgTextShape::Private::childCount(siblingCurrent(it)) > 0 || !it->textPathId.isEmpty()) {
            continue;
        }
 
        int endContentElement = it->finalResultIndex;
 
        if (endContentElement >= startIndex && currentIndex <= endIndex) {
 
            QVector<KoSvgText::CharTransformation> transforms;
            int addressableOffset = 0;
            for (int i = currentIndex; (i < endContentElement); i++) {
                const CharacterResult res = d->result.value(i);
                if (!res.addressable) {
                    addressableOffset += 1;
                    continue;
                }
 
                const int transformIndex = (i - startIndex) - addressableOffset;
                KoSvgText::CharTransformation tf = resolvedTransforms.value(i, KoSvgText::CharTransformation());
 
                // Function to get the delta position.
                auto getDelta = [res, totalStartDelta, accumulatedOffset, anchorAbsolute, anchorCssPos, startAdvance] (QPointF pos) -> QPointF {
                    QPointF delta = pos - (res.textPathAndAnchoringOffset + anchorAbsolute + res.textLengthOffset);
                    delta -= (totalStartDelta + accumulatedOffset + (res.cssPosition-anchorCssPos) + startAdvance);
                    return delta;
                };
                // Function to get absolute position.
                auto getAbsolute = [res, tf, anchorAbsolute] (QPointF pos) -> QPointF {
                    QPointF p = pos - (res.textPathAndAnchoringOffset - anchorAbsolute) - tf.relativeOffset();
                    return p;
                };
 
                if (i < startIndex) {
                    if (!deltaPosition) {
                        // Because we don't split the text content element, we need to set the absolute pos for every preceding transform.
                        const QPointF p = getAbsolute(res.finalPosition);
                        if (!tf.xPos) {
                            tf.xPos = p.x();
                        }
                        if (!tf.yPos) {
                            tf.yPos = p.y();
                        }
                    }
                    transforms << tf;
                    continue;
                }
 
                if (i >= endIndex) {
                    if (i == endIndex) {
                        // Counter transform to keep unselected characters at the same pos.
                        if (deltaPosition && !tf.startsNewChunk()) {
                            QPointF delta = getDelta(res.finalPosition);
                            tf.dxPos = delta.x();
                            tf.dyPos = delta.y();
                        } else {
                            const QPointF p = getAbsolute(res.finalPosition) - anchorAbsolute;
                            tf.xPos = p.x();
                            tf.yPos = p.y();
                        }
                        if (!tf.rotate) {
                            tf.rotate = 0.0;
                        }
                    }
                    transforms << tf;
                    continue;
                }
 
                if (rotateDegrees.size()+startIndex > i) {
                    tf.rotate = kisDegreesToRadians(rotateDegrees.value(transformIndex, tf.rotate? *tf.rotate: rotateDegrees.last()));
                }
                if (positions.size()+startIndex > i) {
                    const QPointF pos = positions.value(transformIndex, QPointF());
 
                    if (deltaPosition) {
                        if (tf.startsNewChunk()) {
                            anchorAbsolute = tf.absolutePos();
                            totalStartDelta = tf.relativeOffset();
                            anchorCssPos = res.cssPosition;
                        }
 
                        QPointF delta = getDelta(pos);
                        tf.dxPos = delta.x();
                        tf.dyPos = delta.y();
 
                        if (tf.startsNewChunk()) {
                            accumulatedOffset = QPointF();
                            totalStartDelta = tf.relativeOffset();
                        } else {
                            accumulatedOffset += tf.relativeOffset();
                        }
                    } else {
                        const QPointF delta = getAbsolute(pos);
                        tf.xPos = delta.x();
                        tf.yPos = delta.y();
                        accumulatedOffset = pos - res.finalPosition;
                    }
 
                }
 
                transforms << tf;
            }
            it->localTransformations = transforms;
            changed = true;
        }
        currentIndex = it->finalResultIndex;
        if (currentIndex > endIndex) {
            break;
        }
    }
    const CharacterResult res = d->result.last();
 
    if (changed) {
        KoSvgTextShape::Private::cleanUp(d->textData);
        notifyChanged();
        shapeChangedPriv(ContentChanged);
    }
 
    return changed;
}

◆ setFontMatchingDisabled()

void KoSvgTextShape::setFontMatchingDisabled ( const bool disable )

setDisableFontMatching

Parameters

disable font matching when retrieving fonts for text layout (if possible). This speeds up text layout, but should only be done if there's only one font necessary and it can be found with the KoFFWWSconverter.

Definition at line 2014 of file KoSvgTextShape.cpp.

{
    d->disableFontMatching = disable;
}

References d.

◆ setMemento() [1/2]

void KoSvgTextShape::setMemento ( const KoSvgTextShapeMementoSP memento )

Set the text data and layout info, reset listening cursors to 0.

Definition at line 1944 of file KoSvgTextShape.cpp.

{
    setMementoImpl(memento);
    if (d->bulkActionState) {
        d->bulkActionState->layoutSetFromMemento = true;
    }
    notifyChanged();
    notifyCursorPosChanged(0, 0);
    notifyMarkupChanged();
}

References d, KoShape::notifyChanged(), notifyCursorPosChanged(), notifyMarkupChanged(), and setMementoImpl().

◆ setMemento() [2/2]

void KoSvgTextShape::setMemento	(	const KoSvgTextShapeMementoSP	memento,
		int	pos,
		int	anchor )

Set the text data, layout info and also adjust any listening cursors.

Definition at line 1955 of file KoSvgTextShape.cpp.

{
    const bool shapeOffsetBefore = (textProperties().hasProperty(KoSvgTextProperties::ShapeMarginId)
                                    || textProperties().hasProperty(KoSvgTextProperties::ShapePaddingId));
    setMementoImpl(memento);
    const bool shapeOffsetAfter = (textProperties().hasProperty(KoSvgTextProperties::ShapeMarginId)
                                   || textProperties().hasProperty(KoSvgTextProperties::ShapePaddingId));
    if (shapeOffsetBefore || shapeOffsetAfter) {
        if (d->bulkActionState) {
            d->bulkActionState->contourHasChanged = true;
        } else {
            d->updateTextWrappingAreas();
        }
    } else {
        if (d->bulkActionState) {
            d->bulkActionState->layoutSetFromMemento = true;
        }
    }
    notifyChanged();
    notifyCursorPosChanged(pos, anchor);
    notifyMarkupChanged();
}

References KoShape::anchor(), d, KoSvgTextProperties::hasProperty(), KoShape::notifyChanged(), notifyCursorPosChanged(), notifyMarkupChanged(), setMementoImpl(), KoSvgTextProperties::ShapeMarginId, KoSvgTextProperties::ShapePaddingId, and textProperties().

◆ setMementoImpl()

void KoSvgTextShape::setMementoImpl ( const KoSvgTextShapeMementoSP memento )

private

Definition at line 1914 of file KoSvgTextShape.cpp.

{
    // TODO: add an assert that all linked shpaes in memento are present in
    // the current state of d->textPaths. That is the responsibility of
    // KoSvgTextAddRemoveShapeCommandImpl to prepare the shapes for us
 
    KoSvgTextShapeMementoImpl *impl = dynamic_cast<KoSvgTextShapeMementoImpl*>(memento.data());
    if (impl) {
        d->textData = impl->textData;
        d->result = impl->result;
        d->lineBoxes = impl->lineBoxes;
        d->cursorPos = impl->cursorPos;
        d->logicalToVisualCursorPos = impl->logicalToVisualCursorPos;
        d->plainText = impl->plainText;
        d->isBidi = impl->isBidi;
        d->initialTextPosition = impl->initialTextPosition;
 
        // Ensure that any text paths exist.
        auto root = d->textData.childBegin();
        for (auto child = childBegin(root); child != childEnd(root); child++) {
            if (!child->textPathId.isEmpty()) {
                KIS_SAFE_ASSERT_RECOVER(Private::textPathByName(child->textPathId, d->textPaths)) {
                    qDebug() << "missing path is" << child->textPathId;
                    child->textPathId = QString();
                }
            }
        }
    }
}

References KoSvgTextShapeMementoImpl::cursorPos, d, KoSvgTextShapeMementoImpl::initialTextPosition, KoSvgTextShapeMementoImpl::isBidi, KIS_SAFE_ASSERT_RECOVER, KoSvgTextShapeMementoImpl::lineBoxes, KoSvgTextShapeMementoImpl::logicalToVisualCursorPos, KoSvgTextShapeMementoImpl::plainText, KoSvgTextShapeMementoImpl::result, and KoSvgTextShapeMementoImpl::textData.

◆ setPaintOrder()

void KoSvgTextShape::setPaintOrder	(	KoShape::PaintOrder	first,
		KoShape::PaintOrder	second )

overridevirtual

setPaintOrder set the paint order. As there's only three entries in any given paintorder, you only need to have the first and second entry to set it.

Parameters

first	first thing to paint
second	second thing to paint.

Reimplemented from KoShape.

Definition at line 1614 of file KoSvgTextShape.cpp.

{
    if (KisForestDetail::size(d->textData) == 0) {
        d->textData.insert(d->textData.childBegin(), KoSvgTextContentElement());
    }
    KIS_SAFE_ASSERT_RECOVER_RETURN(first != second);
    QVector<PaintOrder> order = KoShape::defaultPaintOrder();
 
    if (first != Fill) {
        if (order.at(1) == first) {
            order[1] = order[0];
            order[0] = first;
        } else if (order.at(2) == first) {
            order[2] = order[0];
            order[0] = first;
        }
    }
    if (second != first && second != Stroke) {
        if (order.at(2) == second) {
            order[2] = order[1];
            order[1] = second;
        }
    }
    d->textData.childBegin()->properties.setProperty(KoSvgTextProperties::PaintOrder,
                                                    QVariant::fromValue(order));
    setInheritPaintOrder(false);
}

References d, KoShape::defaultPaintOrder(), KoShape::Fill, KIS_SAFE_ASSERT_RECOVER_RETURN, KoSvgTextProperties::PaintOrder, KoShape::setInheritPaintOrder(), and KisForestDetail::size().

◆ setPropertiesAtPos()

void KoSvgTextShape::setPropertiesAtPos	(	int	pos,
		KoSvgTextProperties	properties )

setPropertiesAtPos will set the properties at pos.

Parameters

pos
properties

Definition at line 1069 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || d->cursorPos.isEmpty()) {
        if (KisForestDetail::size(d->textData)) {
            d->textData.childBegin()->properties = properties;
        }
        notifyChanged();
        shapeChangedPriv(ContentChanged);
        return;
    }
    CursorPos cursorPos = d->getCursorPos(pos);
    CharacterResult res = d->result.at(cursorPos.cluster);
    int currentIndex = 0;
    auto it = d->findTextContentElementForIndex(d->textData, currentIndex, res.plaintTextIndex);
    if (it != d->textData.depthFirstTailEnd()) {
        it->properties = properties;
        notifyChanged();
        shapeChangedPriv(ContentChanged);
    }
}

References KoShape::ContentChanged, cursorPos, d, KoShape::notifyChanged(), CharacterResult::plaintTextIndex, KoShape::shapeChangedPriv(), and KisForestDetail::size().

◆ setRelayoutBlocked()

void KoSvgTextShape::setRelayoutBlocked ( const bool disable )

Definition at line 2004 of file KoSvgTextShape.cpp.

{
    d->isLoading = disable;
}

References d.

◆ setResolution()

void KoSvgTextShape::setResolution	(	qreal	xRes,
		qreal	yRes )

overridevirtual

Update the image resolution in pixels per inch. Shapes should override this if they need to know the image resolution.

Parameters

xRes
yRes

Reimplemented from KoShape.

Definition at line 247 of file KoSvgTextShape.cpp.

{
    int roundedX = qRound(xRes);
    int roundedY = qRound(yRes);
    if (roundedX != d->xRes || roundedY != d->yRes) {
        d->xRes = roundedX;
        d->yRes = roundedY;
        relayout();
    }
}

References d, relayout(), xRes, and yRes.

◆ setShapesInside()

void KoSvgTextShape::setShapesInside ( QList< KoShape * > shapesInside )

setShapesInside

Parameters

shapesInside the list of shapes to make up the content area.

Definition at line 2346 of file KoSvgTextShape.cpp.

{
    removeShapesFromContours(d->shapesInside, false);
    addShapeContours(shapesInside, true);
}

References addShapeContours(), d, removeShapesFromContours(), and shapesInside.

◆ setShapesSubtract()

void KoSvgTextShape::setShapesSubtract ( QList< KoShape * > shapesSubtract )

setShapesSubtract

Parameters

shapesSubtract the list of shapes that subtract from the wrapping area.

Definition at line 2562 of file KoSvgTextShape.cpp.

{
    removeShapesFromContours(d->shapesSubtract, false);
    addShapeContours(shapesSubtract, false);
}

References addShapeContours(), d, removeShapesFromContours(), and shapesSubtract.

◆ setSize()

void KoSvgTextShape::setSize ( const QSizeF & size )

overridevirtual

Resize the shape.

Parameters

size the new size of the shape. This is different from scaling as scaling is a so called secondary operation which is comparable to zooming in instead of changing the size of the basic shape. Easiest example of this difference is that using this method will not distort the size of pattern-fills and strokes.

We don't have any contours, just scale (and distort) the text, as if "Scale Styles" were activated

We have only one contour that has no transformations, so we can just pass the resize to it and preserve all the contours intact

When resizing the shapes via setSize() we expect the method to scale the shapes bluntly in the parent's coordinate system. So, when resizing embedded shapes we should just anchor them to the origin of the text-shape's coordinate system.

When we have transformed (scaled, rotated and etc.) shapes internally, we cannot pass resize action to them, because it is impossible to mimic the parent resize by mere resizing the child shapes. We would have to add shear to them [1].

That is why we just add a scaling transform to every contour shape while keeping the text unscaled. Keeping the text unscaled covers the case when the user want to simply transform a text balloon without contours.

[1] Proof of the "impossible to pass the resize" claim

That comes from the matrix equation to the child-parent transformation. Here is an example for a rotated child:

Original transformation is:

parentPoint = childPoint * ChildRotate,

now apply Scale to both sides, to simulate scale in the parent's coordinate system:

parentPoint * Scale = childPoint * ChildRotate * Scale,

now we need to preserve the original child's transformation to be intact, which was ChildRotate. To achieve that, add (ChildRotate.inverted() * ChildRotate) at the end of the equation:

parentPoint * Scale = childPoint * ChildRotate * Scale * (ChildRotate.inverted() * ChildRotate),

now regroup the matrices:

parentPoint * Scale = childPoint * (ChildRotate * Scale * ChildRotate.inverted()) * ChildRotate,

notice matrix (ChildRotate * Scale * ChildRotate.inverted()) is the one that we should apply to the child shape in setSize() to preserve its transform. This matrix can not be a scale matrix, it will always recieve shear components for any non-trivial ChildRotate values.

Reimplemented from KoShape.

Definition at line 2140 of file KoSvgTextShape.cpp.

{
    const QRectF oRect = this->outlineRect();
    const QSizeF oldSize = oRect.size();
 
    if (size == oldSize) return;
 
    // don't try to divide by zero
    if (oldSize.isEmpty()) return;
 
    const qreal scaleX = size.width() / oldSize.width();
    const qreal scaleY = size.height() / oldSize.height();
 
    if (d->internalShapes().isEmpty()) {
        const qreal scaleX = size.width() / oldSize.width();
        const qreal scaleY = size.height() / oldSize.height();
 
        this->scale(scaleX, scaleY);
        // TODO: use scaling function for kosvgtextproperties when styles presets are merged.
        notifyChanged();
        shapeChangedPriv(ScaleChanged);
    } else {
        if (!d->textPaths.isEmpty()) return;
 
        const bool allInternalShapeAreTranslatedOnly = [this] () {
            Q_FOREACH(KoShape *shape, d->internalShapes()) {
                if (shape->transformation().type() > QTransform::TxTranslate) {
                    return false;
                }
            }
            return true;
        }();
 
        if (allInternalShapeAreTranslatedOnly) {
            Q_FOREACH (KoShape *internalShape, d->internalShapes()) {
                const QPointF stillPoint = this->absoluteTransformation().map(QPointF());
                const bool useGlobalMode = false;
                const bool usePostScaling = false;
                KoFlake::resizeShapeCommon(internalShape,
                                           scaleX,
                                           scaleY,
                                           stillPoint,
                                           useGlobalMode,
                                           usePostScaling,
                                           QTransform());
            }
 
            const QSizeF realNewSize = outlineRect().size();
            KoShape::setSize(realNewSize);
        } else {
            const QTransform scale = QTransform::fromScale(scaleX, scaleY);
 
            Q_FOREACH (KoShape *shape, d->internalShapes()) {
                shape->setTransformation(shape->transformation() * scale);
            }
 
            const QSizeF realNewSize = outlineRect().size();
            KoShape::setSize(realNewSize);
        }
    }
}

References KoShape::absoluteTransformation(), d, KoShape::notifyChanged(), outlineRect(), KoFlake::resizeShapeCommon(), KoShape::scale(), KoShape::ScaleChanged, KoShape::setSize(), KoShape::setTransformation(), KoShape::shapeChangedPriv(), size(), and KoShape::transformation().

◆ setStroke()

void KoSvgTextShape::setStroke ( KoShapeStrokeModelSP stroke )

overridevirtual

Set a new stroke, removing the old one. The stroke inheritance becomes disabled.

Parameters

stroke the new stroke, or 0 if there should be no stroke.

Reimplemented from KoShape.

Definition at line 1594 of file KoSvgTextShape.cpp.

{
    if (KisForestDetail::size(d->textData) == 0) {
        d->textData.insert(d->textData.childBegin(), KoSvgTextContentElement());
    }
    d->textData.childBegin()->properties.setProperty(KoSvgTextProperties::StrokeId,
                                                     QVariant::fromValue(KoSvgText::StrokeProperty(stroke)));
    shapeChangedPriv(StrokeChanged);
    notifyChanged();
}

References d, KoShape::notifyChanged(), KoShape::shapeChangedPriv(), KisForestDetail::size(), stroke(), KoShape::StrokeChanged, and KoSvgTextProperties::StrokeId.

◆ setTextPathOnRange()

bool KoSvgTextShape::setTextPathOnRange	(	KoShape *	textPath,
		const int	startPos = -1,
		const int	endPos = -1 )

setTextPathOnRange Set a text path on the specified range. In SVG text paths are always at the first child.

Parameters

textPath	– TextPath to set.
posStart	– Start of the range, as cursor pos.
posEnd	– End of the range, as cursor pos.

Returns: whether successfull.

Definition at line 2436 of file KoSvgTextShape.cpp.

{
    const int finalPos = d->cursorPos.size() - 1;
    const int startIndex = (startPos == endPos && startPos < 0)? 0: d->getCursorPos(startPos).index;
    const int endIndex = (startPos == endPos && startPos < 0)? finalPos: d->getCursorPos(endPos).index;
 
    Private::splitTree(d->textData, startIndex, false);
    Private::splitTree(d->textData, endIndex, true);
    int currentIndex = 0;
 
    Private::makeTextPathNameUnique(d->textPaths, textPath);
    KoSvgTextContentElement textPathElement;
    textPathElement.textPathId = textPath->name();
    d->shapeGroup->addShape(textPath);
    d->textPaths.append(textPath);
    textPath->addDependee(this);
 
 
    if (KisForestDetail::depth(d->textData) == 1) {
        textPathElement.text = d->textData.childBegin()->text;
        QList<KoSvgTextProperties::PropertyId> copyIds = {KoSvgTextProperties::TextDecorationLineId,
                                                          KoSvgTextProperties::TextDecorationColorId,
                                                          KoSvgTextProperties::TextDecorationStyleId};
        Q_FOREACH(KoSvgTextProperties::PropertyId p, copyIds) {
            if (d->textData.childBegin()->properties.hasProperty(KoSvgTextProperties::TextDecorationLineId)) {
                textPathElement.properties.setProperty(p, d->textData.childBegin()->properties.property(p));
                d->textData.childBegin()->properties.removeProperty(p);
            }
        }
 
        d->textData.childBegin()->text = QString();
        d->textData.insert(childEnd(d->textData.childBegin()), textPathElement);
    } else {
        // find nodes
        auto startElement = Private::findTextContentElementForIndex(d->textData, currentIndex, startIndex, true);
        currentIndex = 0;
        auto endElement = Private::findTextContentElementForIndex(d->textData, currentIndex, endIndex, true);
 
        auto first = startElement.node()?Private::findTopLevelParent(d->textData.childBegin(), KisForestDetail::siblingCurrent(startElement))
                                         : childEnd(d->textData.childBegin());
        auto last = endElement.node()? Private::findTopLevelParent(d->textData.childBegin(), KisForestDetail::siblingCurrent(endElement))
                                     : childEnd(d->textData.childBegin());
 
        // move children. we collect them before inserting the text path,
        // so we don't get iterator issues.
        KisForest<KoSvgTextContentElement> textPathTree;
        auto textPathIt = textPathTree.insert(
                    textPathTree.childEnd(),
                    textPathElement);
        QVector<KisForest<KoSvgTextContentElement>::child_iterator> movableChildren;
        for (auto child = first;
             (child != last && child != childEnd(d->textData.childBegin()));
             child++) {
            if (!child->textPathId.isEmpty()) {
                Q_FOREACH(KoShape *shape, d->textPaths) {
                    if (shape->name() == child->textPathId) {
                        removeShapesFromContours({shape}, false, false);
                        break;
                    }
                }
                child->textPathId = QString();
            }
            movableChildren.append(child);
        }
        while (!movableChildren.isEmpty()) {
            auto child = movableChildren.takeLast();
            textPathTree.move(child, KisForestDetail::childBegin(textPathIt));
        }
        d->textData.move(textPathIt, last);
    }
    Private::cleanUp(d->textData);
 
    d->updateInternalShapesList();
    notifyChanged();
    shapeChangedPriv(ContentChanged);
    update();
    return true;
}

References KoShape::addDependee(), KisForestDetail::childBegin(), KisForestDetail::Forest< T >::childEnd(), KoShape::ContentChanged, d, KisForestDetail::depth(), KisForestDetail::Forest< T >::insert(), KisForestDetail::Forest< T >::move(), KoShape::name(), KoShape::notifyChanged(), p, KoSvgTextContentElement::properties, removeShapesFromContours(), KoSvgTextProperties::setProperty(), KoShape::shapeChangedPriv(), KisForestDetail::siblingCurrent(), KoSvgTextContentElement::text, KoSvgTextProperties::TextDecorationColorId, KoSvgTextProperties::TextDecorationLineId, KoSvgTextProperties::TextDecorationStyleId, KoSvgTextContentElement::textPathId, and KoShape::update().

◆ setTransformsFromLayout()

void KoSvgTextShape::setTransformsFromLayout	(	KisForest< KoSvgTextContentElement > &	tree,
		const QVector< CharacterResult >	layout )

inline

Definition at line 1199 of file KoSvgTextShape_p.h.

                                                                                                                  {
        for (int i = 0; i< layout.size(); i++) {
            //split all anchored chunks, so we can set transforms on them.
            if (layout.at(i).anchored_chunk) {
                int plainTextIndex = layout.at(i).plaintTextIndex;
                splitContentElement(tree, plainTextIndex);
            }
        }
 
        int globalIndex = 0;
        for (auto it = tree.childBegin(); it != tree.childEnd(); it++) {
            KoSvgText::WritingMode mode = KoSvgText::WritingMode(
                        it->properties.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
            bool isHorizontal = mode == KoSvgText::HorizontalTB;
            setTransformsFromLayoutImpl(it, KoSvgTextProperties::defaultProperties(), layout, globalIndex, isHorizontal);
        }
    }

References KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::childEnd(), KoSvgTextProperties::defaultProperties(), KoSvgText::HorizontalTB, and KoSvgTextProperties::WritingModeId.

◆ setTransformsFromLayoutImpl()

void KoSvgTextShape::setTransformsFromLayoutImpl	(	KisForest< KoSvgTextContentElement >::child_iterator	current,
		const KoSvgTextProperties	parentProps,
		const QVector< CharacterResult >	layout,
		int &	globalIndex,
		bool	isHorizontal )

inline

Definition at line 1217 of file KoSvgTextShape_p.h.

                                                                          {
        KoSvgTextProperties props = current->properties;
        props.inheritFrom(parentProps);
        if (!current->textPathId.isEmpty()) return; // When we're doing text-on-path, we're already in preformatted mode.
        for (auto it = childBegin(current); it!= childEnd(current); it++) {
            setTransformsFromLayoutImpl(it, props, layout, globalIndex, isHorizontal);
        }
 
        if (current->text.isEmpty()) {
            current->localTransformations.clear();
        } else {
            QVector<KoSvgText::CharTransformation> transforms;
            const int length = current->numChars(true, props);
 
            for (int i = globalIndex; i< globalIndex+length; i++) {
                CharacterResult result = layout.value(i);
 
                if (!result.addressable) {
                    continue;
                }
                KoSvgText::CharTransformation transform;
 
                //TODO: Also split up content element if multiple anchored chunks.
                if (result.anchored_chunk) {
                    int endIndex = 0;
                    qreal shift = anchoredChunkShift(layout, isHorizontal, i, endIndex);
                    QPointF offset = isHorizontal? QPointF(shift, 0): QPointF(0, shift);
                    transform.xPos = result.finalPosition.x() - offset.x();
                    transform.yPos = result.finalPosition.y() - offset.y();
                } else if (i > 0) {
                    CharacterResult resultPrev = layout.value(i-1);
                    QPointF offset = (result.finalPosition - result.cssPosition) - (resultPrev.finalPosition - resultPrev.cssPosition);
 
                    transform.dxPos = offset.x();
                    transform.dyPos = offset.y();
                }
                transform.rotate = result.rotate;
 
                transforms.append(transform);
            }
            current->localTransformations = transforms;
            current->text = current->text.split("\n").join(" ");
            globalIndex += length;
        }
    }

References CharacterResult::addressable, CharacterResult::anchored_chunk, CharacterResult::cssPosition, KoSvgText::CharTransformation::dxPos, KoSvgText::CharTransformation::dyPos, CharacterResult::finalPosition, KoSvgTextProperties::inheritFrom(), length(), KoSvgText::CharTransformation::rotate, CharacterResult::rotate, KoSvgText::CharTransformation::xPos, and KoSvgText::CharTransformation::yPos.

◆ shapeChanged()

void KoSvgTextShape::shapeChanged	(	ChangeType	type,
		KoShape *	shape )

overrideprotectedvirtual

A hook that allows inheriting classes to do something after a KoShape property changed This is called whenever the shape, position rotation or scale properties were altered.

Parameters

type	an indicator which type was changed.
shape	the shape.

NOTE: we don't need to handle Deleted type for the shapes in d->dependees list here, becasue this function is called on the other side of the relation, i.e. in the actual "dependee". We handle that in Private::DependeesLifetimeListener.

Reimplemented from KoShape.

Definition at line 178 of file KoSvgTextShape.cpp.

{
    KoShape::shapeChanged(type, shape);
 
    if (d->isLoading) {
        return;
    }
 
    const QVector<ChangeType> transformationTypes = {PositionChanged, RotationChanged, ScaleChanged, ShearChanged, SizeChanged, GenericMatrixChange};
 
    if ((d->shapesInside.contains(shape) || d->shapesSubtract.contains(shape) || d->textPaths.contains(shape))
            && (transformationTypes.contains(type)
                || type == ParameterChanged
                || type == ParentChanged
                || type == ContentChanged // for KoPathShape modifications
                || type == Deleted)) {
        if (type == Deleted) {
            if (d->shapesInside.contains(shape)) {
                d->shapesInside.removeAll(shape);
            }
            if (d->shapesSubtract.contains(shape)) {
                d->shapesSubtract.removeAll(shape);
            }
            if (d->textPaths.contains(shape)) {
                d->textPaths.removeAll(shape);
                // TODO: remove ID from relevant text content element.
            }
            if (d->shapeGroup && d->shapeGroup->shapes().contains(shape)) {
                d->shapeGroup->removeShape(shape);
            }
            d->updateInternalShapesList();
        }
 
        // Updates the contours and calls relayout.
        // Would be great if we could compress the updates here somehow...
        if (d->bulkActionState) {
            d->bulkActionState->contourHasChanged = true;
        } else {
            d->updateTextWrappingAreas();
        }
 
        // NotifyChanged ensures that boundingRect() is called on this shape;
        // it is NOT compressed by the bulk action, since boundingRect() is
        // guaranteed to be valid during the whole bulk action
        this->notifyChanged();
    }
    if ((!shape || shape == this)) {
        if (type == ContentChanged) {
            if (d->bulkActionState) {
                d->bulkActionState->layoutHasChanged = true;
            } else {
                relayout();
            }
        } else if (transformationTypes.contains(type) || type == ParentChanged) {
            d->shapeGroup->setTransformation(this->absoluteTransformation());
        } else if (type == TextContourMarginChanged) {
            if (d->bulkActionState) {
                d->bulkActionState->contourHasChanged = true;
            } else {
                d->updateTextWrappingAreas();
            }
        }
 
        // when calling shapeChangedImpl() on `this` shape, we call
        // notifyChanged() manually at the calling site, so we shouldn't
        // do that again here
    }
}

References KoShape::absoluteTransformation(), KoShape::ContentChanged, d, KoShape::Deleted, KoShape::GenericMatrixChange, KoShape::notifyChanged(), KoShape::ParameterChanged, KoShape::ParentChanged, KoShape::PositionChanged, relayout(), KoShape::RotationChanged, KoShape::ScaleChanged, KoShape::shapeChanged(), KoShape::ShearChanged, KoShape::SizeChanged, and KoShape::TextContourMarginChanged.

◆ shapeInContours()

bool KoSvgTextShape::shapeInContours ( KoShape * shape )

shapeInContours

Parameters

shape

Returns: whether a shape is in any contour.

Definition at line 2389 of file KoSvgTextShape.cpp.

{
    return (shape->parent() == d->shapeGroup.data());
}

References d, and KoShape::parent().

◆ shapesInside()

QList< KoShape * > KoSvgTextShape::shapesInside ( ) const

shapesInside

Returns: the list of shapes that make up the content area.

◆ shapesSubtract()

QList< KoShape * > KoSvgTextShape::shapesSubtract ( ) const

shapesSubtract

Returns: list of subtract shapes.

◆ shapeTypeSpecificStyles()

QMap< QString, QString > KoSvgTextShape::shapeTypeSpecificStyles ( SvgSavingContext & context ) const

Right now we don't support showing glyphs outside the shape. Nor does Inkscape. Therefore being excplit about clipping these glyphs is preferable.

Definition at line 2583 of file KoSvgTextShape.cpp.

{
    QMap<QString, QString> map = this->textProperties().convertParagraphProperties();
    if (!d->shapesInside.isEmpty()) {
        QStringList shapesInsideList;
        Q_FOREACH(KoShape* shape, d->shapesInside) {
            QString id = (shape->isVisible(false) && !context.strippedTextMode())? context.getID(shape): SvgStyleWriter::embedShape(shape, context);
            shapesInsideList.append(QString("url(#%1)").arg(id));
        }
        map.insert("shape-inside", shapesInsideList.join(" "));
        map.insert("overflow", "clip");
    }
    if (!d->shapesSubtract.isEmpty()) {
        QStringList shapesInsideList;
        Q_FOREACH(KoShape* shape, d->shapesSubtract) {
            QString id = shape->isVisible(false)? context.getID(shape): SvgStyleWriter::embedShape(shape, context);
            shapesInsideList.append(QString("url(#%1)").arg(id));
        }
        map.insert("shape-subtract", shapesInsideList.join(" "));
    }
 
    return map;
}

References KoSvgTextProperties::convertParagraphProperties(), d, SvgStyleWriter::embedShape(), SvgSavingContext::getID(), KoShape::isVisible(), SvgSavingContext::strippedTextMode, and textProperties().

◆ singleNode()

bool KoSvgTextShape::singleNode ( ) const

singleNode Sometimes it is useful to know whether there's only a single text node for UX purposes.

Returns: whether there's only a single root node, or there's a full fledged tree.

Definition at line 1657 of file KoSvgTextShape.cpp.

{
    if (d->textData.empty()) return false;
    return (KisForestDetail::size(d->textData) == 1);
}

References d, and KisForestDetail::size().

◆ size()

QSizeF KoSvgTextShape::size ( ) const

overridevirtual

Get the size of the shape in pt.

The size is in shape coordinates.

Returns: the size of the shape as set by setSize()

Reimplemented from KoShape.

Definition at line 2134 of file KoSvgTextShape.cpp.

{
    // TODO: check if KoShape::m_d->size is consistent, check cache in KoShapeGroup::size()
    return outlineRect().size();
}

References outlineRect().

◆ splitContentElement()

static bool KoSvgTextShape::splitContentElement	(	KisForest< KoSvgTextContentElement > &	tree,
		int	index,
		bool	allowEmptyText = true )

inlinestatic

splitContentElement split the contentElement in tree at index into two nodes.

Parameters

tree	– tree to work on.
index	– index
allowEmptyText	– when false, will return true without splitting the text content element, if the split text would be empty.

Returns: whether it was successful.

Definition at line 762 of file KoSvgTextShape_p.h.

                                                                                                                     {
        int currentIndex = 0;
 
        // If there's only a single root element, don't bother searching.
        auto contentElement = depth(tree) == 1? tree.depthFirstTailBegin(): findTextContentElementForIndex(tree, currentIndex, index, true);
        if (contentElement == tree.depthFirstTailEnd()) return false;
 
        bool suitableStartIndex = siblingCurrent(contentElement) == tree.childBegin()? index >= currentIndex: index > currentIndex;
        bool suitableEndIndex = siblingCurrent(contentElement) == tree.childBegin()? true: index < currentIndex + contentElement->numChars(false);
 
        if (suitableStartIndex && suitableEndIndex) {
            KoSvgTextContentElement duplicate = KoSvgTextContentElement();
            duplicate.text = contentElement->text;
            int start = index - currentIndex;
            int length = contentElement->numChars(false) - start;
            int zero = 0;
            duplicate.removeText(start, length);
 
            if (!allowEmptyText && (duplicate.text.isEmpty() || length == 0)) {
                return true;
            }
 
            // TODO: handle localtransforms better; annoyingly, this requires whitespace handling
 
            if (siblingCurrent(contentElement) != tree.childBegin()
                    && contentElement->textPathId.isEmpty()
                    && contentElement->textLength.isAuto
                    && contentElement->localTransformations.isEmpty()) {
                contentElement->removeText(zero, start);
                duplicate.properties = contentElement->properties;
                tree.insert(siblingCurrent(contentElement), duplicate);
            } else {
                KoSvgTextContentElement duplicate2 = KoSvgTextContentElement();
                duplicate2.text = contentElement->text;
                duplicate2.removeText(zero, start);
                contentElement->text.clear();
                tree.insert(childBegin(contentElement), duplicate);
                tree.insert(childEnd(contentElement), duplicate2);
            }
            return true;
        }
        return false;
    }

References KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::depthFirstTailBegin(), KisForestDetail::Forest< T >::depthFirstTailEnd(), KisForestDetail::Forest< T >::insert(), length(), KoSvgTextContentElement::properties, KoSvgTextProperties::properties(), KoSvgTextContentElement::removeText(), and KoSvgTextContentElement::text.

◆ splitTree()

static void KoSvgTextShape::splitTree	(	KisForest< KoSvgTextContentElement > &	tree,
		int	index,
		bool	textPathAfterSplit )

inlinestatic

splitTree Split the whole hierarchy of nodes at the given index.

Parameters

tree	- tree to split.
index	- index to split at.
textPathAfterSplit	- whether to put any found textPaths before or after the split.

Definition at line 813 of file KoSvgTextShape_p.h.

                                                                                                        {
        splitContentElement(tree, index, false);
        int currentIndex = 0;
        auto contentElement = depth(tree) == 1? tree.depthFirstTailBegin(): findTextContentElementForIndex(tree, currentIndex, index, true);
 
        // We're either at the start or end.
        if (contentElement == tree.depthFirstTailEnd()) return;
        if (siblingCurrent(contentElement) == tree.childBegin()) return;
 
        auto lastNode = siblingCurrent(contentElement);
        for (auto parentIt = KisForestDetail::hierarchyBegin(siblingCurrent(contentElement));
             parentIt != KisForestDetail::hierarchyEnd(siblingCurrent(contentElement)); parentIt++) {
            if (lastNode == siblingCurrent(parentIt)) continue;
            if (siblingCurrent(parentIt) == tree.childBegin()) {
                break;
            }
 
            if (lastNode != childBegin(siblingCurrent(parentIt))) {
                KoSvgTextContentElement duplicate = KoSvgTextContentElement();
                duplicate.properties = parentIt->properties;
                if (textPathAfterSplit) {
                    duplicate.textPathId = parentIt->textPathId;
                    duplicate.textPathInfo = parentIt->textPathInfo;
                    parentIt->textPathId = QString();
                    parentIt->textPathInfo = KoSvgText::TextOnPathInfo();
                }
                auto insert = siblingCurrent(parentIt);
                insert ++;
                auto it = tree.insert(insert, duplicate);
 
                QVector<KisForest<KoSvgTextContentElement>::child_iterator> movableChildren;
                for (auto child = lastNode; child != childEnd(siblingCurrent(parentIt)); child++) {
                    movableChildren.append(child);
                }
                while(!movableChildren.isEmpty()) {
                    auto child = movableChildren.takeLast();
                    tree.move(child, childBegin(it));
                }
                lastNode = it;
            } else {
                lastNode = siblingCurrent(parentIt);
            }
        }
    }

References KisForestDetail::Forest< T >::childBegin(), KisForestDetail::Forest< T >::depthFirstTailBegin(), KisForestDetail::Forest< T >::depthFirstTailEnd(), KisForestDetail::hierarchyBegin(), KisForestDetail::hierarchyEnd(), KisForestDetail::Forest< T >::insert(), KisForestDetail::Forest< T >::move(), KoSvgTextContentElement::properties, KoSvgTextProperties::properties(), KoSvgTextContentElement::textPathId, and KoSvgTextContentElement::textPathInfo.

◆ startBulkAction()

void KoSvgTextShape::startBulkAction ( )

overridevirtual

Called by the GUI code when it wants to execute some kind of a long action, which will result in multiple shapeChanged() callbacks to be delivered.

When started, the shape enters into an "bulk action" state as described in the class documentation.

Implements KoShapeBulkActionInterface.

Definition at line 2029 of file KoSvgTextShape.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!d->bulkActionState);
    d->bulkActionState.emplace(boundingRect());
}

References boundingRect(), d, and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ startIndexOfIterator()

static bool KoSvgTextShape::startIndexOfIterator	(	KisForest< KoSvgTextContentElement >::child_iterator	parent,
		KisForest< KoSvgTextContentElement >::child_iterator	target,
		int &	currentIndex )

inlinestatic

Definition at line 1372 of file KoSvgTextShape_p.h.

                                                                                                                                                                          {
        for (auto child = KisForestDetail::childBegin(parent); child != KisForestDetail::childEnd(parent); child++) {
            if (child == target) {
                return true;
            } else if ((KisForestDetail::childBegin(child) != KisForestDetail::childEnd(child))) {
                if (startIndexOfIterator(child, target, currentIndex)) {
                    return true;
                }
            } else {
                currentIndex += numChars(child);
            }
        }
        return false;
    }

References KisForestDetail::childBegin(), KisForestDetail::childEnd(), and target().

◆ stretchGlyphOnPath()

static QPainterPath KoSvgTextShape::stretchGlyphOnPath	(	const QPainterPath &	glyph,
		const QPainterPath &	path,
		bool	isHorizontal,
		qreal	offset,
		bool	isClosed )

static

◆ stroke()

KoShapeStrokeModelSP KoSvgTextShape::stroke ( ) const

overridevirtual

Returns the currently set stroke, or 0 if there is no stroke.

Returns: the currently set stroke, or 0 if there is no stroke.

Reimplemented from KoShape.

Definition at line 1588 of file KoSvgTextShape.cpp.

{
    KoSvgTextProperties props = KisForestDetail::size(d->textData)? d->textData.childBegin()->properties: KoSvgTextProperties();
    return props.property(KoSvgTextProperties::StrokeId).value<KoSvgText::StrokeProperty>().property;
}

References d, KoSvgTextProperties::properties(), KoSvgTextProperties::property(), KisForestDetail::size(), and KoSvgTextProperties::StrokeId.

◆ textOutline()

KoShape * KoSvgTextShape::textOutline ( ) const

textOutline This turns the text object into non-text KoShape(s) to the best of its abilities.

Returns: a single KoPathShape if only a single path is necessary, or multiple KoShapes (Paths, Images, and Rectangles with Masks are all possible) inside a KoShapeGroup.

Definition at line 2310 of file KoSvgTextShape.cpp.

{
    KoShape *shape = nullptr;
    int currentIndex = 0;
    if (!d->result.empty()) {
        shape = d->collectPaths(this, d->result, currentIndex);
    }
 
    return shape;
}

References d.

◆ textPathByName()

static KoShape * KoSvgTextShape::textPathByName	(	QString	name,
		QList< KoShape * >	textPaths )

inlinestatic

Definition at line 573 of file KoSvgTextShape_p.h.

                                                                            {
        auto it = std::find_if(textPaths.begin(), textPaths.end(), [&name](const KoShape *s) -> bool {return s->name() == name;});
        return it != textPaths.end()? *it: nullptr;
    }

◆ textPathsAtRange()

QList< KoShape * > KoSvgTextShape::textPathsAtRange	(	const int	startPos = -1,
		const int	endPos = -1 )

textPathsAtRange Get a list of textPaths at the given range. This includes textPaths whose node is only partially overlapped by the range.

Parameters

posStart	– Start of the range, as cursor pos.
posEnd	– End of the range, as cursor pos.

Returns: list of KoShapes that are text paths.

Definition at line 2515 of file KoSvgTextShape.cpp.

{
    const int finalPos = d->cursorPos.size() - 1;
    const int startIndex = (startPos == endPos && startPos < 0)? 0: d->getCursorPos(startPos).index;
    const int endIndex = (startPos == endPos && startPos < 0)? finalPos: d->getCursorPos(endPos).index;
    QList<KoShape*> textPaths;
    int currentIndex = 0;
    auto startElement = Private::findTextContentElementForIndex(d->textData, currentIndex, startIndex, true);
    currentIndex = 0;
    auto endElement = Private::findTextContentElementForIndex(d->textData, currentIndex, endIndex, true);
 
    auto first = startElement.node()? Private::findTopLevelParent(d->textData.childBegin(), KisForestDetail::siblingCurrent(startElement))
                                     : childEnd(d->textData.childBegin());
    auto last = endElement.node()? Private::findTopLevelParent(d->textData.childBegin(), KisForestDetail::siblingCurrent(endElement))
                                 : childEnd(d->textData.childBegin());
    if (last != childEnd(d->textData.childBegin())) {
        last++;
    }
    for (auto child = first; (child != last && child != KisForestDetail::siblingEnd(first)); child++) {
        if (KoShape *path = Private::textPathByName(child->textPathId, d->textPaths)) {
            textPaths.append(path);
        }
    }
    return textPaths;
}

References d, KisForestDetail::siblingCurrent(), KisForestDetail::siblingEnd(), and textPaths.

◆ textProperties()

KoSvgTextProperties KoSvgTextShape::textProperties ( ) const

Definition at line 1562 of file KoSvgTextShape.cpp.

{
    return KisForestDetail::size(d->textData)? d->textData.childBegin()->properties: KoSvgTextProperties();
}

References d, KoSvgTextProperties::properties(), and KisForestDetail::size().

◆ textType()

KoSvgTextShape::TextType KoSvgTextShape::textType ( ) const

textType This enum gives an indication of what kind of text this shape is. The different text types are a bit blurry as SVG allows a mixutre to provide fallback information. When such fallback is in place, this will only return the primary text type, that is, TextInShape before InlineWrap and InlineWrap before PrePositioned/Preformatted. This primarily exists to give UI feedback.

Returns: estimated TextType

Definition at line 2321 of file KoSvgTextShape.cpp.

{
    KoSvgText::AutoValue inlineSize = this->textProperties().propertyOrDefault(KoSvgTextProperties::InlineSizeId).value<KoSvgText::AutoValue>();
    if (!d->shapesInside.isEmpty()) {
        return TextType::TextInShape;
    } else if (!inlineSize.isAuto) {
        return TextType::InlineWrap;
    } else {
        bool textSpaceCollapse = false;
        for (auto it = d->textData.depthFirstTailBegin(); it != d->textData.depthFirstTailEnd(); it++) {
            KoSvgText::TextSpaceCollapse collapse = KoSvgText::TextSpaceCollapse(it->properties.propertyOrDefault(KoSvgTextProperties::TextCollapseId).toInt());
            if (collapse == KoSvgText::Collapse || collapse == KoSvgText::PreserveSpaces) {
                textSpaceCollapse = true;
                break;
            }
            if (!it->localTransformations.isEmpty()) {
                textSpaceCollapse = true;
                break;
            }
        }
        return textSpaceCollapse? TextType::PrePositionedText: TextType::PreformattedText;
    }
    return TextType::PrePositionedText;
}

References KoSvgText::Collapse, d, KoSvgTextProperties::InlineSizeId, InlineWrap, KoSvgText::AutoValue::isAuto, PreformattedText, PrePositionedText, KoSvgText::PreserveSpaces, KoSvgTextProperties::propertyOrDefault(), KoSvgTextProperties::TextCollapseId, TextInShape, and textProperties().

◆ textWrappingAreas()

QList< QPainterPath > KoSvgTextShape::textWrappingAreas ( ) const

textWrappingAreas The text wrapping areas are computed from shapesInside() and shapesSubtract(), as well as the text properties ShapeMargin and ShapePadding. This returns the computed wrapping areas, in the local coordinates of the shape.

@seealso outline()

Returns: a list of computed text wrapping areas.

Definition at line 2568 of file KoSvgTextShape.cpp.

{
    return d->currentTextWrappingAreas;
}

References d.

◆ topLevelNodeForPos()

KoSvgTextNodeIndex KoSvgTextShape::topLevelNodeForPos ( int pos ) const

topLevelNodeForPos Get, if possible, an index for the child element of the root at pos. If not possible, returns an index for the root. This is used primarily for text-on-path.

Parameters

pos	– cursor position at which to find the index.

Returns: if the text only has a root, it will still return the index for the root, but otherwise it will return a child element of root at pos.

Definition at line 1527 of file KoSvgTextShape.cpp.

{
    auto candidate = d->textData.childBegin();
    if (d->isLoading || d->cursorPos.isEmpty()) return d->createTextNodeIndex(candidate);
    if (childBegin(d->textData.childBegin()) != childEnd(d->textData.childBegin())) {
        candidate = childBegin(d->textData.childBegin());
    }
    const int index = d->getCursorPos(pos).index;
    int currentIndex = 0;
 
    auto e = Private::findTextContentElementForIndex(d->textData, currentIndex, index, true);
    if (e == d->textData.depthFirstTailEnd()) {
        return d->createTextNodeIndex(candidate);
    }
 
    auto element = KisForestDetail::siblingCurrent(e);
    auto parent = Private::findTopLevelParent(d->textData.childBegin(), element);
    if (parent == childEnd(d->textData.childBegin())) return d->createTextNodeIndex(candidate);
 
    return d->createTextNodeIndex(parent);
}

References d, KoShape::Private::parent, and KisForestDetail::siblingCurrent().

◆ underlines()

QPainterPath KoSvgTextShape::underlines	(	int	pos,
		int	anchor,
		KoSvgText::TextDecorations	decor,
		KoSvgText::TextDecorationStyle	style,
		qreal	minimum,
		bool	thick )

Definition at line 726 of file KoSvgTextShape.cpp.

{
    int start = qMin(pos, anchor);
    int end = qMax(pos, anchor);
 
    if (start == end || start < 0 || end >= d->cursorPos.size()) {
        return QPainterPath();
    }
    QPainterPathStroker stroker;
 
    KoSvgText::WritingMode mode = KoSvgText::WritingMode(this->textProperties().propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
    stroker.setCapStyle(Qt::FlatCap);
    if (style == KoSvgText::Solid) {
        stroker.setDashPattern(Qt::SolidLine);
    } else if (style == KoSvgText::Dashed) {
        stroker.setDashPattern(Qt::DashLine);
    } else if (style == KoSvgText::Dotted) {
        stroker.setDashPattern(Qt::DotLine);
    } else {
        stroker.setDashPattern(Qt::SolidLine);
    }
 
    QPainterPath underPath;
    QPainterPath overPath;
    QPainterPath middlePath;
    qint32 strokeWidth = 0;
    QPointF inset = mode == KoSvgText::HorizontalTB? QPointF(minimum*0.5, 0): QPointF(0, minimum*0.5);
    for (int i = start+1; i <= end; i++) {
        CursorPos pos = d->getCursorPos(i);
        CharacterResult res = d->result.at(pos.cluster);
        strokeWidth += res.metrics.underlineThickness;
        const QTransform tf = res.finalTransform();
        QPointF first = res.cursorInfo.caret.p1();
        QPointF last = first;
        if (res.cursorInfo.rtl) {
            last  += res.cursorInfo.offsets.value(pos.offset-1,  res.advance);
            first += res.cursorInfo.offsets.value(pos.offset, QPointF());
            if (i == start+1) {
                first -= inset;
            }
            if (i == end) {
                last += inset;
            }
        } else {
            first += res.cursorInfo.offsets.value(pos.offset-1,  QPointF());
            last  += res.cursorInfo.offsets.value(pos.offset, res.advance);
            if (i == start+1) {
                first += inset;
            }
            if (i == end) {
                last -= inset;
            }
        }
 
        if (decor.testFlag(KoSvgText::DecorationUnderline)){
            underPath.moveTo(tf.map(first));
            underPath.lineTo(tf.map(last));
        }
        QPointF diff = res.cursorInfo.caret.p2() - res.cursorInfo.caret.p1();
        if (decor.testFlag(KoSvgText::DecorationOverline)){
            overPath.moveTo(tf.map(first+diff));
            overPath.lineTo(tf.map(last+diff));
        }
        if (decor.testFlag(KoSvgText::DecorationLineThrough)){
            middlePath.moveTo(tf.map(first+(diff*0.5)));
            middlePath.lineTo(tf.map(last+(diff*0.5)));
        }
    }
 
    const qreal freetypePixelsToPt = (1.0 / 64.0) * (72. / qMin(d->xRes, d->yRes));
    const qreal width = strokeWidth > 0 ? qMax(qreal(strokeWidth/qMax(1, end-(start+1)))*freetypePixelsToPt, minimum): minimum;
 
    stroker.setWidth(thick? width*2: width);
 
    QPainterPath final;
    if (decor.testFlag(KoSvgText::DecorationUnderline)){
        final.addPath(stroker.createStroke(underPath));
    }
    if (decor.testFlag(KoSvgText::DecorationOverline)){
        final.addPath(stroker.createStroke(overPath));
    }
    if (decor.testFlag(KoSvgText::DecorationLineThrough)){
        final.addPath(stroker.createStroke(middlePath));
    }
 
    return final;
}

References CharacterResult::advance, KoShape::anchor(), CursorInfo::caret, CursorPos::cluster, CharacterResult::cursorInfo, d, KoSvgText::Dashed, KoSvgText::DecorationLineThrough, KoSvgText::DecorationOverline, KoSvgText::DecorationUnderline, KoSvgText::Dotted, CharacterResult::finalTransform(), KoSvgText::HorizontalTB, CharacterResult::metrics, CursorPos::offset, CursorInfo::offsets, CursorInfo::rtl, KoSvgText::Solid, textProperties(), KoSvgText::FontMetrics::underlineThickness, and KoSvgTextProperties::WritingModeId.

◆ updateInternalShapesList()

void KoSvgTextShape::updateInternalShapesList ( )

inline

Definition at line 538 of file KoSvgTextShape_p.h.

                                    {
        if (shapeGroup) {
            internalShapesPainter->setShapes(shapeGroup->shapes());
        }
    }

◆ updateShapeGroup()

void KoSvgTextShape::updateShapeGroup ( )

inline

Definition at line 522 of file KoSvgTextShape_p.h.

                            {
        Q_FOREACH(KoShape *shape, shapeGroup->shapes()) {
            shapeGroup->removeShape(shape);
        }
        Q_FOREACH(KoShape *shape, shapesInside) {
            shapeGroup->addShape(shape);
        }
        Q_FOREACH(KoShape *shape, shapesSubtract) {
            shapeGroup->addShape(shape);
        }
        Q_FOREACH(KoShape *shape, textPaths) {
            shapeGroup->addShape(shape);
        }
        updateTextWrappingAreas();
        updateInternalShapesList();
    }

◆ updateTextWrappingAreas()

void KoSvgTextShape::updateTextWrappingAreas ( )

updateShapeContours The current shape contours can be slow to compute, so this function calls computing them, and then calls relayout();

◆ wordEnd()

int KoSvgTextShape::wordEnd ( int pos )

wordEnd return the pos of the first wordbreak.

Parameters

pos	– cursor position.

Returns: the first wordbreak or line end.

Definition at line 553 of file KoSvgTextShape.cpp.

{
    if (pos < 0 || pos >= d->cursorPos.size() || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
 
    int wordEnd = pos;
    for (int i = pos; i < d->cursorPos.size(); i++) {
        wordEnd = i;
        CursorPos cursorPos = d->cursorPos.at(i);
        bool isWhiteSpace = false;
        const CharacterResult res = d->result.at(cursorPos.cluster);
        const int pIndex = res.plaintTextIndex;
        if (pIndex >= 0 && pIndex < d->plainText.size()) {
            QChar c = d->plainText.at(pIndex);
            isWhiteSpace = KoCssTextUtils::IsCssWordSeparator(QString(c)) || c.isSpace();
        }
        if (res.breakType != BreakType::NoBreak
                && (cursorPos.offset == 0 || cursorPos.offset+1 == res.cursorInfo.offsets.size())
                && i > pos) {
 
            if (isWhiteSpace) {
                wordEnd = qMax(pos, wordEnd-1);
            }
            break;
        }
 
        // Also test the next cluster on whether it is a hardbreak. This is because hardbreaks by default get hidden.
        if (i < d->cursorPos.size()-1 && i > pos) {
            const CursorPos nextCursorPos = d->cursorPos.at(i+1);
            bool found = false;
            for (int j = cursorPos.cluster; j < nextCursorPos.cluster; j++) {
                if (d->result.at(j).breakType == BreakType::HardBreak && d->result.at(j).addressable) {
                    wordEnd = qMax(pos, wordEnd);
                    found = true;
                    break;
                }
            }
            if (found) {
                break;
            }
        }
    }
 
    return wordEnd;
}

References CharacterResult::breakType, CursorPos::cluster, CharacterResult::cursorInfo, cursorPos, d, HardBreak, KoCssTextUtils::IsCssWordSeparator(), isWhiteSpace(), NoBreak, CursorInfo::offsets, plainText, CharacterResult::plaintTextIndex, and wordEnd().

◆ wordLeft()

int KoSvgTextShape::wordLeft	(	int	pos,
		bool	visual = false )

wordLeft return the cursorpos for the word left or the extreme of the line.

Parameters

pos	the position.
visual	whether to flip for rtl.

Returns: the first pos before a wordbreak at the left.

Definition at line 362 of file KoSvgTextShape.cpp.

{
    //TODO: figure out preferred behaviour for wordLeft in RTL && visual.
    Q_UNUSED(visual)
    if (pos < 0 || pos > d->cursorPos.size()-1 || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    if (direction == KoSvgText::DirectionRightToLeft) {
        return wordEnd(pos);
    }
    return wordStart(pos);
}

References d, direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, textProperties(), wordEnd(), and wordStart().

◆ wordRight()

int KoSvgTextShape::wordRight	(	int	pos,
		bool	visual = false )

wordRight return the cursorpos for the word right or the extreme of the line.

Parameters

pos	the position.
visual	whether to flip for rtl.

Returns: the first word break at the right.

Definition at line 376 of file KoSvgTextShape.cpp.

{
    Q_UNUSED(visual)
    if (pos < 0 || pos > d->cursorPos.size()-1 || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
    KoSvgText::Direction direction = KoSvgText::Direction(this->textProperties().propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    if (direction == KoSvgText::DirectionRightToLeft) {
        return wordStart(pos);
    }
    return wordEnd(pos);
}

References d, direction(), KoSvgTextProperties::DirectionId, KoSvgText::DirectionRightToLeft, textProperties(), wordEnd(), and wordStart().

◆ wordStart()

int KoSvgTextShape::wordStart ( int pos )

wordStart return the first pos before a wordbreak in the start direction.

Parameters

pos	– cursor position

Returns: the first position before a wordbreak or the line start.

Definition at line 600 of file KoSvgTextShape.cpp.

{
    if (pos <= 0 || pos > d->cursorPos.size() || d->result.isEmpty() || d->cursorPos.isEmpty()) {
        return pos;
    }
 
    int wordStart = pos;
    for (int i = pos; i >= 0; i--) {
        wordStart = i;
        CursorPos cursorPos = d->getCursorPos(i);
        const CharacterResult res = d->result.at(cursorPos.cluster);
        if (res.breakType != BreakType::NoBreak
                && (cursorPos.offset == 0 || cursorPos.offset+1 == res.cursorInfo.offsets.size())
                && i < pos) {
            break;
        }
        // Also test the previous cluster on whether it is a hardbreak. This is because hardbreaks by default get hidden.
        if (i > 1 && i < pos) {
            const CursorPos prevCursorPos = d->getCursorPos(i-1);
            bool found = false;
            for (int j = cursorPos.cluster; j > prevCursorPos.cluster; j--) {
                if (d->result.at(j).breakType == BreakType::HardBreak && d->result.at(j).addressable) {
                    wordStart = qMin(pos, i-1);
                    found = true;
                    break;
                }
            }
            if (found) {
                break;
            }
        }
    }
 
    return wordStart;
}

References CharacterResult::breakType, CursorPos::cluster, CharacterResult::cursorInfo, cursorPos, d, HardBreak, NoBreak, CursorInfo::offsets, and wordStart().

◆ writingMode()

KoSvgText::WritingMode KoSvgTextShape::writingMode ( ) const

writingMode There's a number of places we need to check the writing mode to provide proper controls.

Returns: the writing mode of this text.

Definition at line 1647 of file KoSvgTextShape.cpp.

{
    return KoSvgText::WritingMode(this->textProperties().propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
}

References textProperties(), and KoSvgTextProperties::WritingModeId.

Friends And Related Symbol Documentation

◆ KoSvgTextLoader

friend class KoSvgTextLoader

friend

Definition at line 684 of file KoSvgTextShape.h.

◆ TestSvgText

friend class TestSvgText

friend

Definition at line 683 of file KoSvgTextShape.h.

Member Data Documentation

◆ bulkActionState

std::optional<BulkActionState> KoSvgTextShape::bulkActionState

Definition at line 557 of file KoSvgTextShape_p.h.

◆ currentTextWrappingAreas

QList<QPainterPath> KoSvgTextShape::currentTextWrappingAreas

Definition at line 563 of file KoSvgTextShape_p.h.

◆ cursorPos

QVector<CursorPos> KoSvgTextShape::cursorPos

Definition at line 591 of file KoSvgTextShape_p.h.

◆ d

QScopedPointer<Private> KoSvgTextShape::d

private

Definition at line 711 of file KoSvgTextShape.h.

◆ disableFontMatching

bool KoSvgTextShape::disableFontMatching = false

Turn off font matching, which should speed up relayout slightly.

Definition at line 586 of file KoSvgTextShape_p.h.

◆ initialTextPosition

QPointF KoSvgTextShape::initialTextPosition = QPointF()

Definition at line 596 of file KoSvgTextShape_p.h.

◆ internalShapesPainter

QScopedPointer<KoShapePainter> KoSvgTextShape::internalShapesPainter

Definition at line 515 of file KoSvgTextShape_p.h.

◆ isBidi

bool KoSvgTextShape::isBidi = false

Definition at line 595 of file KoSvgTextShape_p.h.

◆ isLoading

bool KoSvgTextShape::isLoading = false

Turned on when loading in text data, blocks updates to shape listeners.

Definition at line 584 of file KoSvgTextShape_p.h.

◆ lineBoxes

QVector<LineBox> KoSvgTextShape::lineBoxes

Definition at line 589 of file KoSvgTextShape_p.h.

◆ logicalToVisualCursorPos

QMap<int, int> KoSvgTextShape::logicalToVisualCursorPos

Definition at line 592 of file KoSvgTextShape_p.h.

◆ plainText

QString KoSvgTextShape::plainText

Definition at line 594 of file KoSvgTextShape_p.h.

◆ result

QVector<CharacterResult> KoSvgTextShape::result

Definition at line 588 of file KoSvgTextShape_p.h.

◆ shapeGroup

QScopedPointer<KoShapeGroup> KoSvgTextShape::shapeGroup

Definition at line 516 of file KoSvgTextShape_p.h.

◆ shapesInside

QList< KoShape * > KoSvgTextShape::shapesInside

Definition at line 559 of file KoSvgTextShape_p.h.

◆ shapesSubtract

QList< KoShape * > KoSvgTextShape::shapesSubtract

Definition at line 560 of file KoSvgTextShape_p.h.

◆ textData

KisForest<KoSvgTextContentElement> KoSvgTextShape::textData

Definition at line 583 of file KoSvgTextShape_p.h.

◆ textPaths

QList<KoShape*> KoSvgTextShape::textPaths

Definition at line 561 of file KoSvgTextShape_p.h.

◆ xRes

int KoSvgTextShape::xRes = 72

Definition at line 512 of file KoSvgTextShape_p.h.

◆ yRes

int KoSvgTextShape::yRes = 72

Definition at line 513 of file KoSvgTextShape_p.h.

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

libs/flake/text/KoSvgTextShape.h
libs/flake/text/KoSvgTextShape_p.h
libs/flake/text/KoSvgTextShape.cpp

index	- index (not cursorpos!) of the start position.
length	- total length of text to remove.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ DebugElement

◆ InternalShapeState

◆ TextType

Constructor & Destructor Documentation

◆ KoSvgTextShape() [1/2]

◆ KoSvgTextShape() [2/2]

◆ ~KoSvgTextShape()

◆ ~Private()

Member Function Documentation

◆ addShapeContours()

◆ addTextPathAtEnd()

◆ anchoredChunkShift()

◆ applyAnchoring()

◆ applyTextLength()

◆ applyTextPath()

◆ applyWhiteSpace()

◆ applyWhiteSpaceImpl()

◆ background()

◆ boundingBoxFromTree()

◆ boundingRect()

◆ characterResultOnPath()

◆ childCount()

◆ cleanUp() [1/2]

◆ cleanUp() [2/2]

◆ cleanUpImpl()

◆ clearAssociatedOutlines()

◆ cloneShape()

◆ collapsedWhiteSpacesForText()

◆ collectPaths()

◆ collectSubChunks()

◆ computeFontMetrics()

◆ computeTextDecorations()

◆ convertCharTransformsToPreformatted()

◆ copyRange()

◆ createTextNodeIndex()

◆ cursorForPos()

◆ debugParsing()

◆ defaultCursorShape()

◆ defaultPlaceholderText()

◆ direction()

◆ endBulkAction()

◆ enterNodeSubtree()

◆ finalizeDecoration()

◆ findNodeIndexForPropertyId()

◆ findRangeForNodeIndex()

◆ findTextContentElementForIndex()

◆ findTopLevelParent()

◆ fontMatchingDisabled()

◆ generateDecorationPaths()

◆ generateShapes()

◆ generateTextAreas()

◆ getCursorPos()

◆ getLigatureCarets()

◆ getMemento()

◆ getPositionsAndRotationsForRange()

◆ handleLineBoxAlignment()

◆ handleShapes()

◆ indexForPos()

◆ initialTextPosition()

◆ insertNewLinesAtAnchors()

◆ insertNewLinesAtAnchorsImpl()

◆ insertRichText()

◆ insertText()

◆ insertTransforms()

◆ insertTransformsImpl()

◆ internalShapeManager()

◆ internalShapes()

◆ iteratorForTreeIndex()